MAME SVN History

199869 Revisions

r31542 Thursday 7th August, 2014 at 08:35:31 UTC by Miodrag Milanović
(OSD BRANCH) win_window_info to class, partial (nw)

[/branches/osd/src/osd/modules/debugger]	debugwin.c
[/branches/osd/src/osd/modules/sound]	direct_sound.c
[/branches/osd/src/osd/windows]	d3dhlsl.c drawd3d.c drawdd.c drawgdi.c drawnone.c input.c video.c window.c window.h winmain.c

branches/osd/src/osd/modules/debugger/debugwin.c
r31541	r31542
512	512	// create the window
513	513	info->handler = handler;
514	514	info->wnd = win_create_window_ex_utf8(DEBUG_WINDOW_STYLE_EX, "MAMEDebugWindow", title, DEBUG_WINDOW_STYLE,
515		0, 0, 100, 100, win_window_list->hwnd, create_standard_menubar(), GetModuleHandle(NULL), info);
	515	0, 0, 100, 100, win_window_list->m_hwnd, create_standard_menubar(), GetModuleHandle(NULL), info);
516	516	if (info->wnd == NULL)
517	517	goto cleanup;
518	518
r31541	r31542
3074	3074	{
3075	3075	debugwin_info *info;
3076	3076	if (!show)
3077		SetForegroundWindow(win_window_list->hwnd);
	3077	SetForegroundWindow(win_window_list->m_hwnd);
3078	3078	for (info = window_list; info != NULL; info = info->next)
3079	3079	smart_show_window(info->wnd, show);
3080	3080	}

branches/osd/src/osd/modules/sound/direct_sound.c
r31541	r31542
234	234	}
235	235
236	236	// set the cooperative level
237		result = IDirectSound_SetCooperativeLevel(dsound, win_window_list->hwnd, DSSCL_PRIORITY);
	237	result = IDirectSound_SetCooperativeLevel(dsound, win_window_list->m_hwnd, DSSCL_PRIORITY);
238	238	if (result != DS_OK)
239	239	{
240	240	osd_printf_error("Error setting DirectSound cooperative level: %08x\n", (UINT32)result);

branches/osd/src/osd/windows/input.c
r31541	r31542
614	614	POINT mousepos;
615	615
616	616	// get the position relative to the window
617		GetClientRect(win_window_list->hwnd, &client_rect);
	617	GetClientRect(win_window_list->m_hwnd, &client_rect);
618	618	mousepos.x = x;
619	619	mousepos.y = y;
620		ScreenToClient(win_window_list->hwnd, &mousepos);
	620	ScreenToClient(win_window_list->m_hwnd, &mousepos);
621	621
622	622	// convert to absolute coordinates
623	623	devinfo->mouse.state.lX = normalize_absolute_axis(mousepos.x, client_rect.left, client_rect.right);
r31541	r31542
1043	1043	RECT client_rect;
1044	1044
1045	1045	// get the position relative to the window
1046		GetClientRect(win_window_list->hwnd, &client_rect);
1047		ScreenToClient(win_window_list->hwnd, &mousepos);
	1046	GetClientRect(win_window_list->m_hwnd, &client_rect);
	1047	ScreenToClient(win_window_list->m_hwnd, &mousepos);
1048	1048
1049	1049	// convert to absolute coordinates
1050	1050	xpos = normalize_absolute_axis(mousepos.x, client_rect.left, client_rect.right);
r31541	r31542
1218	1218	}
1219	1219
1220	1220	// set the cooperative level
1221		result = IDirectInputDevice_SetCooperativeLevel(devinfo->dinput.device, win_window_list->hwnd, cooperative_level);
	1221	result = IDirectInputDevice_SetCooperativeLevel(devinfo->dinput.device, win_window_list->m_hwnd, cooperative_level);
1222	1222	if (result != DI_OK)
1223	1223	goto error;
1224	1224	return devinfo;
r31541	r31542
1702	1702	reglist[regcount].usUsagePage = 0x01;
1703	1703	reglist[regcount].usUsage = 0x06;
1704	1704	reglist[regcount].dwFlags = RIDEV_INPUTSINK;
1705		reglist[regcount].hwndTarget = win_window_list->hwnd;
	1705	reglist[regcount].hwndTarget = win_window_list->m_hwnd;
1706	1706	regcount++;
1707	1707	}
1708	1708	if (mouse_list != NULL)
r31541	r31542
1710	1710	reglist[regcount].usUsagePage = 0x01;
1711	1711	reglist[regcount].usUsage = 0x02;
1712	1712	reglist[regcount].dwFlags = 0;
1713		reglist[regcount].hwndTarget = win_window_list->hwnd;
	1713	reglist[regcount].hwndTarget = win_window_list->m_hwnd;
1714	1714	regcount++;
1715	1715	}
1716	1716

branches/osd/src/osd/windows/winmain.c
r31541	r31542
494	494	winwindow_toggle_full_screen();
495	495
496	496	vsnprintf(buffer, ARRAY_LENGTH(buffer), format, argptr);
497		win_message_box_utf8(win_window_list ? win_window_list->hwnd : NULL, buffer, emulator_info::get_appname(), MB_OK);
	497	win_message_box_utf8(win_window_list ? win_window_list->m_hwnd : NULL, buffer, emulator_info::get_appname(), MB_OK);
498	498	}
499	499
500	500
r31541	r31542
625	625
626	626	// notify listeners of screen configuration
627	627	astring tempstring;
628		for (win_window_info *info = win_window_list; info != NULL; info = info->next)
	628	for (win_window_info *info = win_window_list; info != NULL; info = info->m_next)
629	629	{
630		char *tmp = utf8_from_tstring(info->monitor->info.szDevice);
	630	char *tmp = utf8_from_tstring(info->m_monitor->info.szDevice);
631	631	tempstring.printf("Orientation(%s)", tmp);
632		output_set_value(tempstring, info->targetorient);
	632	output_set_value(tempstring, info->m_targetorient);
633	633	osd_free(tmp);
634	634	}
635	635

branches/osd/src/osd/windows/drawdd.c
r31541	r31542
219	219
220	220	// allocate memory for our structures
221	221	dd = global_alloc_clear(dd_info);
222		window->drawdata = dd;
	222	window->m_drawdata = dd;
223	223
224	224	// configure the adapter for the mode we want
225	225	if (config_adapter_mode(window))
r31541	r31542
245	245
246	246	static void drawdd_window_destroy(win_window_info *window)
247	247	{
248		dd_info dd = (dd_info )window->drawdata;
	248	dd_info dd = (dd_info )window->m_drawdata;
249	249
250	250	// skip if nothing
251	251	if (dd == NULL)
r31541	r31542
256	256
257	257	// free the memory in the window
258	258	global_free(dd);
259		window->drawdata = NULL;
	259	window->m_drawdata = NULL;
260	260	}
261	261
262	262
r31541	r31542
267	267
268	268	static render_primitive_list drawdd_window_get_primitives(win_window_info window)
269	269	{
270		dd_info dd = (dd_info )window->drawdata;
	270	dd_info dd = (dd_info )window->m_drawdata;
271	271
272	272	compute_blit_surface_size(window);
273		window->target->set_bounds(dd->blitwidth, dd->blitheight, 0);
274		window->target->set_max_update_rate((dd->refresh == 0) ? dd->origmode.dwRefreshRate : dd->refresh);
	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	275
276		return &window->target->get_primitives();
	276	return &window->m_target->get_primitives();
277	277	}
278	278
279	279
r31541	r31542
284	284
285	285	static int drawdd_window_draw(win_window_info *window, HDC dc, int update)
286	286	{
287		dd_info dd = (dd_info )window->drawdata;
	287	dd_info dd = (dd_info )window->m_drawdata;
288	288	render_primitive *prim;
289	289	int usemembuffer = FALSE;
290	290	HRESULT result;
r31541	r31542
324	324	}
325	325
326	326	// render to it
327		window->primlist->acquire_lock();
	327	window->m_primlist->acquire_lock();
328	328
329	329	// scan the list of primitives for tricky stuff
330		for (prim = window->primlist->first(); prim != NULL; prim = prim->next())
	330	for (prim = window->m_primlist->first(); prim != NULL; prim = prim->next())
331	331	if (PRIMFLAG_GET_BLENDMODE(prim->flags) != BLENDMODE_NONE \|\|
332	332	(prim->texture.base != NULL && PRIMFLAG_GET_TEXFORMAT(prim->flags) == TEXFORMAT_ARGB32))
333	333	{
r31541	r31542
343	343	// based on the target format, use one of our standard renderers
344	344	switch (dd->blitdesc.ddpfPixelFormat.dwRBitMask)
345	345	{
346		case 0x00ff0000: software_renderer<UINT32, 0,0,0, 16,8,0>::draw_primitives(*window->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->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->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->primlist, dd->membuffer, dd->blitwidth, dd->blitheight, dd->blitwidth); break;
	346	case 0x00ff0000: software_renderer<UINT32, 0,0,0, 16,8,0>::draw_primitives(*window->m_primlist, dd->membuffer, dd->blitwidth, dd->blitheight, dd->blitwidth); break;
	347	case 0x000000ff: software_renderer<UINT32, 0,0,0, 0,8,16>::draw_primitives(*window->m_primlist, dd->membuffer, dd->blitwidth, dd->blitheight, dd->blitwidth); break;
	348	case 0xf800: software_renderer<UINT16, 3,2,3, 11,5,0>::draw_primitives(*window->m_primlist, dd->membuffer, dd->blitwidth, dd->blitheight, dd->blitwidth); break;
	349	case 0x7c00: software_renderer<UINT16, 3,3,3, 10,5,0>::draw_primitives(*window->m_primlist, dd->membuffer, dd->blitwidth, dd->blitheight, dd->blitwidth); break;
350	350	default:
351	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);
352	352	break;
r31541	r31542
379	379	// based on the target format, use one of our standard renderers
380	380	switch (dd->blitdesc.ddpfPixelFormat.dwRBitMask)
381	381	{
382		case 0x00ff0000: software_renderer<UINT32, 0,0,0, 16,8,0, true>::draw_primitives(*window->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->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->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->primlist, dd->blitdesc.lpSurface, dd->blitwidth, dd->blitheight, dd->blitdesc.lPitch / 2); break;
	382	case 0x00ff0000: software_renderer<UINT32, 0,0,0, 16,8,0, true>::draw_primitives(*window->m_primlist, dd->blitdesc.lpSurface, dd->blitwidth, dd->blitheight, dd->blitdesc.lPitch / 4); break;
	383	case 0x000000ff: software_renderer<UINT32, 0,0,0, 0,8,16, true>::draw_primitives(*window->m_primlist, dd->blitdesc.lpSurface, dd->blitwidth, dd->blitheight, dd->blitdesc.lPitch / 4); break;
	384	case 0xf800: software_renderer<UINT16, 3,2,3, 11,5,0, true>::draw_primitives(*window->m_primlist, dd->blitdesc.lpSurface, dd->blitwidth, dd->blitheight, dd->blitdesc.lPitch / 2); break;
	385	case 0x7c00: software_renderer<UINT16, 3,3,3, 10,5,0, true>::draw_primitives(*window->m_primlist, dd->blitdesc.lpSurface, dd->blitwidth, dd->blitheight, dd->blitdesc.lPitch / 2); break;
386	386	default:
387	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);
388	388	break;
389	389	}
390	390	}
391		window->primlist->release_lock();
	391	window->m_primlist->release_lock();
392	392
393	393	// unlock and blit
394	394	result = IDirectDrawSurface7_Unlock(dd->blit, NULL);
395	395	if (result != DD_OK) osd_printf_verbose("DirectDraw: Error %08X unlocking blit surface\n", (int)result);
396	396
397	397	// sync to VBLANK
398		if ((video_config.waitvsync \|\| video_config.syncrefresh) && window->machine().video().throttled() && (!window->fullscreen \|\| dd->back == NULL))
	398	if ((video_config.waitvsync \|\| video_config.syncrefresh) && window->machine().video().throttled() && (!window->m_fullscreen \|\| dd->back == NULL))
399	399	{
400	400	result = IDirectDraw7_WaitForVerticalBlank(dd->ddraw, DDWAITVB_BLOCKBEGIN, NULL);
401	401	if (result != DD_OK) osd_printf_verbose("DirectDraw: Error %08X waiting for VBLANK\n", (int)result);
r31541	r31542
414	414
415	415	static int ddraw_create(win_window_info *window)
416	416	{
417		dd_info dd = (dd_info )window->drawdata;
	417	dd_info dd = (dd_info )window->m_drawdata;
418	418	HRESULT result;
419	419	int verify;
420	420
r31541	r31542
442	442
443	443	// set the cooperative level
444	444	// for non-window modes, we will use full screen here
445		result = IDirectDraw7_SetCooperativeLevel(dd->ddraw, win_window_list->hwnd, DDSCL_SETFOCUSWINDOW);
	445	result = IDirectDraw7_SetCooperativeLevel(dd->ddraw, win_window_list->m_hwnd, DDSCL_SETFOCUSWINDOW);
446	446	if (result != DD_OK)
447	447	{
448	448	osd_printf_verbose("DirectDraw: Error %08X during IDirectDraw7_SetCooperativeLevel(FOCUSWINDOW) call\n", (int)result);
449	449	goto error;
450	450	}
451		result = IDirectDraw7_SetCooperativeLevel(dd->ddraw, window->hwnd, DDSCL_SETDEVICEWINDOW \| (window->fullscreen ? DDSCL_FULLSCREEN \| DDSCL_EXCLUSIVE : DDSCL_NORMAL));
	451	result = IDirectDraw7_SetCooperativeLevel(dd->ddraw, window->m_hwnd, DDSCL_SETDEVICEWINDOW \| (window->m_fullscreen ? DDSCL_FULLSCREEN \| DDSCL_EXCLUSIVE : DDSCL_NORMAL));
452	452	if (result != DD_OK)
453	453	{
454	454	osd_printf_verbose("DirectDraw: Error %08X during IDirectDraw7_SetCooperativeLevel(DEVICEWINDOW) call\n", (int)result);
r31541	r31542
456	456	}
457	457
458	458	// full screen mode: set the resolution
459		if (window->fullscreen && video_config.switchres)
	459	if (window->m_fullscreen && video_config.switchres)
460	460	{
461	461	result = IDirectDraw7_SetDisplayMode(dd->ddraw, dd->width, dd->height, 32, dd->refresh, 0);
462	462	if (result != DD_OK)
r31541	r31542
481	481
482	482	static int ddraw_create_surfaces(win_window_info *window)
483	483	{
484		dd_info dd = (dd_info )window->drawdata;
	484	dd_info dd = (dd_info )window->m_drawdata;
485	485	HRESULT result;
486	486
487	487	// make a description of the primary surface
r31541	r31542
491	491	dd->primarydesc.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
492	492
493	493	// for triple-buffered full screen mode, allocate flipping surfaces
494		if (window->fullscreen && video_config.triplebuf)
	494	if (window->m_fullscreen && video_config.triplebuf)
495	495	{
496	496	dd->primarydesc.dwFlags \|= DDSD_BACKBUFFERCOUNT;
497	497	dd->primarydesc.ddsCaps.dwCaps \|= DDSCAPS_FLIP \| DDSCAPS_COMPLEX;
r31541	r31542
504	504
505	505	// full screen mode: get the back surface
506	506	dd->back = NULL;
507		if (window->fullscreen && video_config.triplebuf)
	507	if (window->m_fullscreen && video_config.triplebuf)
508	508	{
509	509	DDSCAPS2 caps = { DDSCAPS_BACKBUFFER };
510	510	result = IDirectDrawSurface7_GetAttachedSurface(dd->primary, &caps, &dd->back);
r31541	r31542
544	544	goto error;
545	545
546	546	// create a clipper for windowed mode
547		if (!window->fullscreen && create_clipper(window))
	547	if (!window->m_fullscreen && create_clipper(window))
548	548	goto error;
549	549
550	550	// full screen mode: set the gamma
551		if (window->fullscreen)
	551	if (window->m_fullscreen)
552	552	{
553	553	// only set the gamma if it's not 1.0f
554	554	windows_options &options = downcast<windows_options &>(window->machine().options());
r31541	r31542
600	600
601	601	static void ddraw_delete(win_window_info *window)
602	602	{
603		dd_info dd = (dd_info )window->drawdata;
	603	dd_info dd = (dd_info )window->m_drawdata;
604	604
605	605	// free surfaces
606	606	ddraw_delete_surfaces(window);
r31541	r31542
610	610	IDirectDraw7_RestoreDisplayMode(dd->ddraw);
611	611
612	612	// reset cooperative level
613		if (dd->ddraw != NULL && window->hwnd != NULL)
614		IDirectDraw7_SetCooperativeLevel(dd->ddraw, window->hwnd, DDSCL_NORMAL);
	613	if (dd->ddraw != NULL && window->m_hwnd != NULL)
	614	IDirectDraw7_SetCooperativeLevel(dd->ddraw, window->m_hwnd, DDSCL_NORMAL);
615	615
616	616	// release the DirectDraw object itself
617	617	if (dd->ddraw != NULL)
r31541	r31542
627	627
628	628	static void ddraw_delete_surfaces(win_window_info *window)
629	629	{
630		dd_info dd = (dd_info )window->drawdata;
	630	dd_info dd = (dd_info )window->m_drawdata;
631	631
632	632	// release the gamma control
633	633	if (dd->gamma != NULL)
r31541	r31542
699	699
700	700	static int ddraw_test_cooperative(win_window_info *window)
701	701	{
702		dd_info dd = (dd_info )window->drawdata;
	702	dd_info dd = (dd_info )window->m_drawdata;
703	703	HRESULT result;
704	704
705	705	// check our current status; if we lost the device, punt to GDI
r31541	r31542
769	769
770	770	static int create_clipper(win_window_info *window)
771	771	{
772		dd_info dd = (dd_info )window->drawdata;
	772	dd_info dd = (dd_info )window->m_drawdata;
773	773	HRESULT result;
774	774
775	775	// create a clipper for the primary surface
r31541	r31542
781	781	}
782	782
783	783	// set the clipper's hwnd
784		result = IDirectDrawClipper_SetHWnd(dd->clipper, 0, window->hwnd);
	784	result = IDirectDrawClipper_SetHWnd(dd->clipper, 0, window->m_hwnd);
785	785	if (result != DD_OK)
786	786	{
787	787	osd_printf_verbose("DirectDraw: Error %08X setting clipper hwnd\n", (int)result);
r31541	r31542
806	806
807	807	static void compute_blit_surface_size(win_window_info *window)
808	808	{
809		dd_info dd = (dd_info )window->drawdata;
	809	dd_info dd = (dd_info )window->m_drawdata;
810	810	INT32 newwidth, newheight;
811	811	int xscale, yscale;
812	812	RECT client;
813	813
814	814	// start with the minimum size
815		window->target->compute_minimum_size(newwidth, newheight);
	815	window->m_target->compute_minimum_size(newwidth, newheight);
816	816
817	817	// get the window's client rectangle
818		GetClientRect(window->hwnd, &client);
	818	GetClientRect(window->m_hwnd, &client);
819	819
820	820	// hardware stretch case: apply prescale
821	821	if (video_config.hwstretch)
r31541	r31542
842	842	if (video_config.keepaspect)
843	843	{
844	844	win_monitor_info *monitor = winwindow_video_window_monitor(window, NULL);
845		window->target->compute_visible_area(target_width, target_height, monitor->get_aspect(), window->target->orientation(), target_width, target_height);
	845	window->m_target->compute_visible_area(target_width, target_height, monitor->get_aspect(), window->m_target->orientation(), target_width, target_height);
846	846	desired_aspect = (float)target_width / (float)target_height;
847	847	}
848	848
r31541	r31542
930	930
931	931	static void blit_to_primary(win_window_info *window, int srcwidth, int srcheight)
932	932	{
933		dd_info dd = (dd_info )window->drawdata;
	933	dd_info dd = (dd_info )window->m_drawdata;
934	934	IDirectDrawSurface7 *target = (dd->back != NULL) ? dd->back : dd->primary;
935	935	win_monitor_info *monitor = winwindow_video_window_monitor(window, NULL);
936	936	DDBLTFX blitfx = { sizeof(DDBLTFX) };
r31541	r31542
944	944	source.bottom = srcheight;
945	945
946	946	// compute outer rect -- windowed version
947		if (!window->fullscreen)
	947	if (!window->m_fullscreen)
948	948	{
949		GetClientRect(window->hwnd, &outer);
950		ClientToScreen(window->hwnd, &((LPPOINT)&outer)[0]);
951		ClientToScreen(window->hwnd, &((LPPOINT)&outer)[1]);
	949	GetClientRect(window->m_hwnd, &outer);
	950	ClientToScreen(window->m_hwnd, &((LPPOINT)&outer)[0]);
	951	ClientToScreen(window->m_hwnd, &((LPPOINT)&outer)[1]);
952	952
953	953	// adjust to be relative to the monitor
954	954	outer.left -= monitor->info.rcMonitor.left;
r31541	r31542
987	987	else if (video_config.keepaspect)
988	988	{
989	989	// compute the appropriate visible area
990		window->target->compute_visible_area(rect_width(&outer), rect_height(&outer), monitor->get_aspect(), window->target->orientation(), dstwidth, dstheight);
	990	window->m_target->compute_visible_area(rect_width(&outer), rect_height(&outer), monitor->get_aspect(), window->m_target->orientation(), dstwidth, dstheight);
991	991	}
992	992
993	993	// center within
r31541	r31542
1050	1050	if (result != DD_OK) osd_printf_verbose("DirectDraw: Error %08X blitting to the screen\n", (int)result);
1051	1051
1052	1052	// page flip if triple buffered
1053		if (window->fullscreen && dd->back != NULL)
	1053	if (window->m_fullscreen && dd->back != NULL)
1054	1054	{
1055	1055	result = IDirectDrawSurface7_Flip(dd->primary, NULL, DDFLIP_WAIT);
1056	1056	if (result != DD_OK) osd_printf_verbose("DirectDraw: Error %08X waiting for VBLANK\n", (int)result);
r31541	r31542
1066	1066	static int config_adapter_mode(win_window_info *window)
1067	1067	{
1068	1068	DDDEVICEIDENTIFIER2 identifier;
1069		dd_info dd = (dd_info )window->drawdata;
	1069	dd_info dd = (dd_info )window->m_drawdata;
1070	1070	HRESULT result;
1071	1071
1072	1072	// choose the monitor number
1073		get_adapter_for_monitor(dd, window->monitor);
	1073	get_adapter_for_monitor(dd, window->m_monitor);
1074	1074
1075	1075	// create a temporary DirectDraw object
1076	1076	result = (directdrawcreateex)(dd->adapter_ptr, (LPVOID )&dd->ddraw, WRAP_REFIID(IID_IDirectDraw7), NULL);
r31541	r31542
1101	1101	}
1102	1102
1103	1103	// choose a resolution: full screen mode case
1104		if (window->fullscreen)
	1104	if (window->m_fullscreen)
1105	1105	{
1106	1106	// default to the current mode exactly
1107	1107	dd->width = dd->origmode.dwWidth;
r31541	r31542
1118	1118	dd->ddraw = NULL;
1119	1119
1120	1120	// if we're not changing resolutions, make sure we have a resolution we can handle
1121		if (!window->fullscreen \|\| !video_config.switchres)
	1121	if (!window->m_fullscreen \|\| !video_config.switchres)
1122	1122	{
1123	1123	switch (dd->origmode.ddpfPixelFormat.dwRBitMask)
1124	1124	{
r31541	r31542
1195	1195	{
1196	1196	float size_score, refresh_score, final_score;
1197	1197	mode_enum_info einfo = (mode_enum_info )context;
1198		dd_info dd = (dd_info )einfo->window->drawdata;
	1198	dd_info dd = (dd_info )einfo->window->m_drawdata;
1199	1199
1200	1200	// skip non-32 bit modes
1201	1201	if (desc->ddpfPixelFormat.dwRGBBitCount != 32)
r31541	r31542
1213	1213	size_score *= 0.1f;
1214	1214
1215	1215	// if we're looking for a particular mode, that's a winner
1216		if (desc->dwWidth == einfo->window->maxwidth && desc->dwHeight == einfo->window->maxheight)
	1216	if (desc->dwWidth == einfo->window->m_maxwidth && desc->dwHeight == einfo->window->m_maxheight)
1217	1217	size_score = 2.0f;
1218	1218
1219	1219	// compute refresh score
r31541	r31542
1224	1224	refresh_score *= 0.1f;
1225	1225
1226	1226	// if we're looking for a particular refresh, make sure it matches
1227		if (desc->dwRefreshRate == einfo->window->refresh)
	1227	if (desc->dwRefreshRate == einfo->window->m_refresh)
1228	1228	refresh_score = 2.0f;
1229	1229
1230	1230	// weight size and refresh equally
r31541	r31542
1250	1250
1251	1251	static void pick_best_mode(win_window_info *window)
1252	1252	{
1253		dd_info dd = (dd_info )window->drawdata;
	1253	dd_info dd = (dd_info )window->m_drawdata;
1254	1254	mode_enum_info einfo;
1255	1255	HRESULT result;
1256	1256
r31541	r31542
1258	1258	// note: technically we should not be calling this from an alternate window
1259	1259	// thread; however, it is only done during init time, and the init code on
1260	1260	// the main thread is waiting for us to finish, so it is safe to do so here
1261		window->target->compute_minimum_size(einfo.minimum_width, einfo.minimum_height);
	1261	window->m_target->compute_minimum_size(einfo.minimum_width, einfo.minimum_height);
1262	1262
1263	1263	// use those as the target for now
1264	1264	einfo.target_width = einfo.minimum_width * MAX(1, video_config.prescale);

branches/osd/src/osd/windows/video.c
r31541	r31542
84	84	for (index = 0; index < video_config.numscreens; index++)
85	85	winwindow_video_window_create(machine(), index, pick_monitor(options, index), &video_config.window[index]);
86	86	if (video_config.mode != VIDEO_MODE_NONE)
87		SetForegroundWindow(win_window_list->hwnd);
	87	SetForegroundWindow(win_window_list->m_hwnd);
88	88
89	89	return true;
90	90	}
r31541	r31542
187	187
188	188	// if we're not skipping this redraw, update all windows
189	189	if (!skip_redraw)
190		for (win_window_info *window = win_window_list; window != NULL; window = window->next)
191		winwindow_video_window_update(window);
	190	for (win_window_info *window = win_window_list; window != NULL; window = window->m_next)
	191	window->update();
192	192
193	193	// poll the joystick values here
194	194	winwindow_process_events(machine(), TRUE, FALSE);

branches/osd/src/osd/windows/window.c
r31541	r31542
264	264	while (win_window_list != NULL)
265	265	{
266	266	win_window_info *temp = win_window_list;
267		win_window_list = temp->next;
	267	win_window_list = temp->m_next;
268	268	winwindow_video_window_destroy(temp);
269	269	}
270	270
r31541	r31542
293	293	}
294	294
295	295
	296	win_window_info::win_window_info(running_machine &machine)
	297	: m_next(NULL),
	298	m_init_state(0),
	299	m_hwnd(0),
	300	m_focus_hwnd(0),
	301	m_startmaximized(0),
	302	m_isminimized(0),
	303	m_ismaximized(0),
	304	m_resize_state(0),
	305	m_monitor(0),
	306	m_fullscreen(0),
	307	m_fullscreen_safe(0),
	308	m_maxwidth(0),
	309	m_maxheight(0),
	310	m_refresh(0),
	311	m_aspect(0),
	312	m_render_lock(NULL),
	313	m_target(NULL),
	314	m_targetview(0),
	315	m_targetorient(0),
	316	m_primlist(NULL),
	317	m_lastclicktime(0),
	318	m_lastclickx(0),
	319	m_lastclicky(0),
	320	m_drawdata(NULL),
	321	m_machine(machine)
	322	{
	323	memset(m_title,0,sizeof(m_title));
	324	m_non_fullscreen_bounds.left = 0;
	325	m_non_fullscreen_bounds.top = 0;
	326	m_non_fullscreen_bounds.right = 0;
	327	m_non_fullscreen_bounds.bottom = 0;
	328	}
296	329
	330	win_window_info::~win_window_info()
	331	{
	332	}
	333
	334
297	335	//============================================================
298	336	// winwindow_process_events_periodic
299	337	// (main thread)
r31541	r31542
321	359	{
322	360	win_window_info *window;
323	361
324		for (window = win_window_list; window != NULL; window = window->next)
325		if (window->hwnd == hwnd)
	362	for (window = win_window_list; window != NULL; window = window->m_next)
	363	if (window->m_hwnd == hwnd)
326	364	return TRUE;
327	365
328	366	return FALSE;
r31541	r31542
471	509	assert(GetCurrentThreadId() == main_threadid);
472	510
473	511	// iterate over windows and request a snap
474		for (window = win_window_list; window != NULL; window = window->next)
	512	for (window = win_window_list; window != NULL; window = window->m_next)
475	513	{
476	514	(*draw.window_save)(window);
477	515	}
r31541	r31542
494	532	assert(GetCurrentThreadId() == main_threadid);
495	533
496	534	// iterate over windows and request a snap
497		for (window = win_window_list; window != NULL; window = window->next)
	535	for (window = win_window_list; window != NULL; window = window->m_next)
498	536	{
499	537	(*draw.window_toggle_fsfx)(window);
500	538	}
r31541	r31542
517	555	assert(GetCurrentThreadId() == main_threadid);
518	556
519	557	// iterate over windows and request a snap
520		for (window = win_window_list; window != NULL; window = window->next)
	558	for (window = win_window_list; window != NULL; window = window->m_next)
521	559	{
522	560	(*draw.window_record)(window);
523	561	}
r31541	r31542
537	575	assert(GetCurrentThreadId() == main_threadid);
538	576
539	577	// if we are in debug mode, never go full screen
540		for (window = win_window_list; window != NULL; window = window->next)
	578	for (window = win_window_list; window != NULL; window = window->m_next)
541	579	if (window->machine().debug_flags & DEBUG_FLAG_OSD_ENABLED)
542	580	return;
543	581
r31541	r31542
545	583	video_config.windowed = !video_config.windowed;
546	584
547	585	// iterate over windows and toggle their fullscreen state
548		for (window = win_window_list; window != NULL; window = window->next)
549		SendMessage(window->hwnd, WM_USER_SET_FULLSCREEN, !video_config.windowed, 0);
550		SetForegroundWindow(win_window_list->hwnd);
	586	for (window = win_window_list; window != NULL; window = window->m_next)
	587	SendMessage(window->m_hwnd, WM_USER_SET_FULLSCREEN, !video_config.windowed, 0);
	588	SetForegroundWindow(win_window_list->m_hwnd);
551	589	}
552	590
553	591
r31541	r31542
563	601	win_window_info *window;
564	602
565	603	// see if one of the video windows has focus
566		for (window = win_window_list; window != NULL; window = window->next)
567		if (focuswnd == window->hwnd)
	604	for (window = win_window_list; window != NULL; window = window->m_next)
	605	if (focuswnd == window->m_hwnd)
568	606	return TRUE;
569	607
570	608	return FALSE;
r31541	r31542
601	639	GetCursorPos(&saved_cursor_pos);
602	640
603	641	// clip cursor to game video window
604		GetClientRect(window->hwnd, &bounds);
605		ClientToScreen(window->hwnd, &((POINT *)&bounds)[0]);
606		ClientToScreen(window->hwnd, &((POINT *)&bounds)[1]);
	642	GetClientRect(window->m_hwnd, &bounds);
	643	ClientToScreen(window->m_hwnd, &((POINT *)&bounds)[0]);
	644	ClientToScreen(window->m_hwnd, &((POINT *)&bounds)[1]);
607	645	ClipCursor(&bounds);
608	646	}
609	647	else
r31541	r31542
636	674	assert(GetCurrentThreadId() == main_threadid);
637	675
638	676	// allocate a new window object
639		window = global_alloc~~_clear~~(win_window_info(machine));
	677	window = global_alloc(win_window_info(machine));
640	678	//printf("%d, %d\n", config->width, config->height);
641		window->maxwidth = config->width;
642		window->maxheight = config->height;
643		window->refresh = config->refresh;
644		window->monitor = monitor;
645		window->fullscreen = !video_config.windowed;
	679	window->m_maxwidth = config->width;
	680	window->m_maxheight = config->height;
	681	window->m_refresh = config->refresh;
	682	window->m_monitor = monitor;
	683	window->m_fullscreen = !video_config.windowed;
646	684
647	685	// see if we are safe for fullscreen
648		window->fullscreen_safe = TRUE;
649		for (win = win_window_list; win != NULL; win = win->next)
650		if (win->monitor == monitor)
651		window->fullscreen_safe = FALSE;
	686	window->m_fullscreen_safe = TRUE;
	687	for (win = win_window_list; win != NULL; win = win->m_next)
	688	if (win->m_monitor == monitor)
	689	window->m_fullscreen_safe = FALSE;
652	690
653	691	// add us to the list
654	692	*last_window_ptr = window;
655		last_window_ptr = &window->next;
	693	last_window_ptr = &window->m_next;
656	694
657	695	// create a lock that we can use to skip blitting
658		window->render_lock = osd_lock_alloc();
	696	window->m_render_lock = osd_lock_alloc();
659	697
660	698	// load the layout
661		window->target = machine.render().target_alloc();
	699	window->m_target = machine.render().target_alloc();
662	700
663	701	// set the specific view
664	702	windows_options &options = downcast<windows_options &>(machine.options());
665	703	set_starting_view(index, window, options.view(index));
666	704
667	705	// remember the current values in case they change
668		window->targetview = window->target->view();
669		window->targetorient = window->target->orientation();
670		window->targetlayerconfig = window->target->layer_config();
	706	window->m_targetview = window->m_target->view();
	707	window->m_targetorient = window->m_target->orientation();
	708	window->m_targetlayerconfig = window->m_target->layer_config();
671	709
672	710	// make the window title
673	711	if (video_config.numscreens == 1)
674		sprintf(window->title, "%s: %s [%s]", emulator_info::get_appname(), machine.system().description, machine.system().name);
	712	sprintf(window->m_title, "%s: %s [%s]", emulator_info::get_appname(), machine.system().description, machine.system().name);
675	713	else
676		sprintf(window->title, "%s: %s [%s] - Screen %d", emulator_info::get_appname(), machine.system().description, machine.system().name, index);
	714	sprintf(window->m_title, "%s: %s [%s] - Screen %d", emulator_info::get_appname(), machine.system().description, machine.system().name, index);
677	715
678	716	// set the initial maximized state
679		window->startmaximized = options.maximize();
	717	window->m_startmaximized = options.maximize();
680	718
681	719	// finish the window creation on the window thread
682	720	if (multithreading_enabled)
r31541	r31542
685	723	WaitForSingleObject(window_thread_ready_event, INFINITE);
686	724
687	725	PostThreadMessage(window_threadid, WM_USER_FINISH_CREATE_WINDOW, 0, (LPARAM)window);
688		while (window->init_state == 0)
	726	while (window->m_init_state == 0)
689	727	{
690	728	winwindow_process_events(machine, 0, 1); //pump the message queue
691	729	Sleep(1);
692	730	}
693	731	}
694	732	else
695		window->init_state = complete_create(window) ? -1 : 1;
	733	window->m_init_state = complete_create(window) ? -1 : 1;
696	734
697	735	// handle error conditions
698		if (window->init_state == -1)
	736	if (window->m_init_state == -1)
699	737	fatalerror("Unable to complete window creation\n");
700	738	}
701	739
r31541	r31542
713	751	assert(GetCurrentThreadId() == main_threadid);
714	752
715	753	// remove us from the list
716		for (prevptr = &win_window_list; prevptr != NULL; prevptr = &(prevptr)->next)
	754	for (prevptr = &win_window_list; prevptr != NULL; prevptr = &(prevptr)->m_next)
717	755	if (*prevptr == window)
718	756	{
719		*prevptr = window->next;
	757	*prevptr = window->m_next;
720	758	break;
721	759	}
722	760
723	761	// destroy the window
724		if (window->hwnd != NULL)
725		SendMessage(window->hwnd, WM_USER_SELF_TERMINATE, 0, 0);
	762	if (window->m_hwnd != NULL)
	763	SendMessage(window->m_hwnd, WM_USER_SELF_TERMINATE, 0, 0);
726	764
727	765	// free the render target
728		window->machine().render().target_free(window->target);
	766	window->machine().render().target_free(window->m_target);
729	767
730	768	// free the lock
731		osd_lock_free(window->render_lock);
	769	osd_lock_free(window->m_render_lock);
732	770
733	771	// free the window itself
734	772	global_free(window);
r31541	r31542
741	779	// (main thread)
742	780	//============================================================
743	781
744		void winwindow_vi~~deo_wi~~ndow_update(~~win_window_info *window~~)
	782	void win_window_info::update()
745	783	{
746	784	int targetview, targetorient;
747	785	render_layer_config targetlayerconfig;
r31541	r31542
751	789	mtlog_add("winwindow_video_window_update: begin");
752	790
753	791	// see if the target has changed significantly in window mode
754		targetview = window->target->view();
755		targetorient = window->target->orientation();
756		targetlayerconfig = window->target->layer_config();
757		if (targetview != window->targetview \|\| targetorient != window->targetorient \|\| targetlayerconfig != window->targetlayerconfig)
	792	targetview = m_target->view();
	793	targetorient = m_target->orientation();
	794	targetlayerconfig = m_target->layer_config();
	795	if (targetview != m_targetview \|\| targetorient != m_targetorient \|\| targetlayerconfig != m_targetlayerconfig)
758	796	{
759		window->targetview = targetview;
760		window->targetorient = targetorient;
761		window->targetlayerconfig = targetlayerconfig;
	797	m_targetview = targetview;
	798	m_targetorient = targetorient;
	799	m_targetlayerconfig = targetlayerconfig;
762	800
763	801	// in window mode, reminimize/maximize
764		if (!~~window->~~fullscreen)
	802	if (!m_fullscreen)
765	803	{
766		if (window->isminimized)
767		SendMessage(window->hwnd, WM_USER_SET_MINSIZE, 0, 0);
768		if (window->ismaximized)
769		SendMessage(window->hwnd, WM_USER_SET_MAXSIZE, 0, 0);
	804	if (m_isminimized)
	805	SendMessage(m_hwnd, WM_USER_SET_MINSIZE, 0, 0);
	806	if (m_ismaximized)
	807	SendMessage(m_hwnd, WM_USER_SET_MAXSIZE, 0, 0);
770	808	}
771	809	}
772	810
773	811	// if we're visible and running and not in the middle of a resize, draw
774		if (~~window->~~hwnd != NULL && ~~window->~~target != NULL && ~~window->~~drawdata != NULL)
	812	if (m_hwnd != NULL && m_target != NULL && m_drawdata != NULL)
775	813	{
776	814	int got_lock = TRUE;
777	815
778	816	mtlog_add("winwindow_video_window_update: try lock");
779	817
780	818	// only block if we're throttled
781		if (window->machine().video().throttled() \|\| timeGetTime() - last_update_time > 250)
782		osd_lock_acquire(window->render_lock);
	819	if (machine().video().throttled() \|\| timeGetTime() - last_update_time > 250)
	820	osd_lock_acquire(m_render_lock);
783	821	else
784		got_lock = osd_lock_try(~~window->~~render_lock);
	822	got_lock = osd_lock_try(m_render_lock);
785	823
786	824	// only render if we were able to get the lock
787	825	if (got_lock)
r31541	r31542
791	829	mtlog_add("winwindow_video_window_update: got lock");
792	830
793	831	// don't hold the lock; we just used it to see if rendering was still happening
794		osd_lock_release(~~window->~~render_lock);
	832	osd_lock_release(m_render_lock);
795	833
796	834	// ensure the target bounds are up-to-date, and then get the primitives
797		primlist = (*draw.window_get_primitives)(wi~~ndow~~);
	835	primlist = (*draw.window_get_primitives)(this);
798	836
799	837	// post a redraw request with the primitive list as a parameter
800	838	last_update_time = timeGetTime();
801	839	mtlog_add("winwindow_video_window_update: PostMessage start");
802	840	if (multithreading_enabled)
803		PostMessage(~~window->~~hwnd, WM_USER_REDRAW, 0, (LPARAM)primlist);
	841	PostMessage(m_hwnd, WM_USER_REDRAW, 0, (LPARAM)primlist);
804	842	else
805		SendMessage(~~window->~~hwnd, WM_USER_REDRAW, 0, (LPARAM)primlist);
	843	SendMessage(m_hwnd, WM_USER_REDRAW, 0, (LPARAM)primlist);
806	844	mtlog_add("winwindow_video_window_update: PostMessage end");
807	845	}
808	846	}
r31541	r31542
822	860	win_monitor_info *monitor;
823	861
824	862	// in window mode, find the nearest
825		if (!window->fullscreen)
	863	if (!window->m_fullscreen)
826	864	{
827	865	if (proposed != NULL)
828	866	monitor = winvideo_monitor_from_handle(MonitorFromRect(proposed, MONITOR_DEFAULTTONEAREST));
829	867	else
830		monitor = winvideo_monitor_from_handle(MonitorFromWindow(window->hwnd, MONITOR_DEFAULTTONEAREST));
	868	monitor = winvideo_monitor_from_handle(MonitorFromWindow(window->m_hwnd, MONITOR_DEFAULTTONEAREST));
831	869	}
832	870
833	871	// in full screen, just use the configured monitor
834	872	else
835		monitor = window->monitor;
	873	monitor = window->m_monitor;
836	874
837	875	// make sure we're up-to-date
838	876	monitor->refresh();
r31541	r31542
889	927	view = defview;
890	928
891	929	// query the video system to help us pick a view
892		viewindex = window->target->configured_view(view, index, video_config.numscreens);
	930	viewindex = window->m_target->configured_view(view, index, video_config.numscreens);
893	931
894	932	// set the view
895		window->target->set_view(viewindex);
	933	window->m_target->set_view(viewindex);
896	934	}
897	935
898	936
r31541	r31542
1012	1050	INLINE int wnd_extra_width(win_window_info *window)
1013	1051	{
1014	1052	RECT temprect = { 100, 100, 200, 200 };
1015		if (window->fullscreen)
	1053	if (window->m_fullscreen)
1016	1054	return 0;
1017	1055	AdjustWindowRectEx(&temprect, WINDOW_STYLE, win_has_menu(window), WINDOW_STYLE_EX);
1018	1056	return rect_width(&temprect) - 100;
r31541	r31542
1028	1066	INLINE int wnd_extra_height(win_window_info *window)
1029	1067	{
1030	1068	RECT temprect = { 100, 100, 200, 200 };
1031		if (window->fullscreen)
	1069	if (window->m_fullscreen)
1032	1070	return 0;
1033	1071	AdjustWindowRectEx(&temprect, WINDOW_STYLE, win_has_menu(window), WINDOW_STYLE_EX);
1034	1072	return rect_height(&temprect) - 100;
r31541	r31542
1113	1151	case WM_USER_FINISH_CREATE_WINDOW:
1114	1152	{
1115	1153	win_window_info window = (win_window_info )message.lParam;
1116		window->init_state = complete_create(window) ? -1 : 1;
	1154	window->m_init_state = complete_create(window) ? -1 : 1;
1117	1155	dispatch = FALSE;
1118	1156	break;
1119	1157	}
r31541	r31542
1147	1185	assert(GetCurrentThreadId() == window_threadid);
1148	1186
1149	1187	// get the monitor bounds
1150		monitorbounds = window->monitor->info.rcMonitor;
	1188	monitorbounds = window->m_monitor->info.rcMonitor;
1151	1189
1152	1190	// create the window menu if needed
1153	1191	if (downcast<windows_options &>(window->machine().options()).menu())
r31541	r31542
1157	1195	}
1158	1196
1159	1197	// create the window, but don't show it yet
1160		window->hwnd = win_create_window_ex_utf8(
1161		window->fullscreen ? FULLSCREEN_STYLE_EX : WINDOW_STYLE_EX,
	1198	window->m_hwnd = win_create_window_ex_utf8(
	1199	window->m_fullscreen ? FULLSCREEN_STYLE_EX : WINDOW_STYLE_EX,
1162	1200	"MAME",
1163		window->title,
1164		window->fullscreen ? FULLSCREEN_STYLE : WINDOW_STYLE,
	1201	window->m_title,
	1202	window->m_fullscreen ? FULLSCREEN_STYLE : WINDOW_STYLE,
1165	1203	monitorbounds.left + 20, monitorbounds.top + 20,
1166	1204	monitorbounds.left + 100, monitorbounds.top + 100,
1167		NULL,//(win_window_list != NULL) ? win_window_list->hwnd : NULL,
	1205	NULL,//(win_window_list != NULL) ? win_window_list->m_hwnd : NULL,
1168	1206	menu,
1169	1207	GetModuleHandle(NULL),
1170	1208	NULL);
1171		if (window->hwnd == NULL)
	1209	if (window->m_hwnd == NULL)
1172	1210	return 1;
1173	1211
1174	1212	// set window #0 as the focus window for all windows, required for D3D & multimonitor
1175		window->focus_hwnd = win_window_list->hwnd;
	1213	window->m_focus_hwnd = win_window_list->m_hwnd;
1176	1214
1177	1215	// set a pointer back to us
1178		SetWindowLongPtr(window->hwnd, GWLP_USERDATA, (LONG_PTR)window);
	1216	SetWindowLongPtr(window->m_hwnd, GWLP_USERDATA, (LONG_PTR)window);
1179	1217
1180	1218	// skip the positioning stuff for -video none */
1181	1219	if (video_config.mode == VIDEO_MODE_NONE)
1182	1220	return 0;
1183	1221
1184	1222	// adjust the window position to the initial width/height
1185		tempwidth = (window->maxwidth != 0) ? window->maxwidth : 640;
1186		tempheight = (window->maxheight != 0) ? window->maxheight : 480;
1187		SetWindowPos(window->hwnd, NULL, monitorbounds.left + 20, monitorbounds.top + 20,
	1223	tempwidth = (window->m_maxwidth != 0) ? window->m_maxwidth : 640;
	1224	tempheight = (window->m_maxheight != 0) ? window->m_maxheight : 480;
	1225	SetWindowPos(window->m_hwnd, NULL, monitorbounds.left + 20, monitorbounds.top + 20,
1188	1226	monitorbounds.left + tempwidth + wnd_extra_width(window),
1189	1227	monitorbounds.top + tempheight + wnd_extra_height(window),
1190	1228	SWP_NOZORDER);
1191	1229
1192	1230	// maximum or minimize as appropriate
1193		if (window->startmaximized)
	1231	if (window->m_startmaximized)
1194	1232	maximize_window(window);
1195	1233	else
1196	1234	minimize_window(window);
1197	1235	adjust_window_position_after_major_change(window);
1198	1236
1199	1237	// show the window
1200		if (!window->fullscreen \|\| window->fullscreen_safe)
	1238	if (!window->m_fullscreen \|\| window->m_fullscreen_safe)
1201	1239	{
1202	1240	// finish off by trying to initialize DirectX; if we fail, ignore it
1203	1241	if ((*draw.window_init)(window))
1204	1242	return 1;
1205		ShowWindow(window->hwnd, SW_SHOW);
	1243	ShowWindow(window->m_hwnd, SW_SHOW);
1206	1244	}
1207	1245
1208	1246	// clear the window
1209		dc = GetDC(window->hwnd);
1210		GetClientRect(window->hwnd, &client);
	1247	dc = GetDC(window->m_hwnd);
	1248	GetClientRect(window->m_hwnd, &client);
1211	1249	FillRect(dc, &client, (HBRUSH)GetStockObject(BLACK_BRUSH));
1212		ReleaseDC(window->hwnd, dc);
	1250	ReleaseDC(window->m_hwnd, dc);
1213	1251	return 0;
1214	1252	}
1215	1253
r31541	r31542
1242	1280	HDC hdc = BeginPaint(wnd, &pstruct);
1243	1281	draw_video_contents(window, hdc, TRUE);
1244	1282	if (win_has_menu(window))
1245		DrawMenuBar(window->hwnd);
	1283	DrawMenuBar(window->m_hwnd);
1246	1284	EndPaint(wnd, &pstruct);
1247	1285	break;
1248	1286	}
1249	1287
1250	1288	// non-client paint: punt if full screen
1251	1289	case WM_NCPAINT:
1252		if (!window->fullscreen \|\| win_has_menu(window))
	1290	if (!window->m_fullscreen \|\| win_has_menu(window))
1253	1291	return DefWindowProc(wnd, message, wparam, lparam);
1254	1292	break;
1255	1293
r31541	r31542
1265	1303
1266	1304	// input events
1267	1305	case WM_MOUSEMOVE:
1268		ui_input_push_mouse_move_event(window->machine(), window->target, GET_X_LPARAM(lparam), GET_Y_LPARAM(lparam));
	1306	ui_input_push_mouse_move_event(window->machine(), window->m_target, GET_X_LPARAM(lparam), GET_Y_LPARAM(lparam));
1269	1307	break;
1270	1308
1271	1309	case WM_MOUSELEAVE:
1272		ui_input_push_mouse_leave_event(window->machine(), window->target);
	1310	ui_input_push_mouse_leave_event(window->machine(), window->m_target);
1273	1311	break;
1274	1312
1275	1313	case WM_LBUTTONDOWN:
1276	1314	{
1277	1315	DWORD ticks = GetTickCount();
1278		ui_input_push_mouse_down_event(window->machine(), window->target, GET_X_LPARAM(lparam), GET_Y_LPARAM(lparam));
	1316	ui_input_push_mouse_down_event(window->machine(), window->m_target, GET_X_LPARAM(lparam), GET_Y_LPARAM(lparam));
1279	1317
1280	1318	// check for a double-click
1281		if (ticks - window->lastclicktime < GetDoubleClickTime() &&
1282		GET_X_LPARAM(lparam) >= window->lastclickx - 4 && GET_X_LPARAM(lparam) <= window->lastclickx + 4 &&
1283		GET_Y_LPARAM(lparam) >= window->lastclicky - 4 && GET_Y_LPARAM(lparam) <= window->lastclicky + 4)
	1319	if (ticks - window->m_lastclicktime < GetDoubleClickTime() &&
	1320	GET_X_LPARAM(lparam) >= window->m_lastclickx - 4 && GET_X_LPARAM(lparam) <= window->m_lastclickx + 4 &&
	1321	GET_Y_LPARAM(lparam) >= window->m_lastclicky - 4 && GET_Y_LPARAM(lparam) <= window->m_lastclicky + 4)
1284	1322	{
1285		window->lastclicktime = 0;
1286		ui_input_push_mouse_double_click_event(window->machine(), window->target, GET_X_LPARAM(lparam), GET_Y_LPARAM(lparam));
	1323	window->m_lastclicktime = 0;
	1324	ui_input_push_mouse_double_click_event(window->machine(), window->m_target, GET_X_LPARAM(lparam), GET_Y_LPARAM(lparam));
1287	1325	}
1288	1326	else
1289	1327	{
1290		window->lastclicktime = ticks;
1291		window->lastclickx = GET_X_LPARAM(lparam);
1292		window->lastclicky = GET_Y_LPARAM(lparam);
	1328	window->m_lastclicktime = ticks;
	1329	window->m_lastclickx = GET_X_LPARAM(lparam);
	1330	window->m_lastclicky = GET_Y_LPARAM(lparam);
1293	1331	}
1294	1332	break;
1295	1333	}
1296	1334
1297	1335	case WM_LBUTTONUP:
1298		ui_input_push_mouse_up_event(window->machine(), window->target, GET_X_LPARAM(lparam), GET_Y_LPARAM(lparam));
	1336	ui_input_push_mouse_up_event(window->machine(), window->m_target, GET_X_LPARAM(lparam), GET_Y_LPARAM(lparam));
1299	1337	break;
1300	1338
1301	1339	case WM_CHAR:
1302		ui_input_push_char_event(window->machine(), window->target, (unicode_char) wparam);
	1340	ui_input_push_char_event(window->machine(), window->m_target, (unicode_char) wparam);
1303	1341	break;
1304	1342
1305	1343	// pause the system when we start a menu or resize
1306	1344	case WM_ENTERSIZEMOVE:
1307		window->resize_state = RESIZE_STATE_RESIZING;
	1345	window->m_resize_state = RESIZE_STATE_RESIZING;
1308	1346	case WM_ENTERMENULOOP:
1309	1347	winwindow_ui_pause_from_window_thread(window->machine(), TRUE);
1310	1348	break;
1311	1349
1312	1350	// unpause the system when we stop a menu or resize and force a redraw
1313	1351	case WM_EXITSIZEMOVE:
1314		window->resize_state = RESIZE_STATE_PENDING;
	1352	window->m_resize_state = RESIZE_STATE_PENDING;
1315	1353	case WM_EXITMENULOOP:
1316	1354	winwindow_ui_pause_from_window_thread(window->machine(), FALSE);
1317	1355	InvalidateRect(wnd, NULL, FALSE);
r31541	r31542
1352	1390	if (cmd == SC_MAXIMIZE)
1353	1391	{
1354	1392	update_minmax_state(window);
1355		if (window->ismaximized)
	1393	if (window->m_ismaximized)
1356	1394	minimize_window(window);
1357	1395	else
1358	1396	maximize_window(window);
r31541	r31542
1377	1415	// destroy: clean up all attached rendering bits and NULL out our hwnd
1378	1416	case WM_DESTROY:
1379	1417	(*draw.window_destroy)(window);
1380		window->hwnd = NULL;
	1418	window->m_hwnd = NULL;
1381	1419	return DefWindowProc(wnd, message, wparam, lparam);
1382	1420
1383	1421	// self redraw: draw ourself in a non-painty way
r31541	r31542
1386	1424	HDC hdc = GetDC(wnd);
1387	1425
1388	1426	mtlog_add("winwindow_video_window_proc: WM_USER_REDRAW begin");
1389		window->primlist = (render_primitive_list *)lparam;
	1427	window->m_primlist = (render_primitive_list *)lparam;
1390	1428	draw_video_contents(window, hdc, FALSE);
1391	1429	mtlog_add("winwindow_video_window_proc: WM_USER_REDRAW end");
1392	1430
r31541	r31542
1396	1434
1397	1435	// self destruct
1398	1436	case WM_USER_SELF_TERMINATE:
1399		DestroyWindow(window->hwnd);
	1437	DestroyWindow(window->m_hwnd);
1400	1438	break;
1401	1439
1402	1440	// fullscreen set
r31541	r31542
1418	1456	// commented out ATM because this prevents us from resizing secondary windows
1419	1457	// case WM_SETFOCUS:
1420	1458	// if (window != win_window_list && win_window_list != NULL)
1421		// SetFocus(win_window_list->hwnd);
	1459	// SetFocus(win_window_list->m_hwnd);
1422	1460	// break;
1423	1461
1424	1462	// everything else: defaults
r31541	r31542
1443	1481	mtlog_add("draw_video_contents: begin");
1444	1482
1445	1483	mtlog_add("draw_video_contents: render lock acquire");
1446		osd_lock_acquire(window->render_lock);
	1484	osd_lock_acquire(window->m_render_lock);
1447	1485	mtlog_add("draw_video_contents: render lock acquired");
1448	1486
1449	1487	// if we're iconic, don't bother
1450		if (window->hwnd != NULL && !IsIconic(window->hwnd))
	1488	if (window->m_hwnd != NULL && !IsIconic(window->m_hwnd))
1451	1489	{
1452	1490	// if no bitmap, just fill
1453		if (window->primlist == NULL)
	1491	if (window->m_primlist == NULL)
1454	1492	{
1455	1493	RECT fill;
1456		GetClientRect(window->hwnd, &fill);
	1494	GetClientRect(window->m_hwnd, &fill);
1457	1495	FillRect(dc, &fill, (HBRUSH)GetStockObject(BLACK_BRUSH));
1458	1496	}
1459	1497
r31541	r31542
1465	1503	}
1466	1504	}
1467	1505
1468		osd_lock_release(window->render_lock);
	1506	osd_lock_release(window->m_render_lock);
1469	1507	mtlog_add("draw_video_contents: render lock released");
1470	1508
1471	1509	mtlog_add("draw_video_contents: end");
r31541	r31542
1505	1543	{
1506	1544	case WMSZ_BOTTOM:
1507	1545	case WMSZ_TOP:
1508		window->target->compute_visible_area(10000, propheight, pixel_aspect, window->target->orientation(), propwidth, propheight);
	1546	window->m_target->compute_visible_area(10000, propheight, pixel_aspect, window->m_target->orientation(), propwidth, propheight);
1509	1547	break;
1510	1548
1511	1549	case WMSZ_LEFT:
1512	1550	case WMSZ_RIGHT:
1513		window->target->compute_visible_area(propwidth, 10000, pixel_aspect, window->target->orientation(), propwidth, propheight);
	1551	window->m_target->compute_visible_area(propwidth, 10000, pixel_aspect, window->m_target->orientation(), propwidth, propheight);
1514	1552	break;
1515	1553
1516	1554	default:
1517		window->target->compute_visible_area(propwidth, propheight, pixel_aspect, window->target->orientation(), propwidth, propheight);
	1555	window->m_target->compute_visible_area(propwidth, propheight, pixel_aspect, window->m_target->orientation(), propwidth, propheight);
1518	1556	break;
1519	1557	}
1520	1558
1521	1559	// get the minimum width/height for the current layout
1522		window->target->compute_minimum_size(minwidth, minheight);
	1560	window->m_target->compute_minimum_size(minwidth, minheight);
1523	1561
1524	1562	// clamp against the absolute minimum
1525	1563	propwidth = MAX(propwidth, MIN_WINDOW_DIM);
r31541	r31542
1530	1568	propheight = MAX(propheight, minheight);
1531	1569
1532	1570	// clamp against the maximum (fit on one screen for full screen mode)
1533		if (window->fullscreen)
	1571	if (window->m_fullscreen)
1534	1572	{
1535	1573	maxwidth = rect_width(&monitor->info.rcMonitor) - extrawidth;
1536	1574	maxheight = rect_height(&monitor->info.rcMonitor) - extraheight;
r31541	r31542
1541	1579	maxheight = rect_height(&monitor->info.rcWork) - extraheight;
1542	1580
1543	1581	// further clamp to the maximum width/height in the window
1544		if (window->maxwidth != 0)
1545		maxwidth = MIN(maxwidth, window->maxwidth + extrawidth);
1546		if (window->maxheight != 0)
1547		maxheight = MIN(maxheight, window->maxheight + extraheight);
	1582	if (window->m_maxwidth != 0)
	1583	maxwidth = MIN(maxwidth, window->m_maxwidth + extrawidth);
	1584	if (window->m_maxheight != 0)
	1585	maxheight = MIN(maxheight, window->m_maxheight + extraheight);
1548	1586	}
1549	1587
1550	1588	// clamp to the maximum
r31541	r31542
1552	1590	propheight = MIN(propheight, maxheight);
1553	1591
1554	1592	// compute the visible area based on the proposed rectangle
1555		window->target->compute_visible_area(propwidth, propheight, pixel_aspect, window->target->orientation(), viswidth, visheight);
	1593	window->m_target->compute_visible_area(propwidth, propheight, pixel_aspect, window->m_target->orientation(), viswidth, visheight);
1556	1594
1557	1595	// compute the adjustments we need to make
1558	1596	adjwidth = (viswidth + extrawidth) - rect_width(rect);
r31541	r31542
1601	1639	assert(GetCurrentThreadId() == window_threadid);
1602	1640
1603	1641	// get the minimum target size
1604		window->target->compute_minimum_size(minwidth, minheight);
	1642	window->m_target->compute_minimum_size(minwidth, minheight);
1605	1643
1606	1644	// expand to our minimum dimensions
1607	1645	if (minwidth < MIN_WINDOW_DIM)
r31541	r31542
1644	1682	}
1645	1683
1646	1684	// get the window rect
1647		GetWindowRect(window->hwnd, bounds);
	1685	GetWindowRect(window->m_hwnd, bounds);
1648	1686
1649	1687	// now adjust
1650	1688	bounds->right = bounds->left + minwidth;
r31541	r31542
1665	1703	assert(GetCurrentThreadId() == window_threadid);
1666	1704
1667	1705	// compute the maximum client area
1668		window->monitor->refresh();
1669		maximum = window->monitor->info.rcWork;
	1706	window->m_monitor->refresh();
	1707	maximum = window->m_monitor->info.rcWork;
1670	1708
1671	1709	// clamp to the window's max
1672		if (window->maxwidth != 0)
	1710	if (window->m_maxwidth != 0)
1673	1711	{
1674		int temp = window->maxwidth + wnd_extra_width(window);
	1712	int temp = window->m_maxwidth + wnd_extra_width(window);
1675	1713	if (temp < rect_width(&maximum))
1676	1714	maximum.right = maximum.left + temp;
1677	1715	}
1678		if (window->maxheight != 0)
	1716	if (window->m_maxheight != 0)
1679	1717	{
1680		int temp = window->maxheight + wnd_extra_height(window);
	1718	int temp = window->m_maxheight + wnd_extra_height(window);
1681	1719	if (temp < rect_height(&maximum))
1682	1720	maximum.bottom = maximum.top + temp;
1683	1721	}
r31541	r31542
1692	1730	}
1693	1731
1694	1732	// center within the work area
1695		bounds->left = window->monitor->info.rcWork.left + (rect_width(&window->monitor->info.rcWork) - rect_width(&maximum)) / 2;
1696		bounds->top = window->monitor->info.rcWork.top + (rect_height(&window->monitor->info.rcWork) - rect_height(&maximum)) / 2;
	1733	bounds->left = window->m_monitor->info.rcWork.left + (rect_width(&window->m_monitor->info.rcWork) - rect_width(&maximum)) / 2;
	1734	bounds->top = window->m_monitor->info.rcWork.top + (rect_height(&window->m_monitor->info.rcWork) - rect_height(&maximum)) / 2;
1697	1735	bounds->right = bounds->left + rect_width(&maximum);
1698	1736	bounds->bottom = bounds->top + rect_height(&maximum);
1699	1737	}
r31541	r31542
1709	1747	{
1710	1748	assert(GetCurrentThreadId() == window_threadid);
1711	1749
1712		if (!window->fullscreen)
	1750	if (!window->m_fullscreen)
1713	1751	{
1714	1752	RECT bounds, minbounds, maxbounds;
1715	1753
1716	1754	// compare the maximum bounds versus the current bounds
1717	1755	get_min_bounds(window, &minbounds, video_config.keepaspect);
1718	1756	get_max_bounds(window, &maxbounds, video_config.keepaspect);
1719		GetWindowRect(window->hwnd, &bounds);
	1757	GetWindowRect(window->m_hwnd, &bounds);
1720	1758
1721	1759	// if either the width or height matches, we were maximized
1722		window->isminimized = (rect_width(&bounds) == rect_width(&minbounds) \|\|
	1760	window->m_isminimized = (rect_width(&bounds) == rect_width(&minbounds) \|\|
1723	1761	rect_height(&bounds) == rect_height(&minbounds));
1724		window->ismaximized = (rect_width(&bounds) == rect_width(&maxbounds) \|\|
	1762	window->m_ismaximized = (rect_width(&bounds) == rect_width(&maxbounds) \|\|
1725	1763	rect_height(&bounds) == rect_height(&maxbounds));
1726	1764	}
1727	1765	else
1728	1766	{
1729		window->isminimized = FALSE;
1730		window->ismaximized = TRUE;
	1767	window->m_isminimized = FALSE;
	1768	window->m_ismaximized = TRUE;
1731	1769	}
1732	1770	}
1733	1771
r31541	r31542
1745	1783	assert(GetCurrentThreadId() == window_threadid);
1746	1784
1747	1785	get_min_bounds(window, &newsize, video_config.keepaspect);
1748		SetWindowPos(window->hwnd, NULL, newsize.left, newsize.top, rect_width(&newsize), rect_height(&newsize), SWP_NOZORDER);
	1786	SetWindowPos(window->m_hwnd, NULL, newsize.left, newsize.top, rect_width(&newsize), rect_height(&newsize), SWP_NOZORDER);
1749	1787	}
1750	1788
1751	1789
r31541	r31542
1762	1800	assert(GetCurrentThreadId() == window_threadid);
1763	1801
1764	1802	get_max_bounds(window, &newsize, video_config.keepaspect);
1765		SetWindowPos(window->hwnd, NULL, newsize.left, newsize.top, rect_width(&newsize), rect_height(&newsize), SWP_NOZORDER);
	1803	SetWindowPos(window->m_hwnd, NULL, newsize.left, newsize.top, rect_width(&newsize), rect_height(&newsize), SWP_NOZORDER);
1766	1804	}
1767	1805
1768	1806
r31541	r31542
1779	1817	assert(GetCurrentThreadId() == window_threadid);
1780	1818
1781	1819	// get the current size
1782		GetWindowRect(window->hwnd, &oldrect);
	1820	GetWindowRect(window->m_hwnd, &oldrect);
1783	1821
1784	1822	// adjust the window size so the client area is what we want
1785		if (!window->fullscreen)
	1823	if (!window->m_fullscreen)
1786	1824	{
1787	1825	// constrain the existing size to the aspect ratio
1788	1826	newrect = oldrect;
r31541	r31542
1800	1838	// adjust the position if different
1801	1839	if (oldrect.left != newrect.left \|\| oldrect.top != newrect.top \|\|
1802	1840	oldrect.right != newrect.right \|\| oldrect.bottom != newrect.bottom)
1803		SetWindowPos(window->hwnd, window->fullscreen ? HWND_TOPMOST : HWND_TOP,
	1841	SetWindowPos(window->m_hwnd, window->m_fullscreen ? HWND_TOPMOST : HWND_TOP,
1804	1842	newrect.left, newrect.top,
1805	1843	rect_width(&newrect), rect_height(&newrect), 0);
1806	1844
r31541	r31542
1825	1863	assert(GetCurrentThreadId() == window_threadid);
1826	1864
1827	1865	// if we're in the right state, punt
1828		if (window->fullscreen == fullscreen)
	1866	if (window->m_fullscreen == fullscreen)
1829	1867	return;
1830		window->fullscreen = fullscreen;
	1868	window->m_fullscreen = fullscreen;
1831	1869
1832	1870	// kill off the drawers
1833	1871	(*draw.window_destroy)(window);
1834	1872
1835	1873	// hide ourself
1836		ShowWindow(window->hwnd, SW_HIDE);
	1874	ShowWindow(window->m_hwnd, SW_HIDE);
1837	1875
1838	1876	// configure the window if non-fullscreen
1839	1877	if (!fullscreen)
1840	1878	{
1841	1879	// adjust the style
1842		SetWindowLong(window->hwnd, GWL_STYLE, WINDOW_STYLE);
1843		SetWindowLong(window->hwnd, GWL_EXSTYLE, WINDOW_STYLE_EX);
1844		SetWindowPos(window->hwnd, 0, 0, 0, 0, 0, SWP_NOMOVE \| SWP_NOSIZE \| SWP_NOZORDER \| SWP_FRAMECHANGED);
	1880	SetWindowLong(window->m_hwnd, GWL_STYLE, WINDOW_STYLE);
	1881	SetWindowLong(window->m_hwnd, GWL_EXSTYLE, WINDOW_STYLE_EX);
	1882	SetWindowPos(window->m_hwnd, 0, 0, 0, 0, 0, SWP_NOMOVE \| SWP_NOSIZE \| SWP_NOZORDER \| SWP_FRAMECHANGED);
1845	1883
1846	1884	// force to the bottom, then back on top
1847		SetWindowPos(window->hwnd, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE \| SWP_NOSIZE);
1848		SetWindowPos(window->hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE \| SWP_NOSIZE);
	1885	SetWindowPos(window->m_hwnd, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE \| SWP_NOSIZE);
	1886	SetWindowPos(window->m_hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE \| SWP_NOSIZE);
1849	1887
1850	1888	// if we have previous non-fullscreen bounds, use those
1851		if (window->non_fullscreen_bounds.right != window->non_fullscreen_bounds.left)
	1889	if (window->m_non_fullscreen_bounds.right != window->m_non_fullscreen_bounds.left)
1852	1890	{
1853		SetWindowPos(window->hwnd, HWND_TOP, window->non_fullscreen_bounds.left, window->non_fullscreen_bounds.top,
1854		rect_width(&window->non_fullscreen_bounds), rect_height(&window->non_fullscreen_bounds),
	1891	SetWindowPos(window->m_hwnd, HWND_TOP, window->m_non_fullscreen_bounds.left, window->m_non_fullscreen_bounds.top,
	1892	rect_width(&window->m_non_fullscreen_bounds), rect_height(&window->m_non_fullscreen_bounds),
1855	1893	SWP_NOZORDER);
1856	1894	}
1857	1895
1858	1896	// otherwise, set a small size and maximize from there
1859	1897	else
1860	1898	{
1861		SetWindowPos(window->hwnd, HWND_TOP, 0, 0, MIN_WINDOW_DIM, MIN_WINDOW_DIM, SWP_NOZORDER);
	1899	SetWindowPos(window->m_hwnd, HWND_TOP, 0, 0, MIN_WINDOW_DIM, MIN_WINDOW_DIM, SWP_NOZORDER);
1862	1900	maximize_window(window);
1863	1901	}
1864	1902	}
r31541	r31542
1867	1905	else
1868	1906	{
1869	1907	// save the bounds
1870		GetWindowRect(window->hwnd, &window->non_fullscreen_bounds);
	1908	GetWindowRect(window->m_hwnd, &window->m_non_fullscreen_bounds);
1871	1909
1872	1910	// adjust the style
1873		SetWindowLong(window->hwnd, GWL_STYLE, FULLSCREEN_STYLE);
1874		SetWindowLong(window->hwnd, GWL_EXSTYLE, FULLSCREEN_STYLE_EX);
1875		SetWindowPos(window->hwnd, 0, 0, 0, 0, 0, SWP_NOMOVE \| SWP_NOSIZE \| SWP_NOZORDER \| SWP_FRAMECHANGED);
	1911	SetWindowLong(window->m_hwnd, GWL_STYLE, FULLSCREEN_STYLE);
	1912	SetWindowLong(window->m_hwnd, GWL_EXSTYLE, FULLSCREEN_STYLE_EX);
	1913	SetWindowPos(window->m_hwnd, 0, 0, 0, 0, 0, SWP_NOMOVE \| SWP_NOSIZE \| SWP_NOZORDER \| SWP_FRAMECHANGED);
1876	1914
1877	1915	// set topmost
1878		SetWindowPos(window->hwnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE \| SWP_NOSIZE);
	1916	SetWindowPos(window->m_hwnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE \| SWP_NOSIZE);
1879	1917	}
1880	1918
1881	1919	// adjust the window to compensate for the change
1882	1920	adjust_window_position_after_major_change(window);
1883	1921
1884	1922	// show ourself
1885		if (!window->fullscreen \|\| window->fullscreen_safe)
	1923	if (!window->m_fullscreen \|\| window->m_fullscreen_safe)
1886	1924	{
1887	1925	if (video_config.mode != VIDEO_MODE_NONE)
1888		ShowWindow(window->hwnd, SW_SHOW);
	1926	ShowWindow(window->m_hwnd, SW_SHOW);
1889	1927	if ((*draw.window_init)(window))
1890	1928	exit(1);
1891	1929	}

branches/osd/src/osd/windows/window.h
r31541	r31542
32	32	// TYPE DEFINITIONS
33	33	//============================================================
34	34
35		~~stru~~ct win_window_info
	35	class win_window_info
36	36	{
37	37	public:
38		win_window_info(running_machine &machine)
39		: m_machine(machine) { }
	38	win_window_info(running_machine &machine);
	39	virtual ~win_window_info();
40	40
41	41	running_machine &machine() const { return m_machine; }
42	42
43		win_window_info * next;
44		volatile int init_state;
	43	void update();
	44
	45	win_window_info * m_next;
	46	volatile int m_init_state;
45	47
46	48	// window handle and info
47		HWND hwnd;
48		HWND focus_hwnd;
49		char title[256];
50		RECT non_fullscreen_bounds;
51		int startmaximized;
52		int isminimized;
53		int ismaximized;
54		int resize_state;
	49	HWND m_hwnd;
	50	HWND m_focus_hwnd;
	51	char m_title[256];
	52	RECT m_non_fullscreen_bounds;
	53	int m_startmaximized;
	54	int m_isminimized;
	55	int m_ismaximized;
	56	int m_resize_state;
55	57
56	58	// monitor info
57		win_monitor_info * monitor;
58		int fullscreen;
59		int fullscreen_safe;
60		int maxwidth, maxheight;
61		int refresh;
62		float aspect;
	59	win_monitor_info * m_monitor;
	60	int m_fullscreen;
	61	int m_fullscreen_safe;
	62	int m_maxwidth, m_maxheight;
	63	int m_refresh;
	64	float m_aspect;
63	65
64	66	// rendering info
65		osd_lock * render_lock;
66		render_target * target;
67		int targetview;
68		int targetorient;
69		render_layer_config targetlayerconfig;
70		render_primitive_list *primlist;
	67	osd_lock * m_render_lock;
	68	render_target * m_target;
	69	int m_targetview;
	70	int m_targetorient;
	71	render_layer_config m_targetlayerconfig;
	72	render_primitive_list *m_primlist;
71	73
72	74	// input info
73		DWORD lastclicktime;
74		int lastclickx;
75		int lastclicky;
	75	DWORD m_lastclicktime;
	76	int m_lastclickx;
	77	int m_lastclicky;
76	78
77	79	// drawing data
78		void * drawdata;
	80	void * m_drawdata;
79	81
80	82	private:
81	83	running_machine & m_machine;
r31541	r31542
115	117
116	118	BOOL winwindow_has_focus(void);
117	119	void winwindow_update_cursor_state(running_machine &machine);
118		void winwindow_video_window_update(win_window_info *window);
119	120	win_monitor_info winwindow_video_window_monitor(win_window_info window, const RECT *proposed);
120	121
121	122	LRESULT CALLBACK winwindow_video_window_proc(HWND wnd, UINT message, WPARAM wparam, LPARAM lparam);
r31541	r31542
146	147
147	148	INLINE BOOL win_has_menu(win_window_info *window)
148	149	{
149		return GetMenu(window->hwnd) ? TRUE : FALSE;
	150	return GetMenu(window->m_hwnd) ? TRUE : FALSE;
150	151	}
151	152
152	153

branches/osd/src/osd/windows/drawd3d.c
r31541	r31542
196	196	{
197	197	// allocate memory for our structures
198	198	d3d::renderer *d3d = global_alloc(d3d::renderer(window));
199		window->drawdata = d3d;
	199	window->m_drawdata = d3d;
200	200
201	201	if (!d3d->initialize())
202	202	{
r31541	r31542
220	220
221	221	static void drawd3d_window_toggle_fsfx(win_window_info *window)
222	222	{
223		d3d::renderer d3d = (d3d::renderer )window->drawdata;
	223	d3d::renderer d3d = (d3d::renderer )window->m_drawdata;
224	224	d3d->set_restarting(true);
225	225	}
226	226
227	227	static void drawd3d_window_record(win_window_info *window)
228	228	{
229		d3d::renderer d3d = (d3d::renderer )window->drawdata;
	229	d3d::renderer d3d = (d3d::renderer )window->m_drawdata;
230	230	d3d->get_shaders()->window_record();
231	231	}
232	232
233	233	static void drawd3d_window_save(win_window_info *window)
234	234	{
235		d3d::renderer d3d = (d3d::renderer )window->drawdata;
	235	d3d::renderer d3d = (d3d::renderer )window->m_drawdata;
236	236	d3d->get_shaders()->window_save();
237	237	}
238	238
r31541	r31542
244	244
245	245	static void drawd3d_window_destroy(win_window_info *window)
246	246	{
247		d3d::renderer d3d = (d3d::renderer )window->drawdata;
	247	d3d::renderer d3d = (d3d::renderer )window->m_drawdata;
248	248
249	249	// skip if nothing
250	250	if (d3d == NULL)
r31541	r31542
255	255
256	256	// free the memory in the window
257	257	global_free(d3d);
258		window->drawdata = NULL;
	258	window->m_drawdata = NULL;
259	259	}
260	260
261	261
r31541	r31542
266	266
267	267	static render_primitive_list drawd3d_window_get_primitives(win_window_info window)
268	268	{
269		d3d::renderer d3d = (d3d::renderer )window->drawdata;
	269	d3d::renderer d3d = (d3d::renderer )window->m_drawdata;
270	270	RECT client;
271	271
272		GetClientRectExceptMenu(window->hwnd, &client, window->fullscreen);
	272	GetClientRectExceptMenu(window->m_hwnd, &client, window->m_fullscreen);
273	273	if (rect_width(&client) > 0 && rect_height(&client) > 0)
274	274	{
275		window->target->set_bounds(rect_width(&client), rect_height(&client), window->monitor->get_aspect());
276		window->target->set_max_update_rate((d3d->get_refresh() == 0) ? d3d->get_origmode().RefreshRate : d3d->get_refresh());
	275	window->m_target->set_bounds(rect_width(&client), rect_height(&client), window->m_monitor->get_aspect());
	276	window->m_target->set_max_update_rate((d3d->get_refresh() == 0) ? d3d->get_origmode().RefreshRate : d3d->get_refresh());
277	277	}
278		return &window->target->get_primitives();
	278	return &window->m_target->get_primitives();
279	279	}
280	280
281	281	int drawd3d_init(running_machine &machine, win_draw_callbacks *callbacks)
r31541	r31542
311	311
312	312	static int drawd3d_window_draw(win_window_info *window, HDC dc, int update)
313	313	{
314		d3d::renderer d3d = (d3d::renderer )window->drawdata;
	314	d3d::renderer d3d = (d3d::renderer )window->m_drawdata;
315	315
316	316	// if we haven't been created, just punt
317	317	if (d3d == NULL)
r31541	r31542
496	496	osd_printf_verbose("Direct3D: YUV format = %s\n", (m_yuv_format == D3DFMT_YUY2) ? "YUY2" : (m_yuv_format == D3DFMT_UYVY) ? "UYVY" : "RGB");
497	497
498	498	// set the max texture size
499		d3d->get_window()->target->set_max_texture_size(m_texture_max_width, m_texture_max_height);
	499	d3d->get_window()->m_target->set_max_texture_size(m_texture_max_width, m_texture_max_height);
500	500	osd_printf_verbose("Direct3D: Max texture size = %dx%d\n", (int)m_texture_max_width, (int)m_texture_max_height);
501	501	}
502	502
r31541	r31542
672	672	return false;
673	673
674	674	// create the device immediately for the full screen case (defer for window mode)
675		if (m_window->fullscreen && device_create())
	675	if (m_window->m_fullscreen && device_create())
676	676	return false;
677	677
678	678	return true;
r31541	r31542
681	681	int renderer::pre_window_draw_check()
682	682	{
683	683	// if we're in the middle of resizing, leave things alone
684		if (m_window->resize_state == RESIZE_STATE_RESIZING)
	684	if (m_window->m_resize_state == RESIZE_STATE_RESIZING)
685	685	return 0;
686	686
687	687	// if we're restarting the renderer, leave things alone
r31541	r31542
706	706	}
707	707
708	708	// in window mode, we need to track the window size
709		if (!m_window->fullscreen \|\| m_device == NULL)
	709	if (!m_window->m_fullscreen \|\| m_device == NULL)
710	710	{
711	711	// if the size changes, skip this update since the render target will be out of date
712	712	if (update_window_size())
r31541	r31542
722	722
723	723	void texture_manager::update_textures()
724	724	{
725		for (render_primitive *prim = m_renderer->get_window()->primlist->first(); prim != NULL; prim = prim->next())
	725	for (render_primitive *prim = m_renderer->get_window()->m_primlist->first(); prim != NULL; prim = prim->next())
726	726	{
727	727	if (prim->texture.base != NULL)
728	728	{
r31541	r31542
759	759
760	760	m_shaders->begin_frame();
761	761
762		m_window->primlist->acquire_lock();
	762	m_window->m_primlist->acquire_lock();
763	763
764	764	// first update any textures
765	765	m_texture_manager->update_textures();
r31541	r31542
780	780	m_line_count = 0;
781	781
782	782	// loop over primitives
783		for (render_primitive *prim = m_window->primlist->first(); prim != NULL; prim = prim->next())
	783	for (render_primitive *prim = m_window->m_primlist->first(); prim != NULL; prim = prim->next())
784	784	if (prim->type == render_primitive::LINE && PRIMFLAG_GET_VECTOR(prim->flags))
785	785	m_line_count++;
786	786	}
r31541	r31542
788	788	void renderer::process_primitives()
789	789	{
790	790	// Rotating index for vector time offsets
791		for (render_primitive *prim = m_window->primlist->first(); prim != NULL; prim = prim->next())
	791	for (render_primitive *prim = m_window->m_primlist->first(); prim != NULL; prim = prim->next())
792	792	{
793	793	switch (prim->type)
794	794	{
r31541	r31542
818	818
819	819	void renderer::end_frame()
820	820	{
821		m_window->primlist->release_lock();
	821	m_window->m_primlist->release_lock();
822	822
823	823	// flush any pending polygons
824	824	primitive_flush_pending();
r31541	r31542
893	893	m_presentation.BackBufferCount = video_config.triplebuf ? 2 : 1;
894	894	m_presentation.MultiSampleType = D3DMULTISAMPLE_NONE;
895	895	m_presentation.SwapEffect = D3DSWAPEFFECT_DISCARD;
896		m_presentation.hDeviceWindow = m_window->hwnd;
897		m_presentation.Windowed = !m_window->fullscreen \|\| win_has_menu(m_window);
	896	m_presentation.hDeviceWindow = m_window->m_hwnd;
	897	m_presentation.Windowed = !m_window->m_fullscreen \|\| win_has_menu(m_window);
898	898	m_presentation.EnableAutoDepthStencil = FALSE;
899	899	m_presentation.AutoDepthStencilFormat = D3DFMT_D16;
900	900	m_presentation.Flags = 0;
901	901	m_presentation.FullScreen_RefreshRateInHz = m_refresh;
902		m_presentation.PresentationInterval = ((video_config.triplebuf && m_window->fullscreen) \|\|
	902	m_presentation.PresentationInterval = ((video_config.triplebuf && m_window->m_fullscreen) \|\|
903	903	video_config.waitvsync \|\| video_config.syncrefresh) ?
904	904	D3DPRESENT_INTERVAL_ONE : D3DPRESENT_INTERVAL_IMMEDIATE;
905	905
906	906	// create the D3D device
907		result = (*d3dintf->d3d.create_device)(d3dintf, m_adapter, D3DDEVTYPE_HAL, m_window->focus_hwnd,
	907	result = (*d3dintf->d3d.create_device)(d3dintf, m_adapter, D3DDEVTYPE_HAL, m_window->m_focus_hwnd,
908	908	D3DCREATE_SOFTWARE_VERTEXPROCESSING \| D3DCREATE_FPU_PRESERVE, &m_presentation, &m_device);
909	909	if (result != D3D_OK)
910	910	{
r31541	r31542
927	927	osd_printf_verbose("Direct3D: Device created at %dx%d\n", m_width, m_height);
928	928
929	929	// set the gamma if we need to
930		if (m_window->fullscreen)
	930	if (m_window->m_fullscreen)
931	931	{
932	932	// only set the gamma if it's not 1.0f
933	933	windows_options &options = downcast<windows_options &>(m_window->machine().options());
r31541	r31542
1227	1227	}
1228	1228
1229	1229	// choose a resolution: window mode case
1230		if (!m_window->fullscreen \|\| !video_config.switchres \|\| win_has_menu(m_window))
	1230	if (!m_window->m_fullscreen \|\| !video_config.switchres \|\| win_has_menu(m_window))
1231	1231	{
1232	1232	RECT client;
1233	1233
1234	1234	// bounds are from the window client rect
1235		GetClientRectExceptMenu(m_window->hwnd, &client, m_window->fullscreen);
	1235	GetClientRectExceptMenu(m_window->m_hwnd, &client, m_window->m_fullscreen);
1236	1236	m_width = client.right - client.left;
1237	1237	m_height = client.bottom - client.top;
1238	1238
r31541	r31542
1243	1243	// make sure it's a pixel format we can get behind
1244	1244	if (m_pixformat != D3DFMT_X1R5G5B5 && m_pixformat != D3DFMT_R5G6B5 && m_pixformat != D3DFMT_X8R8G8B8)
1245	1245	{
1246		char *utf8_device = utf8_from_tstring(m_window->monitor->info.szDevice);
	1246	char *utf8_device = utf8_from_tstring(m_window->m_monitor->info.szDevice);
1247	1247	if (utf8_device != NULL)
1248	1248	{
1249	1249	osd_printf_error("Device %s currently in an unsupported mode\n", utf8_device);
r31541	r31542
1268	1268	}
1269	1269
1270	1270	// see if we can handle the device type
1271		result = (*d3dintf->d3d.check_device_type)(d3dintf, m_adapter, D3DDEVTYPE_HAL, m_pixformat, m_pixformat, !m_window->fullscreen);
	1271	result = (*d3dintf->d3d.check_device_type)(d3dintf, m_adapter, D3DDEVTYPE_HAL, m_pixformat, m_pixformat, !m_window->m_fullscreen);
1272	1272	if (result != D3D_OK)
1273	1273	{
1274		char *utf8_device = utf8_from_tstring(m_window->monitor->info.szDevice);
	1274	char *utf8_device = utf8_from_tstring(m_window->m_monitor->info.szDevice);
1275	1275	if (utf8_device != NULL)
1276	1276	{
1277	1277	osd_printf_error("Proposed video mode not supported on device %s\n", utf8_device);
r31541	r31542
1299	1299	HMONITOR curmonitor = (*d3dintf->d3d.get_adapter_monitor)(d3dintf, adapternum);
1300	1300
1301	1301	// if we match the proposed monitor, this is it
1302		if (curmonitor == m_window->monitor->handle)
	1302	if (curmonitor == m_window->m_monitor->handle)
1303	1303	{
1304	1304	return adapternum;
1305	1305	}
r31541	r31542
1332	1332	// note: technically we should not be calling this from an alternate window
1333	1333	// thread; however, it is only done during init time, and the init code on
1334	1334	// the main thread is waiting for us to finish, so it is safe to do so here
1335		m_window->target->compute_minimum_size(minwidth, minheight);
	1335	m_window->m_target->compute_minimum_size(minwidth, minheight);
1336	1336
1337	1337	// use those as the target for now
1338	1338	INT32 target_width = minwidth;
r31541	r31542
1367	1367	size_score *= 0.1f;
1368	1368
1369	1369	// if we're looking for a particular mode, that's a winner
1370		if (mode.Width == m_window->maxwidth && mode.Height == m_window->maxheight)
	1370	if (mode.Width == m_window->m_maxwidth && mode.Height == m_window->m_maxheight)
1371	1371	size_score = 2.0f;
1372	1372
1373	1373	// compute refresh score
r31541	r31542
1378	1378	refresh_score *= 0.1f;
1379	1379
1380	1380	// if we're looking for a particular refresh, make sure it matches
1381		if (mode.RefreshRate == m_window->refresh)
	1381	if (mode.RefreshRate == m_window->m_refresh)
1382	1382	refresh_score = 2.0f;
1383	1383
1384	1384	// weight size and refresh equally
r31541	r31542
1408	1408	{
1409	1409	// get the current window bounds
1410	1410	RECT client;
1411		GetClientRectExceptMenu(m_window->hwnd, &client, m_window->fullscreen);
	1411	GetClientRectExceptMenu(m_window->m_hwnd, &client, m_window->m_fullscreen);
1412	1412
1413	1413	// if we have a device and matching width/height, nothing to do
1414	1414	if (m_device != NULL && rect_width(&client) == m_width && rect_height(&client) == m_height)
1415	1415	{
1416	1416	// clear out any pending resizing if the area didn't change
1417		if (m_window->resize_state == RESIZE_STATE_PENDING)
1418		m_window->resize_state = RESIZE_STATE_NORMAL;
	1417	if (m_window->m_resize_state == RESIZE_STATE_PENDING)
	1418	m_window->m_resize_state = RESIZE_STATE_NORMAL;
1419	1419	return FALSE;
1420	1420	}
1421	1421
1422	1422	// if we're in the middle of resizing, leave it alone as well
1423		if (m_window->resize_state == RESIZE_STATE_RESIZING)
	1423	if (m_window->m_resize_state == RESIZE_STATE_RESIZING)
1424	1424	return FALSE;
1425	1425
1426	1426	// set the new bounds and create the device again
r31541	r31542
1430	1430	return FALSE;
1431	1431
1432	1432	// reset the resize state to normal, and indicate we made a change
1433		m_window->resize_state = RESIZE_STATE_NORMAL;
	1433	m_window->m_resize_state = RESIZE_STATE_NORMAL;
1434	1434	return TRUE;
1435	1435	}
1436	1436
r31541	r31542
1450	1450	int line_index = 0;
1451	1451	float period = options.screen_vector_time_period();
1452	1452	UINT32 cached_flags = 0;
1453		for (render_primitive *prim = m_window->primlist->first(); prim != NULL; prim = prim->next())
	1453	for (render_primitive *prim = m_window->m_primlist->first(); prim != NULL; prim = prim->next())
1454	1454	{
1455	1455	switch (prim->type)
1456	1456	{

branches/osd/src/osd/windows/d3dhlsl.c
r31541	r31542
224	224	if (!master_enable \|\| !d3dintf->post_fx_available)
225	225	return;
226	226
227		renderer d3d = (renderer )window->drawdata;
	227	renderer d3d = (renderer )window->m_drawdata;
228	228
229	229	HRESULT result = (*d3dintf->device.create_texture)(d3d->get_device(), snap_width, snap_height, 1, D3DUSAGE_DYNAMIC, D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM, &snap_copy_texture);
230	230	if (result != D3D_OK)
r31541	r31542
276	276	if (!master_enable \|\| !d3dintf->post_fx_available)
277	277	return;
278	278
279		renderer d3d = (renderer )window->drawdata;
	279	renderer d3d = (renderer )window->m_drawdata;
280	280
281	281	D3DLOCKED_RECT rect;
282	282
r31541	r31542
326	326	if (!master_enable \|\| !d3dintf->post_fx_available)
327	327	return;
328	328
329		renderer d3d = (renderer )window->drawdata;
	329	renderer d3d = (renderer )window->m_drawdata;
330	330
331	331	D3DLOCKED_RECT rect;
332	332
r31541	r31542
519	519	if (!master_enable \|\| !d3dintf->post_fx_available)
520	520	return;
521	521
522		renderer d3d = (renderer )window->drawdata;
	522	renderer d3d = (renderer )window->m_drawdata;
523	523
524	524	// stop any existing recording
525	525	end_avi_recording();
r31541	r31542
678	678	if (!master_enable \|\| !d3dintf->post_fx_available)
679	679	return;
680	680
681		renderer d3d = (renderer )window->drawdata;
	681	renderer d3d = (renderer )window->m_drawdata;
682	682
683	683	if(texture != NULL)
684	684	{
r31541	r31542
820	820	if (!master_enable \|\| !d3dintf->post_fx_available)
821	821	return;
822	822
823		renderer d3d = (renderer )window->drawdata;
	823	renderer d3d = (renderer )window->m_drawdata;
824	824
825	825	// get a pointer to the vertex buffer
826	826	fsfx_vertices = (vertex *)vertbuf;
r31541	r31542
892	892	if (!master_enable \|\| !d3dintf->post_fx_available)
893	893	return 0;
894	894
895		renderer d3d = (renderer )window->drawdata;
	895	renderer d3d = (renderer )window->m_drawdata;
896	896
897	897	HRESULT result = (*d3dintf->device.get_render_target)(d3d->get_device(), 0, &backbuffer);
898	898	if (result != D3D_OK) osd_printf_verbose("Direct3D: Error %08X during device get_render_target call\n", (int)result);
r31541	r31542
1066	1066	if (!master_enable \|\| !d3dintf->post_fx_available)
1067	1067	return;
1068	1068
1069		renderer d3d = (renderer )window->drawdata;
	1069	renderer d3d = (renderer )window->m_drawdata;
1070	1070
1071	1071	curr_effect = default_effect;
1072	1072
r31541	r31542
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->drawdata;
	1104	renderer d3d = (renderer )window->m_drawdata;
1105	1105
1106	1106	HRESULT result = (*d3dintf->device.set_render_target)(d3d->get_device(), 0, dst);
1107	1107	if (result != D3D_OK) osd_printf_verbose("Direct3D: Error %08X during device set_render_target call\n", (int)result);
r31541	r31542
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->drawdata;
	1149	renderer d3d = (renderer )window->m_drawdata;
1150	1150
1151	1151	HRESULT result = (*d3dintf->device.set_render_target)(d3d->get_device(), 0, dst);
1152	1152	if (result != D3D_OK) osd_printf_verbose("Direct3D: Error %08X during device set_render_target call\n", (int)result);
r31541	r31542
1231	1231	if (!master_enable \|\| !d3dintf->post_fx_available)
1232	1232	return;
1233	1233
1234		renderer d3d = (renderer )window->drawdata;
	1234	renderer d3d = (renderer )window->m_drawdata;
1235	1235	texture_info *texture = poly->get_texture();
1236	1236
1237	1237	if(PRIMFLAG_GET_SCREENTEX(d3d->get_last_texture_flags()) && texture != NULL)
r31541	r31542
1308	1308
1309	1309	void shaders::ntsc_pass(render_target *rt, vec2f &sourcedims, vec2f &delta)
1310	1310	{
1311		renderer d3d = (renderer )window->drawdata;
	1311	renderer d3d = (renderer )window->m_drawdata;
1312	1312	UINT num_passes = 0;
1313	1313
1314	1314	if(options->yiq_enable)
r31541	r31542
1370	1370
1371	1371	void shaders::color_convolution_pass(render_target *rt, vec2f &texsize, vec2f &sourcedims)
1372	1372	{
1373		renderer d3d = (renderer )window->drawdata;
	1373	renderer d3d = (renderer )window->m_drawdata;
1374	1374	UINT num_passes = 0;
1375	1375
1376	1376	curr_effect = color_effect;
r31541	r31542
1398	1398
1399	1399	void shaders::prescale_pass(render_target *rt, vec2f &texsize, vec2f &sourcedims)
1400	1400	{
1401		renderer d3d = (renderer )window->drawdata;
	1401	renderer d3d = (renderer )window->m_drawdata;
1402	1402	UINT num_passes = 0;
1403	1403
1404	1404	curr_effect = prescale_effect;
r31541	r31542
1426	1426
1427	1427	void shaders::deconverge_pass(render_target *rt, vec2f &texsize, vec2f &delta, vec2f &sourcedims)
1428	1428	{
1429		renderer d3d = (renderer )window->drawdata;
	1429	renderer d3d = (renderer )window->m_drawdata;
1430	1430	UINT num_passes = 0;
1431	1431
1432	1432	curr_effect = deconverge_effect;
r31541	r31542
1454	1454
1455	1455	void shaders::defocus_pass(render_target *rt, vec2f &texsize)
1456	1456	{
1457		renderer d3d = (renderer )window->drawdata;
	1457	renderer d3d = (renderer )window->m_drawdata;
1458	1458	UINT num_passes = 0;
1459	1459
1460	1460	// Defocus pass 1
r31541	r31542
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->drawdata;
	1506	renderer d3d = (renderer )window->m_drawdata;
1507	1507	UINT num_passes = 0;
1508	1508
1509	1509	curr_effect = phosphor_effect;
r31541	r31542
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->drawdata;
	1564	renderer d3d = (renderer )window->m_drawdata;
1565	1565	UINT num_passes = 0;
1566	1566
1567	1567	curr_effect = post_effect;
r31541	r31542
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->drawdata;
	1619	renderer d3d = (renderer )window->m_drawdata;
1620	1620	UINT num_passes = 0;
1621	1621
1622	1622	curr_effect = post_effect;
r31541	r31542
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->drawdata;
	1653	renderer d3d = (renderer )window->m_drawdata;
1654	1654	UINT num_passes = 0;
1655	1655
1656	1656	curr_effect = downsample_effect;
r31541	r31542
1755	1755	return;
1756	1756
1757	1757	UINT num_passes = 0;
1758		renderer d3d = (renderer )window->drawdata;
	1758	renderer d3d = (renderer )window->m_drawdata;
1759	1759	curr_texture = poly->get_texture();
1760	1760
1761	1761	if(PRIMFLAG_GET_SCREENTEX(d3d->get_last_texture_flags()) && curr_texture != NULL)
r31541	r31542
2080	2080	return NULL;
2081	2081	}
2082	2082
2083		renderer d3d = (renderer )window->drawdata;
	2083	renderer d3d = (renderer )window->m_drawdata;
2084	2084
2085	2085	return find_render_target(d3d->get_width(), d3d->get_height(), 0, 0);
2086	2086	}
2087	2087
2088	2088	void shaders::create_vector_target(render_primitive *prim)
2089	2089	{
2090		renderer d3d = (renderer )window->drawdata;
	2090	renderer d3d = (renderer )window->m_drawdata;
2091	2091	if (!add_render_target(d3d, NULL, d3d->get_width(), d3d->get_height(), 1, 1))
2092	2092	{
2093	2093	vector_enable = false;
r31541	r31542
2202	2202
2203	2203	enumerate_screens();
2204	2204
2205		renderer d3d = (renderer )window->drawdata;
	2205	renderer d3d = (renderer )window->m_drawdata;
2206	2206
2207	2207	int hlsl_prescale_x = prescale_force_x;
2208	2208	int hlsl_prescale_y = prescale_force_y;
r31541	r31542
2994	2994	}
2995	2995
2996	2996	shaders *shadersys = m_shader->m_shaders;
2997		renderer d3d = (renderer )shadersys->window->drawdata;
	2997	renderer d3d = (renderer )shadersys->window->m_drawdata;
2998	2998	hlsl_options *options = shadersys->options;
2999	2999
3000	3000	switch(m_id)

branches/osd/src/osd/windows/drawnone.c
r31541	r31542
87	87	static render_primitive_list drawnone_window_get_primitives(win_window_info window)
88	88	{
89	89	RECT client;
90		GetClientRect(window->hwnd, &client);
91		window->target->set_bounds(rect_width(&client), rect_height(&client), window->monitor->get_aspect());
92		return &window->target->get_primitives();
	90	GetClientRect(window->m_hwnd, &client);
	91	window->m_target->set_bounds(rect_width(&client), rect_height(&client), window->m_monitor->get_aspect());
	92	return &window->m_target->get_primitives();
93	93	}
94	94
95	95

branches/osd/src/osd/windows/drawgdi.c
r31541	r31542
82	82	{
83	83	// allocate memory for our structures
84	84	gdi_info *gdi = global_alloc_clear(gdi_info);
85		window->drawdata = gdi;
	85	window->m_drawdata = gdi;
86	86
87	87	// fill in the bitmap info header
88	88	gdi->bminfo.bmiHeader.biSize = sizeof(gdi->bminfo.bmiHeader);
r31541	r31542
106	106
107	107	static void drawgdi_window_destroy(win_window_info *window)
108	108	{
109		gdi_info gdi = (gdi_info )window->drawdata;
	109	gdi_info gdi = (gdi_info )window->m_drawdata;
110	110
111	111	// skip if nothing
112	112	if (gdi == NULL)
r31541	r31542
116	116	if (gdi->bmdata != NULL)
117	117	global_free_array(gdi->bmdata);
118	118	global_free(gdi);
119		window->drawdata = NULL;
	119	window->m_drawdata = NULL;
120	120	}
121	121
122	122
r31541	r31542
128	128	static render_primitive_list drawgdi_window_get_primitives(win_window_info window)
129	129	{
130	130	RECT client;
131		GetClientRect(window->hwnd, &client);
132		window->target->set_bounds(rect_width(&client), rect_height(&client), window->monitor->get_aspect());
133		return &window->target->get_primitives();
	131	GetClientRect(window->m_hwnd, &client);
	132	window->m_target->set_bounds(rect_width(&client), rect_height(&client), window->m_monitor->get_aspect());
	133	return &window->m_target->get_primitives();
134	134	}
135	135
136	136
r31541	r31542
141	141
142	142	static int drawgdi_window_draw(win_window_info *window, HDC dc, int update)
143	143	{
144		gdi_info gdi = (gdi_info )window->drawdata;
	144	gdi_info gdi = (gdi_info )window->m_drawdata;
145	145	int width, height, pitch;
146	146	RECT bounds;
147	147
148	148	// we don't have any special resize behaviors
149		if (window->resize_state == RESIZE_STATE_PENDING)
150		window->resize_state = RESIZE_STATE_NORMAL;
	149	if (window->m_resize_state == RESIZE_STATE_PENDING)
	150	window->m_resize_state = RESIZE_STATE_NORMAL;
151	151
152	152	// get the target bounds
153		GetClientRect(window->hwnd, &bounds);
	153	GetClientRect(window->m_hwnd, &bounds);
154	154
155	155	// compute width/height/pitch of target
156	156	width = rect_width(&bounds);
r31541	r31542
166	166	}
167	167
168	168	// draw the primitives to the bitmap
169		window->primlist->acquire_lock();
170		software_renderer<UINT32, 0,0,0, 16,8,0>::draw_primitives(*window->primlist, gdi->bmdata, width, height, pitch);
171		window->primlist->release_lock();
	169	window->m_primlist->acquire_lock();
	170	software_renderer<UINT32, 0,0,0, 16,8,0>::draw_primitives(*window->m_primlist, gdi->bmdata, width, height, pitch);
	171	window->m_primlist->release_lock();
172	172
173	173	// fill in bitmap-specific info
174	174	gdi->bminfo.bmiHeader.biWidth = pitch;

199869 Revisions