Previous

199869 Revisions

Next

r35190 Sunday 22nd February, 2015 at 00:14:37 UTC by Couriersud
Make OpenGL renderer available in mainline build as well. This needs to be explicitly enabled by specifying USE_OPENGL=1. More code alignment. [Couriersud]

[src/osd/modules/lib]	osdobj_common.h
[src/osd/sdl]	draw13.c drawogl.c gl_shader_mgr.c gl_shader_tool.h input.c osdsdl.h sdlmain.c video.c video.h window.h
[src/osd/windows]	drawd3d.c drawdd.c video.c video.h window.c window.h windows.mak winmain.c winmain.h

trunk/src/osd/modules/lib/osdobj_common.h

r243701	r243702
56	56	#define OSDOPTION_AUDIO_LATENCY         "audio_latency"
57	57
58	58	#define OSDOPTVAL_AUTO                  "auto"
	59	#define OSDOPTVAL_NONE                  "none"
59	60
	61
	62
60	63	//============================================================
61	64	//  TYPE DEFINITIONS
62	65	//============================================================

trunk/src/osd/sdl/draw13.c

r243701	r243702
525	525	#else
526	526	stemp = NULL;
527	527	#endif
528		if (stemp != NULL && strcmp(stemp, SDLOPTVAL_AUTO) == 0)
	528	if (stemp != NULL && strcmp(stemp, OSDOPTVAL_AUTO) == 0)
529	529	stemp = NULL;
530	530
531	531	// No fatalerror here since not all video drivers support GL !

trunk/src/osd/sdl/drawogl.c

r243701	r243702
23	23	#include "options.h"
24	24	#include "emuopts.h"
25	25
	26	#ifndef OSD_WINDOWS
26	27	// standard SDL headers
	28	#define TOBEMIGRATED 1
27	29	#include "sdlinc.h"
	30	#else
	31	#define SDLMAME_SDL2 1
	32	#include "GL/gl.h"
	33	#include "GL/glext.h"
	34	#include "GL/wglext.h"
28	35
	36	typedef HGLRC SDL_GLContext;
	37	#endif
	38
29	39	// OpenGL headers
	40	#ifndef OSD_WINDOWS
30	41	#include "osd_opengl.h"
	42	#endif
31	43	#include "modules/lib/osdlib.h"
32	44
33	45
r243701	r243702
121	133	#define OVERFLOW_SIZE   (1<<10)
122	134
123	135	// OSD headers
	136	#ifndef OSD_WINDOWS
124	137	#include "osdsdl.h"
125	138	#include "window.h"
	139	#else
	140	#include "../windows/window.h"
	141	typedef UINT64 HashT;
	142	#endif
126	143
127	144	//============================================================
128	145	//  DEBUGGING
r243701	r243702
149	166	//  MACROS
150	167	//============================================================
151	168
	169	#ifdef OSD_WINDOWS
	170	// texture formats
	171	// This used to be an enum, but these are now defines so we can use them as
	172	// preprocessor conditionals
	173	#define SDL_TEXFORMAT_ARGB32            (0) // non-16-bit textures or specials
	174	#define SDL_TEXFORMAT_RGB32             (1)
	175	#define SDL_TEXFORMAT_RGB32_PALETTED    (2)
	176	#define SDL_TEXFORMAT_YUY16             (3)
	177	#define SDL_TEXFORMAT_YUY16_PALETTED    (4)
	178	#define SDL_TEXFORMAT_PALETTE16         (5)
	179	#define SDL_TEXFORMAT_RGB15             (6)
	180	#define SDL_TEXFORMAT_RGB15_PALETTED    (7)
	181	#define SDL_TEXFORMAT_PALETTE16A        (8)
	182	// special texture formats for 16bpp texture destination support, do not use
	183	// to address the tex properties / tex functions arrays!
	184	#define SDL_TEXFORMAT_PALETTE16_ARGB1555    (16)
	185	#define SDL_TEXFORMAT_RGB15_ARGB1555        (17)
	186	#define SDL_TEXFORMAT_RGB15_PALETTED_ARGB1555   (18)
	187	#endif
	188
152	189	#define FSWAP(var1, var2) do { float temp = var1; var1 = var2; var2 = temp; } while (0)
153	190	#define GL_NO_PRIMITIVE -1
154	191
r243701	r243702
253	290	}
254	291
255	292	/* virtual */ int create();
	293	#ifdef OSD_WINDOWS
	294	/* virtual */ int draw(const HDC dc, const int update);
	295	#else
256	296	/* virtual */ int draw(const UINT32 dc, const int update);
	297	#endif
257	298	/* virtual */ int xy_to_render_target(const int x, const int y, int *xt, int *yt);
258	299	/* virtual */ void destroy();
259	300	/* virtual */ render_primitive_list *get_primitives()
260	301	{
261	302	int nw = 0; int nh = 0;
	303	#ifdef OSD_WINDOWS
	304	window().get_size(nw, nh);
	305	#else
262	306	window().blit_surface_size(nw, nh);
	307	#endif
263	308	if (nw != m_blitwidth || nh != m_blitheight)
264	309	{
265	310	m_blitwidth = nw; m_blitheight = nh;
r243701	r243702
269	314	return &window().target()->get_primitives();
270	315	}
271	316
	317	/* virtual */ void save() { }
	318	/* virtual */ void record() { }
	319	/* virtual */ void toggle_fsfx() { }
	320
272	321	private:
273	322	void destroy_all_textures();
274	323
r243701	r243702
298	347
299	348	#if (SDLMAME_SDL2)
300	349	SDL_GLContext   m_gl_context_id;
	350	#ifdef OSD_WINDOWS
	351	HDC            m_hdc;
	352	#endif
301	353	#else
302	354	#endif
303	355
r243701	r243702
483	535	return 0;
484	536	}
485	537
	538	//============================================================
	539	// Windows Compatibility
	540	//============================================================
486	541
	542	#ifdef OSD_WINDOWS
	543	PROC SDL_GL_GetProcAddress(const char *procname)
	544	{
	545	return wglGetProcAddress(procname);
	546	}
	547	#endif
	548
487	549	//============================================================
488	550	// Load the OGL function addresses
489	551	//============================================================
r243701	r243702
530	592	const char *stemp;
531	593
532	594	stemp = downcast<sdl_options &>(machine.options()).gl_lib();
533		if (stemp != NULL && strcmp(stemp, SDLOPTVAL_AUTO) == 0)
	595	if (stemp != NULL && strcmp(stemp, OSDOPTVAL_AUTO) == 0)
534	596	stemp = NULL;
535	597
536	598	if (SDL_GL_LoadLibrary(stemp) != 0) // Load library (default for e==NULL
r243701	r243702
552	614	char *extstr = (char *)glGetString(GL_EXTENSIONS);
553	615	char *vendor = (char *)glGetString(GL_VENDOR);
554	616
555		//printf("%s\n", extstr);
556
	617	//printf("%p\n", extstr);
	618	#ifdef OSD_WINDOWS
	619	if (!extstr)
	620	extstr = (char *)"";
	621	#endif
557	622	// print out the driver info for debugging
558	623	if (!shown_video_info)
559	624	{
r243701	r243702
679	744	}
680	745	}
681	746
	747	#ifdef TOBEMIGRATED
682	748	if (osd_getenv(SDLENV_VMWARE) != NULL)
683	749	{
684	750	m_usetexturerect = 1;
685	751	m_texpoweroftwo = 1;
686	752	}
	753	#endif
687	754	glGetIntegerv(GL_MAX_TEXTURE_SIZE, (GLint *)&m_texture_max_width);
688	755	glGetIntegerv(GL_MAX_TEXTURE_SIZE, (GLint *)&m_texture_max_height);
689	756	if (!shown_video_info)
r243701	r243702
724	791	// a
725	792	//============================================================
726	793
	794	#ifdef OSD_WINDOWS
	795	void
	796	setupPixelFormat(HDC hDC)
	797	{
	798	PIXELFORMATDESCRIPTOR pfd = {
	799	sizeof(PIXELFORMATDESCRIPTOR),  /* size */
	800	1,                              /* version */
	801	PFD_SUPPORT_OPENGL |
	802	PFD_DRAW_TO_WINDOW |
	803	PFD_DOUBLEBUFFER,               /* support double-buffering */
	804	PFD_TYPE_RGBA,                  /* color type */
	805	32,                             /* prefered color depth */
	806	0, 0, 0, 0, 0, 0,               /* color bits (ignored) */
	807	0,                              /* no alpha buffer */
	808	0,                              /* alpha bits (ignored) */
	809	0,                              /* no accumulation buffer */
	810	0, 0, 0, 0,                     /* accum bits (ignored) */
	811	16,                             /* depth buffer */
	812	0,                              /* no stencil buffer */
	813	0,                              /* no auxiliary buffers */
	814	PFD_MAIN_PLANE,                 /* main layer */
	815	0,                              /* reserved */
	816	0, 0, 0,                        /* no layer, visible, damage masks */
	817	};
	818	int pixelFormat;
	819
	820	pixelFormat = ChoosePixelFormat(hDC, &pfd);
	821	if (pixelFormat == 0) {
	822	osd_printf_error("ChoosePixelFormat failed.\n");
	823	exit(1);
	824	}
	825
	826	if (SetPixelFormat(hDC, pixelFormat, &pfd) != TRUE) {
	827	osd_printf_error("SetPixelFormat failed.\n");
	828	exit(1);
	829	}
	830	}
	831	#endif
727	832	int sdl_info_ogl::create()
728	833	{
729	834
730	835	#if (SDLMAME_SDL2)
731	836	// create renderer
732
	837	#ifdef OSD_WINDOWS
	838	m_hdc = GetDC(window().m_hwnd);
	839	setupPixelFormat(m_hdc);
	840	m_gl_context_id = wglCreateContext(m_hdc);
	841	if  (!m_gl_context_id)
	842	{
	843	char errorStr[1024];
	844	FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, GetLastError(), 0, errorStr, 255, NULL);
	845	osd_printf_error("OpenGL not supported on this driver %s\n", errorStr);
	846	return 1;
	847	}
	848	wglMakeCurrent(m_hdc, m_gl_context_id);
	849	#else
733	850	m_gl_context_id = SDL_GL_CreateContext(window().sdl_window());
734	851	if  (!m_gl_context_id)
735	852	{
736	853	osd_printf_error("OpenGL not supported on this driver: %s\n", SDL_GetError());
737	854	return 1;
738	855	}
	856	#endif
739	857
	858	#ifndef OSD_WINDOWS
740	859	SDL_GL_SetSwapInterval(video_config.waitvsync ? 2 : 0);
741
	860	#endif
742	861	#else
743	862	#endif
744	863
r243701	r243702
779	898	destroy_all_textures();
780	899
781	900	#if (SDLMAME_SDL2)
	901	#ifdef OSD_WINDOWS
	902	wglDeleteContext(m_gl_context_id);
	903	ReleaseDC(window().m_hwnd, m_hdc);
	904	#else
782	905	SDL_GL_DeleteContext(m_gl_context_id);
783	906	#endif
	907	#endif
784	908
785	909	}
786	910
r243701	r243702
815	939	return;
816	940
817	941	#if (SDLMAME_SDL2)
	942	#ifdef OSD_WINDOWS
	943	wglMakeCurrent(m_hdc, m_gl_context_id);
	944	#else
818	945	SDL_GL_MakeCurrent(window().sdl_window(), m_gl_context_id);
819	946	#endif
	947	#endif
820	948
821	949	if(window().m_primlist)
822	950	{
r243701	r243702
1199	1327	//  sdl_info::draw
1200	1328	//============================================================
1201	1329
1202		int sdl_info_ogl::draw(UINT32 dc, int update)
	1330	#ifdef OSD_WINDOWS
	1331	int sdl_info_ogl::draw(const HDC dc, const int update)
	1332	#else
	1333	int sdl_info_ogl::draw(const UINT32 dc, const int update)
	1334	#endif
1203	1335	{
1204	1336	render_primitive *prim;
1205	1337	texture_info *texture=NULL;
r243701	r243702
1207	1339	int  pendingPrimitive=GL_NO_PRIMITIVE, curPrimitive=GL_NO_PRIMITIVE;
1208	1340	int width = 0; int height = 0;
1209	1341
	1342	#ifdef TOBEMIGRATED
1210	1343	if (video_config.novideo)
1211	1344	{
1212	1345	return 0;
1213	1346	}
	1347	#endif
1214	1348
1215	1349	window().get_size(width, height);
1216	1350
r243701	r243702
1225	1359	}
1226	1360
1227	1361	#if (SDLMAME_SDL2)
	1362	#ifdef OSD_WINDOWS
	1363	wglMakeCurrent(m_hdc, m_gl_context_id);
	1364	#else
1228	1365	SDL_GL_MakeCurrent(window().sdl_window(), m_gl_context_id);
1229	1366	#endif
	1367	#endif
1230	1368
1231	1369	if (m_init_context)
1232	1370	{
r243701	r243702
1294	1432	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1295	1433	m_last_blendmode = BLENDMODE_ALPHA;
1296	1434
	1435	#ifdef TOBEMIGRATED
1297	1436	// set lines and points just barely above normal size to get proper results
1298	1437	glLineWidth(video_config.beamwidth);
1299	1438	glPointSize(video_config.beamwidth);
	1439	#endif
1300	1440
1301	1441	// set up a nice simple 2D coordinate system, so GL behaves exactly how we'd like.
1302	1442	//
r243701	r243702
1327	1467	// compute centering parameters
1328	1468	vofs = hofs = 0.0f;
1329	1469
	1470	#ifdef TOBEMIGRATED
1330	1471	if (video_config.centerv || video_config.centerh)
1331	1472	{
1332	1473	int ch, cw;
r243701	r243702
1343	1484	hofs = (cw - m_blitwidth) / 2.0f;
1344	1485	}
1345	1486	}
	1487	#else
	1488	#endif
1346	1489
1347	1490	m_last_hofs = hofs;
1348	1491	m_last_vofs = vofs;
r243701	r243702
1572	1715	#if (!SDLMAME_SDL2)
1573	1716	SDL_GL_SwapBuffers();
1574	1717	#else
	1718	#ifdef OSD_WINDOWS
	1719	SwapBuffers(m_hdc);
	1720	//wglSwapLayerBuffers(GetDC(window().m_hwnd), WGL_SWAP_MAIN_PLANE);
	1721	#else
1575	1722	SDL_GL_SwapWindow(window().sdl_window());
1576	1723	#endif
	1724	#endif
1577	1725	return 0;
1578	1726	}
1579	1727

trunk/src/osd/sdl/gl_shader_mgr.c

r243701	r243702
1	1	#include <stdio.h>   /* snprintf */
2	2	#include <stdlib.h>  /* malloc */
3	3
	4	#ifdef OSD_WINDOWS
	5	#include "GL/gl.h"
	6	#include "GL/glext.h"
	7	#else
4	8	#include "sdlinc.h"
5
6	9	#include "osd_opengl.h"
	10	#endif
7	11
8	12	#include "gl_shader_mgr.h"
9	13	#include "gl_shader_tool.h"
r243701	r243702
120	124	{
121	125	int i,j, err;
122	126
123		err = gl_shader_loadExtention((PFNGLGETPROCADDRESSOS)SDL_GL_GetProcAddress);
	127	#ifdef OSD_WINDOWS
	128	err = gl_shader_loadExtention((PFNGLGETPROCADDRESSOS)wglGetProcAddress);
	129	#else
	130	err = gl_shader_loadExtention((PFNGLGETPROCADDRESSOS)SDL_GL_GetProcAddress);
	131	#endif
124	132	if(err) return NULL;
125	133
126	134	for (i=0; !err && i<GLSL_VERTEX_SHADER_INT_NUMBER; i++)

trunk/src/osd/sdl/gl_shader_tool.h

r243701	r243702
51	51	#define GL_GLEXT_PROTOTYPES 1
52	52	#endif
53	53
	54	#ifdef OSD_WINDOWS
	55	#include "GL/gl.h"
	56	#include "GL/glext.h"
	57	#else
54	58	#include "osd_opengl.h"
	59	#endif
55	60
56	61	#if defined(SDLMAME_MACOSX)
57	62

trunk/src/osd/sdl/input.c

r243701	r243702
665	665	sprintf(defname, "%s%d", opt, dev + 1);
666	666
667	667	dev_name = machine.options().value(defname);
668		if (dev_name && *dev_name && strcmp(dev_name,SDLOPTVAL_AUTO))
	668	if (dev_name && *dev_name && strcmp(dev_name,OSDOPTVAL_AUTO))
669	669	{
670	670	devmap->map[dev].name = remove_spaces(machine, dev_name);
671	671	osd_printf_verbose("%s: Logical id %d: %s\n", label, dev + 1, devmap->map[dev].name);

trunk/src/osd/sdl/osdsdl.h

r243701	r243702
81	81	#define SDLOPTION_RENDERDRIVER          "renderdriver"
82	82	#define SDLOPTION_GL_LIB                "gl_lib"
83	83
84		#define SDLOPTVAL_NONE                  "none"
85		#define SDLOPTVAL_AUTO                  "auto"
86
87	84	#define SDLOPTVAL_OPENGL                "opengl"
88	85	#define SDLOPTVAL_SOFT                  "soft"
89	86	#define SDLOPTVAL_SDL2ACCEL             "accel"
r243701	r243702
109	106	/* Vas Crabb: Default GL-lib for MACOSX */
110	107	#define SDLOPTVAL_GLLIB                 "/System/Library/Frameworks/OpenGL.framework/Libraries/libGL.dylib"
111	108	#else
112		#define SDLOPTVAL_GLLIB                 SDLOPTVAL_AUTO
	109	#define SDLOPTVAL_GLLIB                 OSDOPTVAL_AUTO
113	110	#endif
114	111
115	112
r243701	r243702
209	206	private:
210	207	virtual void osd_exit();
211	208
212		// FIXME: remove machine usage
213		void extract_video_config(running_machine &machine);
	209	void extract_video_config();
214	210
215	211	sdl_options &m_options;
216	212

trunk/src/osd/sdl/sdlmain.c

r243701	r243702
103	103	{ SDLOPTION_CENTERH,                      "1",        OPTION_BOOLEAN,    "center horizontally within the view area" },
104	104	{ SDLOPTION_CENTERV,                      "1",        OPTION_BOOLEAN,    "center vertically within the view area" },
105	105	#if (SDLMAME_SDL2)
106		{ SDLOPTION_SCALEMODE ";sm",         SDLOPTVAL_NONE,  OPTION_STRING,     "Scale mode: none, hwblit, hwbest, yv12, yuy2, yv12x2, yuy2x2 (-video soft only)" },
	106	{ SDLOPTION_SCALEMODE ";sm",         OSDOPTVAL_NONE,  OPTION_STRING,     "Scale mode: none, hwblit, hwbest, yv12, yuy2, yv12x2, yuy2x2 (-video soft only)" },
107	107	#else
108		{ SDLOPTION_SCALEMODE ";sm",         SDLOPTVAL_NONE,  OPTION_STRING,     "Scale mode: none, async, yv12, yuy2, yv12x2, yuy2x2 (-video soft only)" },
	108	{ SDLOPTION_SCALEMODE ";sm",         OSDOPTVAL_NONE,  OPTION_STRING,     "Scale mode: none, async, yv12, yuy2, yv12x2, yuy2x2 (-video soft only)" },
109	109	#endif
110	110	#if USE_OPENGL
111	111	// OpenGL specific options
r243701	r243702
118	118	{ SDLOPTION_GL_PBO,                       "1",    OPTION_BOOLEAN, "enable OpenGL PBO,  if available (default on)" },
119	119	{ SDLOPTION_GL_GLSL,                      "0",    OPTION_BOOLEAN, "enable OpenGL GLSL, if available (default off)" },
120	120	{ SDLOPTION_GLSL_FILTER,                  "1",    OPTION_STRING,  "enable OpenGL GLSL filtering instead of FF filtering 0-plain, 1-bilinear (default)" },
121		{ SDLOPTION_SHADER_MAME "0",     SDLOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader set mame bitmap 0" },
122		{ SDLOPTION_SHADER_MAME "1",     SDLOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader set mame bitmap 1" },
123		{ SDLOPTION_SHADER_MAME "2",     SDLOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader set mame bitmap 2" },
124		{ SDLOPTION_SHADER_MAME "3",     SDLOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader set mame bitmap 3" },
125		{ SDLOPTION_SHADER_MAME "4",     SDLOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader set mame bitmap 4" },
126		{ SDLOPTION_SHADER_MAME "5",     SDLOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader set mame bitmap 5" },
127		{ SDLOPTION_SHADER_MAME "6",     SDLOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader set mame bitmap 6" },
128		{ SDLOPTION_SHADER_MAME "7",     SDLOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader set mame bitmap 7" },
129		{ SDLOPTION_SHADER_MAME "8",     SDLOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader set mame bitmap 8" },
130		{ SDLOPTION_SHADER_MAME "9",     SDLOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader set mame bitmap 9" },
131		{ SDLOPTION_SHADER_SCREEN "0",   SDLOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader screen bitmap 0" },
132		{ SDLOPTION_SHADER_SCREEN "1",   SDLOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader screen bitmap 1" },
133		{ SDLOPTION_SHADER_SCREEN "2",   SDLOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader screen bitmap 2" },
134		{ SDLOPTION_SHADER_SCREEN "3",   SDLOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader screen bitmap 3" },
135		{ SDLOPTION_SHADER_SCREEN "4",   SDLOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader screen bitmap 4" },
136		{ SDLOPTION_SHADER_SCREEN "5",   SDLOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader screen bitmap 5" },
137		{ SDLOPTION_SHADER_SCREEN "6",   SDLOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader screen bitmap 6" },
138		{ SDLOPTION_SHADER_SCREEN "7",   SDLOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader screen bitmap 7" },
139		{ SDLOPTION_SHADER_SCREEN "8",   SDLOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader screen bitmap 8" },
140		{ SDLOPTION_SHADER_SCREEN "9",   SDLOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader screen bitmap 9" },
	121	{ SDLOPTION_SHADER_MAME "0",     OSDOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader set mame bitmap 0" },
	122	{ SDLOPTION_SHADER_MAME "1",     OSDOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader set mame bitmap 1" },
	123	{ SDLOPTION_SHADER_MAME "2",     OSDOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader set mame bitmap 2" },
	124	{ SDLOPTION_SHADER_MAME "3",     OSDOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader set mame bitmap 3" },
	125	{ SDLOPTION_SHADER_MAME "4",     OSDOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader set mame bitmap 4" },
	126	{ SDLOPTION_SHADER_MAME "5",     OSDOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader set mame bitmap 5" },
	127	{ SDLOPTION_SHADER_MAME "6",     OSDOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader set mame bitmap 6" },
	128	{ SDLOPTION_SHADER_MAME "7",     OSDOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader set mame bitmap 7" },
	129	{ SDLOPTION_SHADER_MAME "8",     OSDOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader set mame bitmap 8" },
	130	{ SDLOPTION_SHADER_MAME "9",     OSDOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader set mame bitmap 9" },
	131	{ SDLOPTION_SHADER_SCREEN "0",   OSDOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader screen bitmap 0" },
	132	{ SDLOPTION_SHADER_SCREEN "1",   OSDOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader screen bitmap 1" },
	133	{ SDLOPTION_SHADER_SCREEN "2",   OSDOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader screen bitmap 2" },
	134	{ SDLOPTION_SHADER_SCREEN "3",   OSDOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader screen bitmap 3" },
	135	{ SDLOPTION_SHADER_SCREEN "4",   OSDOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader screen bitmap 4" },
	136	{ SDLOPTION_SHADER_SCREEN "5",   OSDOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader screen bitmap 5" },
	137	{ SDLOPTION_SHADER_SCREEN "6",   OSDOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader screen bitmap 6" },
	138	{ SDLOPTION_SHADER_SCREEN "7",   OSDOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader screen bitmap 7" },
	139	{ SDLOPTION_SHADER_SCREEN "8",   OSDOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader screen bitmap 8" },
	140	{ SDLOPTION_SHADER_SCREEN "9",   OSDOPTVAL_NONE,  OPTION_STRING,  "custom OpenGL GLSL shader screen bitmap 9" },
141	141	#endif
142	142
143	143	// full screen options
r243701	r243702
158	158
159	159	// joystick mapping
160	160	{ NULL,                                  NULL,   OPTION_HEADER,     "SDL JOYSTICK MAPPING" },
161		{ SDLOPTION_JOYINDEX "1",                SDLOPTVAL_AUTO, OPTION_STRING,         "name of joystick mapped to joystick #1" },
162		{ SDLOPTION_JOYINDEX "2",                SDLOPTVAL_AUTO, OPTION_STRING,         "name of joystick mapped to joystick #2" },
163		{ SDLOPTION_JOYINDEX "3",                SDLOPTVAL_AUTO, OPTION_STRING,         "name of joystick mapped to joystick #3" },
164		{ SDLOPTION_JOYINDEX "4",                SDLOPTVAL_AUTO, OPTION_STRING,         "name of joystick mapped to joystick #4" },
165		{ SDLOPTION_JOYINDEX "5",                SDLOPTVAL_AUTO, OPTION_STRING,         "name of joystick mapped to joystick #5" },
166		{ SDLOPTION_JOYINDEX "6",                SDLOPTVAL_AUTO, OPTION_STRING,         "name of joystick mapped to joystick #6" },
167		{ SDLOPTION_JOYINDEX "7",                SDLOPTVAL_AUTO, OPTION_STRING,         "name of joystick mapped to joystick #7" },
168		{ SDLOPTION_JOYINDEX "8",                SDLOPTVAL_AUTO, OPTION_STRING,         "name of joystick mapped to joystick #8" },
	161	{ SDLOPTION_JOYINDEX "1",                OSDOPTVAL_AUTO, OPTION_STRING,         "name of joystick mapped to joystick #1" },
	162	{ SDLOPTION_JOYINDEX "2",                OSDOPTVAL_AUTO, OPTION_STRING,         "name of joystick mapped to joystick #2" },
	163	{ SDLOPTION_JOYINDEX "3",                OSDOPTVAL_AUTO, OPTION_STRING,         "name of joystick mapped to joystick #3" },
	164	{ SDLOPTION_JOYINDEX "4",                OSDOPTVAL_AUTO, OPTION_STRING,         "name of joystick mapped to joystick #4" },
	165	{ SDLOPTION_JOYINDEX "5",                OSDOPTVAL_AUTO, OPTION_STRING,         "name of joystick mapped to joystick #5" },
	166	{ SDLOPTION_JOYINDEX "6",                OSDOPTVAL_AUTO, OPTION_STRING,         "name of joystick mapped to joystick #6" },
	167	{ SDLOPTION_JOYINDEX "7",                OSDOPTVAL_AUTO, OPTION_STRING,         "name of joystick mapped to joystick #7" },
	168	{ SDLOPTION_JOYINDEX "8",                OSDOPTVAL_AUTO, OPTION_STRING,         "name of joystick mapped to joystick #8" },
169	169	{ SDLOPTION_SIXAXIS,                     "0",    OPTION_BOOLEAN,    "Use special handling for PS3 Sixaxis controllers" },
170	170
171	171	#if (USE_XINPUT)
172	172	// lightgun mapping
173	173	{ NULL,                                  NULL,   OPTION_HEADER,     "SDL LIGHTGUN MAPPING" },
174		{ SDLOPTION_LIGHTGUNINDEX "1",           SDLOPTVAL_AUTO, OPTION_STRING,         "name of lightgun mapped to lightgun #1" },
175		{ SDLOPTION_LIGHTGUNINDEX "2",           SDLOPTVAL_AUTO, OPTION_STRING,         "name of lightgun mapped to lightgun #2" },
176		{ SDLOPTION_LIGHTGUNINDEX "3",           SDLOPTVAL_AUTO, OPTION_STRING,         "name of lightgun mapped to lightgun #3" },
177		{ SDLOPTION_LIGHTGUNINDEX "4",           SDLOPTVAL_AUTO, OPTION_STRING,         "name of lightgun mapped to lightgun #4" },
178		{ SDLOPTION_LIGHTGUNINDEX "5",           SDLOPTVAL_AUTO, OPTION_STRING,         "name of lightgun mapped to lightgun #5" },
179		{ SDLOPTION_LIGHTGUNINDEX "6",           SDLOPTVAL_AUTO, OPTION_STRING,         "name of lightgun mapped to lightgun #6" },
180		{ SDLOPTION_LIGHTGUNINDEX "7",           SDLOPTVAL_AUTO, OPTION_STRING,         "name of lightgun mapped to lightgun #7" },
181		{ SDLOPTION_LIGHTGUNINDEX "8",           SDLOPTVAL_AUTO, OPTION_STRING,         "name of lightgun mapped to lightgun #8" },
	174	{ SDLOPTION_LIGHTGUNINDEX "1",           OSDOPTVAL_AUTO, OPTION_STRING,         "name of lightgun mapped to lightgun #1" },
	175	{ SDLOPTION_LIGHTGUNINDEX "2",           OSDOPTVAL_AUTO, OPTION_STRING,         "name of lightgun mapped to lightgun #2" },
	176	{ SDLOPTION_LIGHTGUNINDEX "3",           OSDOPTVAL_AUTO, OPTION_STRING,         "name of lightgun mapped to lightgun #3" },
	177	{ SDLOPTION_LIGHTGUNINDEX "4",           OSDOPTVAL_AUTO, OPTION_STRING,         "name of lightgun mapped to lightgun #4" },
	178	{ SDLOPTION_LIGHTGUNINDEX "5",           OSDOPTVAL_AUTO, OPTION_STRING,         "name of lightgun mapped to lightgun #5" },
	179	{ SDLOPTION_LIGHTGUNINDEX "6",           OSDOPTVAL_AUTO, OPTION_STRING,         "name of lightgun mapped to lightgun #6" },
	180	{ SDLOPTION_LIGHTGUNINDEX "7",           OSDOPTVAL_AUTO, OPTION_STRING,         "name of lightgun mapped to lightgun #7" },
	181	{ SDLOPTION_LIGHTGUNINDEX "8",           OSDOPTVAL_AUTO, OPTION_STRING,         "name of lightgun mapped to lightgun #8" },
182	182	#endif
183	183
184	184	#if (SDLMAME_SDL2)
185	185	{ NULL,                                  NULL,   OPTION_HEADER,     "SDL MOUSE MAPPING" },
186		{ SDLOPTION_MOUSEINDEX "1",              SDLOPTVAL_AUTO, OPTION_STRING,         "name of mouse mapped to mouse #1" },
187		{ SDLOPTION_MOUSEINDEX "2",              SDLOPTVAL_AUTO, OPTION_STRING,         "name of mouse mapped to mouse #2" },
188		{ SDLOPTION_MOUSEINDEX "3",              SDLOPTVAL_AUTO, OPTION_STRING,         "name of mouse mapped to mouse #3" },
189		{ SDLOPTION_MOUSEINDEX "4",              SDLOPTVAL_AUTO, OPTION_STRING,         "name of mouse mapped to mouse #4" },
190		{ SDLOPTION_MOUSEINDEX "5",              SDLOPTVAL_AUTO, OPTION_STRING,         "name of mouse mapped to mouse #5" },
191		{ SDLOPTION_MOUSEINDEX "6",              SDLOPTVAL_AUTO, OPTION_STRING,         "name of mouse mapped to mouse #6" },
192		{ SDLOPTION_MOUSEINDEX "7",              SDLOPTVAL_AUTO, OPTION_STRING,         "name of mouse mapped to mouse #7" },
193		{ SDLOPTION_MOUSEINDEX "8",              SDLOPTVAL_AUTO, OPTION_STRING,         "name of mouse mapped to mouse #8" },
	186	{ SDLOPTION_MOUSEINDEX "1",              OSDOPTVAL_AUTO, OPTION_STRING,         "name of mouse mapped to mouse #1" },
	187	{ SDLOPTION_MOUSEINDEX "2",              OSDOPTVAL_AUTO, OPTION_STRING,         "name of mouse mapped to mouse #2" },
	188	{ SDLOPTION_MOUSEINDEX "3",              OSDOPTVAL_AUTO, OPTION_STRING,         "name of mouse mapped to mouse #3" },
	189	{ SDLOPTION_MOUSEINDEX "4",              OSDOPTVAL_AUTO, OPTION_STRING,         "name of mouse mapped to mouse #4" },
	190	{ SDLOPTION_MOUSEINDEX "5",              OSDOPTVAL_AUTO, OPTION_STRING,         "name of mouse mapped to mouse #5" },
	191	{ SDLOPTION_MOUSEINDEX "6",              OSDOPTVAL_AUTO, OPTION_STRING,         "name of mouse mapped to mouse #6" },
	192	{ SDLOPTION_MOUSEINDEX "7",              OSDOPTVAL_AUTO, OPTION_STRING,         "name of mouse mapped to mouse #7" },
	193	{ SDLOPTION_MOUSEINDEX "8",              OSDOPTVAL_AUTO, OPTION_STRING,         "name of mouse mapped to mouse #8" },
194	194
195	195	{ NULL,                                  NULL,   OPTION_HEADER,     "SDL KEYBOARD MAPPING" },
196		{ SDLOPTION_KEYBINDEX "1",               SDLOPTVAL_AUTO, OPTION_STRING,         "name of keyboard mapped to keyboard #1" },
197		{ SDLOPTION_KEYBINDEX "2",               SDLOPTVAL_AUTO, OPTION_STRING,         "name of keyboard mapped to keyboard #2" },
198		{ SDLOPTION_KEYBINDEX "3",               SDLOPTVAL_AUTO, OPTION_STRING,         "name of keyboard mapped to keyboard #3" },
199		{ SDLOPTION_KEYBINDEX "4",               SDLOPTVAL_AUTO, OPTION_STRING,         "name of keyboard mapped to keyboard #4" },
200		{ SDLOPTION_KEYBINDEX "5",               SDLOPTVAL_AUTO, OPTION_STRING,         "name of keyboard mapped to keyboard #5" },
201		{ SDLOPTION_KEYBINDEX "6",               SDLOPTVAL_AUTO, OPTION_STRING,         "name of keyboard mapped to keyboard #6" },
202		{ SDLOPTION_KEYBINDEX "7",               SDLOPTVAL_AUTO, OPTION_STRING,         "name of keyboard mapped to keyboard #7" },
203		{ SDLOPTION_KEYBINDEX "8",               SDLOPTVAL_AUTO, OPTION_STRING,         "name of keyboard mapped to keyboard #8" },
	196	{ SDLOPTION_KEYBINDEX "1",               OSDOPTVAL_AUTO, OPTION_STRING,         "name of keyboard mapped to keyboard #1" },
	197	{ SDLOPTION_KEYBINDEX "2",               OSDOPTVAL_AUTO, OPTION_STRING,         "name of keyboard mapped to keyboard #2" },
	198	{ SDLOPTION_KEYBINDEX "3",               OSDOPTVAL_AUTO, OPTION_STRING,         "name of keyboard mapped to keyboard #3" },
	199	{ SDLOPTION_KEYBINDEX "4",               OSDOPTVAL_AUTO, OPTION_STRING,         "name of keyboard mapped to keyboard #4" },
	200	{ SDLOPTION_KEYBINDEX "5",               OSDOPTVAL_AUTO, OPTION_STRING,         "name of keyboard mapped to keyboard #5" },
	201	{ SDLOPTION_KEYBINDEX "6",               OSDOPTVAL_AUTO, OPTION_STRING,         "name of keyboard mapped to keyboard #6" },
	202	{ SDLOPTION_KEYBINDEX "7",               OSDOPTVAL_AUTO, OPTION_STRING,         "name of keyboard mapped to keyboard #7" },
	203	{ SDLOPTION_KEYBINDEX "8",               OSDOPTVAL_AUTO, OPTION_STRING,         "name of keyboard mapped to keyboard #8" },
204	204	#endif
205	205	// SDL low level driver options
206	206	{ NULL,                                  NULL,   OPTION_HEADER,     "SDL LOWLEVEL DRIVER OPTIONS" },
207		{ SDLOPTION_VIDEODRIVER ";vd",           SDLOPTVAL_AUTO,  OPTION_STRING,        "sdl video driver to use ('x11', 'directfb', ... or 'auto' for SDL default" },
	207	{ SDLOPTION_VIDEODRIVER ";vd",           OSDOPTVAL_AUTO,  OPTION_STRING,        "sdl video driver to use ('x11', 'directfb', ... or 'auto' for SDL default" },
208	208	#if (SDLMAME_SDL2)
209		{ SDLOPTION_RENDERDRIVER ";rd",          SDLOPTVAL_AUTO,  OPTION_STRING,        "sdl render driver to use ('software', 'opengl', 'directfb' ... or 'auto' for SDL default" },
	209	{ SDLOPTION_RENDERDRIVER ";rd",          OSDOPTVAL_AUTO,  OPTION_STRING,        "sdl render driver to use ('software', 'opengl', 'directfb' ... or 'auto' for SDL default" },
210	210	#endif
211		{ SDLOPTION_AUDIODRIVER ";ad",           SDLOPTVAL_AUTO,  OPTION_STRING,        "sdl audio driver to use ('alsa', 'arts', ... or 'auto' for SDL default" },
	211	{ SDLOPTION_AUDIODRIVER ";ad",           OSDOPTVAL_AUTO,  OPTION_STRING,        "sdl audio driver to use ('alsa', 'arts', ... or 'auto' for SDL default" },
212	212	#if USE_OPENGL
213	213	{ SDLOPTION_GL_LIB,                      SDLOPTVAL_GLLIB, OPTION_STRING,        "alternative libGL.so to use; 'auto' for system default" },
214	214	#endif
r243701	r243702
542	542
543	543	// Some driver options - must be before audio init!
544	544	stemp = options().audio_driver();
545		if (stemp != NULL && strcmp(stemp, SDLOPTVAL_AUTO) != 0)
	545	if (stemp != NULL && strcmp(stemp, OSDOPTVAL_AUTO) != 0)
546	546	{
547	547	osd_printf_verbose("Setting SDL audiodriver '%s' ...\n", stemp);
548	548	osd_setenv(SDLENV_AUDIODRIVER, stemp, 1);
549	549	}
550	550
551	551	stemp = options().video_driver();
552		if (stemp != NULL && strcmp(stemp, SDLOPTVAL_AUTO) != 0)
	552	if (stemp != NULL && strcmp(stemp, OSDOPTVAL_AUTO) != 0)
553	553	{
554	554	osd_printf_verbose("Setting SDL videodriver '%s' ...\n", stemp);
555	555	osd_setenv(SDLENV_VIDEODRIVER, stemp, 1);
r243701	r243702
559	559	stemp = options().render_driver();
560	560	if (stemp != NULL)
561	561	{
562		if (strcmp(stemp, SDLOPTVAL_AUTO) != 0)
	562	if (strcmp(stemp, OSDOPTVAL_AUTO) != 0)
563	563	{
564	564	osd_printf_verbose("Setting SDL renderdriver '%s' ...\n", stemp);
565	565	//osd_setenv(SDLENV_RENDERDRIVER, stemp, 1);
r243701	r243702
584	584	/* FIXME: move lib loading code from drawogl.c here */
585	585
586	586	stemp = options().gl_lib();
587		if (stemp != NULL && strcmp(stemp, SDLOPTVAL_AUTO) != 0)
	587	if (stemp != NULL && strcmp(stemp, OSDOPTVAL_AUTO) != 0)
588	588	{
589	589	osd_setenv("SDL_VIDEO_GL_DRIVER", stemp, 1);
590	590	osd_printf_verbose("Setting SDL_VIDEO_GL_DRIVER = '%s' ...\n", stemp);

trunk/src/osd/sdl/video.c

r243701	r243702
95	95	int index;
96	96
97	97	// extract data from the options
98		extract_video_config(machine());
	98	extract_video_config();
99	99
100	100	// set up monitors first
101	101	sdl_monitor_info::init();
r243701	r243702
418	418	monitor = global_alloc_clear(sdl_monitor_info);
419	419	monitor->m_handle = i;
420	420
421		snprintf(monitor->m_monitor_device, sizeof(monitor->m_monitor_device)-1, "%s%d", OSDOPTION_SCREEN,i);
	421	snprintf(monitor->m_name, sizeof(monitor->m_name)-1, "%s%d", OSDOPTION_SCREEN,i);
422	422
423	423	SDL_GetDesktopDisplayMode(i, &dmode);
424	424	SDL_GetDisplayBounds(i, &monitor->m_dimensions);
r243701	r243702
426	426	// guess the aspect ratio assuming square pixels
427	427	monitor->m_aspect = (float)(dmode.w) / (float)(dmode.h);
428	428
429		osd_printf_verbose("Adding monitor %s (%d x %d)\n", monitor->m_monitor_device, dmode.w, dmode.h);
	429	osd_printf_verbose("Adding monitor %s (%d x %d)\n", monitor->m_name, dmode.w, dmode.h);
430	430
431	431	monx += dmode.w;
432	432
r243701	r243702
488	488	for (monitor = sdl_monitor_info::list; monitor != NULL; monitor = monitor->next())
489	489	{
490	490	moncount++;
491		if (strcmp(scrname, monitor->device()) == 0)
	491	if (strcmp(scrname, monitor->devicename()) == 0)
492	492	goto finishit;
493	493	}
494	494	}
r243701	r243702
584	584	//  extract_video_config
585	585	//============================================================
586	586
587		void sdl_osd_interface::extract_video_config(running_machine &machine)
	587	void sdl_osd_interface::extract_video_config()
588	588	{
589	589	const char *stemp;
590	590
r243701	r243702
592	592
593	593	// global options: extract the data
594	594	video_config.windowed      = options().window();
	595	video_config.prescale      = options().prescale();
595	596	video_config.keepaspect    = options().keep_aspect();
596	597	video_config.numscreens    = options().numscreens();
597	598	video_config.fullstretch   = options().uneven_stretch();
r243701	r243702
599	600	video_config.restrictonemonitor = !options().use_all_heads();
600	601	#endif
601	602
602
603		if (machine.debug_flags & DEBUG_FLAG_OSD_ENABLED)
	603	// if we are in debug mode, never go full screen
	604	if (machine().debug_flags & DEBUG_FLAG_OSD_ENABLED)
604	605	video_config.windowed = TRUE;
605	606
606	607	// default to working video please
r243701	r243702
618	619	}
619	620	if (strcmp(stemp, SDLOPTVAL_SOFT) == 0)
620	621	video_config.mode = VIDEO_MODE_SOFT;
621		else if (strcmp(stemp, SDLOPTVAL_NONE) == 0)
	622	else if (strcmp(stemp, OSDOPTVAL_NONE) == 0)
622	623	{
623	624	video_config.mode = VIDEO_MODE_SOFT;
624	625	video_config.novideo = 1;
r243701	r243702
656	657	}
657	658
658	659	#if (USE_OPENGL || SDLMAME_SDL2)
659		video_config.filter        = options().filter();
	660	video_config.filter        = options().filter();
660	661	#endif
661	662
662	663	#if (USE_OPENGL)
663		video_config.prescale      = options().prescale();
664	664	if (video_config.prescale < 1 || video_config.prescale > 3)
665	665	{
666	666	osd_printf_warning("Invalid prescale option, reverting to '1'\n");
r243701	r243702
683	683	for(i=0; i<GLSL_SHADER_MAX; i++)
684	684	{
685	685	stemp = options().shader_mame(i);
686		if (stemp && strcmp(stemp, SDLOPTVAL_NONE) != 0 && strlen(stemp)>0)
	686	if (stemp && strcmp(stemp, OSDOPTVAL_NONE) != 0 && strlen(stemp)>0)
687	687	{
688	688	video_config.glsl_shader_mamebm[i] = (char *) malloc(strlen(stemp)+1);
689	689	strcpy(video_config.glsl_shader_mamebm[i], stemp);
r243701	r243702
698	698	for(i=0; i<GLSL_SHADER_MAX; i++)
699	699	{
700	700	stemp = options().shader_screen(i);
701		if (stemp && strcmp(stemp, SDLOPTVAL_NONE) != 0 && strlen(stemp)>0)
	701	if (stemp && strcmp(stemp, OSDOPTVAL_NONE) != 0 && strlen(stemp)>0)
702	702	{
703	703	video_config.glsl_shader_scrn[i] = (char *) malloc(strlen(stemp)+1);
704	704	strcpy(video_config.glsl_shader_scrn[i], stemp);
r243701	r243702
763	763	{
764	764	int num = 0, den = 1;
765	765
766		if (strcmp(data, SDLOPTVAL_AUTO) == 0)
	766	if (strcmp(data, OSDOPTVAL_AUTO) == 0)
767	767	{
768		if (strcmp(defdata,SDLOPTVAL_AUTO) == 0)
	768	if (strcmp(defdata,OSDOPTVAL_AUTO) == 0)
769	769	return 0;
770	770	data = defdata;
771	771	}
r243701	r243702
782	782	static void get_resolution(const char *defdata, const char *data, sdl_window_config *config, int report_error)
783	783	{
784	784	config->width = config->height = config->depth = config->refresh = 0;
785		if (strcmp(data, SDLOPTVAL_AUTO) == 0)
	785	if (strcmp(data, OSDOPTVAL_AUTO) == 0)
786	786	{
787		if (strcmp(defdata, SDLOPTVAL_AUTO) == 0)
788		{
	787	if (strcmp(defdata, OSDOPTVAL_AUTO) == 0)
789	788	return;
790		}
791
792	789	data = defdata;
793	790	}
794	791

trunk/src/osd/sdl/video.h

r243701	r243702
70	70	sdl_monitor_info(const UINT64 handle, const char *monitor_device, float aspect)
71	71	: m_next(NULL), m_handle(handle), m_aspect(aspect)
72	72	{
73		strncpy(m_monitor_device, monitor_device, 64);
	73	strncpy(m_name, monitor_device, 64);
74	74	refresh();
75	75	}
76	76
77	77	const UINT64 handle() { return m_handle; }
78	78	const SDL_Rect &position_size() { refresh(); return m_dimensions; }
79	79
80		const char *device() { return m_monitor_device; }
	80	const char *devicename() { refresh(); return (m_name != NULL) ? m_name : "UNKNOWN"; }
81	81
82	82	float aspect();
83	83
r243701	r243702
97	97	static sdl_monitor_info *primary_monitor;
98	98	static sdl_monitor_info *list;
99	99
100		// FIXME: shouldn't be here - see windows enumeration callback
101	100	sdl_monitor_info     * m_next;                   // pointer to next monitor in list
102	101	private:
103	102	void refresh();
104	103
105	104	UINT64              m_handle;                 // handle to the monitor
106	105	SDL_Rect         m_dimensions;
107		char                m_monitor_device[64];
	106	char                m_name[64];
108	107	float               m_aspect;                 // computed/configured aspect ratio of the physical device
109	108	};
110	109
r243701	r243702
126	125
127	126	// global configuration
128	127	int                 windowed;               // start windowed?
129		int                 prescale;               // prescale factor (supported by accel driver)
130		int                 keepaspect;             // keep aspect ratio?
	128	int                 prescale;                   // prescale factor
	129	int                 keepaspect;                 // keep aspect ratio
131	130	int                 numscreens;             // number of screens
132	131	int                 centerh;
133	132	int                 centerv;

trunk/src/osd/sdl/window.h

r243701	r243702
66	66
67	67	float aspect() const { return monitor()->aspect(); }
68	68
	69	virtual void get_size(int &w, int &h) = 0;
	70
69	71	#ifdef OSD_SDL
70	72	virtual void blit_surface_size(int &blitwidth, int &blitheight) = 0;
71	73	virtual sdl_monitor_info *monitor() const = 0;
72		virtual void get_size(int &w, int &h) = 0;
73	74	#if (SDLMAME_SDL2)
74	75	virtual SDL_Window *sdl_window() = 0;
75	76	#else

trunk/src/osd/windows/drawd3d.c

r243701	r243702
1266	1266	HMONITOR curmonitor = (*d3dintf->d3d.get_adapter_monitor)(d3dintf, adapternum);
1267	1267
1268	1268	// if we match the proposed monitor, this is it
1269		if (curmonitor == window().monitor()->handle)
	1269	if (curmonitor == window().monitor()->handle())
1270	1270	{
1271	1271	return adapternum;
1272	1272	}

trunk/src/osd/windows/drawdd.c

r243701	r243702
964	964	ClientToScreen(window().m_hwnd, &((LPPOINT)&outer)[1]);
965	965
966	966	// adjust to be relative to the monitor
967		outer.left -= monitor->info.rcMonitor.left;
968		outer.right -= monitor->info.rcMonitor.left;
969		outer.top -= monitor->info.rcMonitor.top;
970		outer.bottom -= monitor->info.rcMonitor.top;
	967	RECT pos = monitor->position_size();
	968	outer.left -= pos.left;
	969	outer.right -= pos.left;
	970	outer.top -= pos.top;
	971	outer.bottom -= pos.top;
971	972	}
972	973
973	974	// compute outer rect -- full screen version
r243701	r243702
1160	1161	monitor_enum_info *einfo = (monitor_enum_info *)context;
1161	1162
1162	1163	// do we match the desired monitor?
1163		if (hmonitor == einfo->monitor->handle || (hmonitor == NULL && (einfo->monitor->info.dwFlags & MONITORINFOF_PRIMARY) != 0))
	1164	if (hmonitor == einfo->monitor->handle() || (hmonitor == NULL && einfo->monitor->is_primary()))
1164	1165	{
1165	1166	einfo->guid_ptr = (guid != NULL) ? &einfo->guid : NULL;
1166	1167	if (guid != NULL)

trunk/src/osd/windows/video.c

r243701	r243702
51	51	//============================================================
52	52
53	53	static void init_monitors(void);
54		static BOOL CALLBACK monitor_enum_callback(HMONITOR handle, HDC dc, LPRECT rect, LPARAM data);
55	54	static win_monitor_info *pick_monitor(windows_options &options, int index);
56	55
57	56	static void check_osd_inputs(running_machine &machine);
58	57
59		static void extract_video_config(running_machine &machine);
60	58	static float get_aspect(const char *defdata, const char *data, int report_error);
61	59	static void get_resolution(const char *defdata, const char *data, win_window_config *config, int report_error);
62	60
r243701	r243702
71	69	int index;
72	70
73	71	// extract data from the options
74		extract_video_config(machine());
	72	extract_video_config();
75	73
76	74	// set up monitors first
77	75	init_monitors();
r243701	r243702
102	100	while (win_monitor_list != NULL)
103	101	{
104	102	win_monitor_info *temp = win_monitor_list;
105		win_monitor_list = temp->next;
	103	win_monitor_list = temp->m_next;
106	104	global_free(temp);
107	105	}
108	106	}
r243701	r243702
110	108
111	109
112	110	win_monitor_info::win_monitor_info()
113		: next(NULL),
114		handle(NULL),
	111	: m_next(NULL),
	112	m_handle(NULL),
115	113	m_aspect(0.0f),
116		reqwidth(0),
117		reqheight(0),
118	114	m_name(NULL)
119	115	{
120	116	}
r243701	r243702
134	130	BOOL result;
135	131
136	132	// fetch the latest info about the monitor
137		info.cbSize = sizeof(info);
138		result = GetMonitorInfo(handle, (LPMONITORINFO)&info);
	133	m_info.cbSize = sizeof(m_info);
	134	result = GetMonitorInfo(m_handle, (LPMONITORINFO)&m_info);
139	135	assert(result);
140	136	if (m_name != NULL)
141	137	osd_free(m_name);
142		m_name = utf8_from_tstring(info.szDevice);
	138	m_name = utf8_from_tstring(m_info.szDevice);
143	139	(void)result; // to silence gcc 4.6
144	140	}
145	141
r243701	r243702
152	148	float win_monitor_info::aspect()
153	149	{
154	150	// refresh the monitor information and compute the aspect
	151	refresh();
	152	// FIXME: returning 0 looks odd, video_config is bad
155	153	if (video_config.keepaspect)
156	154	{
157	155	int width, height;
158	156	refresh();
159		width = rect_width(&info.rcMonitor);
160		height = rect_height(&info.rcMonitor);
	157	width = rect_width(&m_info.rcMonitor);
	158	height = rect_height(&m_info.rcMonitor);
161	159	return m_aspect / ((float)width / (float)height);
162	160	}
163	161	return 0.0f;
r243701	r243702
174	172	win_monitor_info *monitor;
175	173
176	174	// find the matching monitor
177		for (monitor = win_monitor_list; monitor != NULL; monitor = monitor->next)
178		if (monitor->handle == hmonitor)
	175	for (monitor = win_monitor_list; monitor != NULL; monitor = monitor->m_next)
	176	if (monitor->handle() == hmonitor)
179	177	return monitor;
180	178	return NULL;
181	179	}
r243701	r243702
218	216	// make a list of monitors
219	217	win_monitor_list = NULL;
220	218	tailptr = &win_monitor_list;
221		EnumDisplayMonitors(NULL, NULL, monitor_enum_callback, (LPARAM)&tailptr);
	219	EnumDisplayMonitors(NULL, NULL, win_monitor_info::monitor_enum_callback, (LPARAM)&tailptr);
222	220
223	221	// if we're verbose, print the list of monitors
224	222	{
225	223	win_monitor_info *monitor;
226		for (monitor = win_monitor_list; monitor != NULL; monitor = monitor->next)
	224	for (monitor = win_monitor_list; monitor != NULL; monitor = monitor->m_next)
227	225	{
228		osd_printf_verbose("Video: Monitor %p = \"%s\" %s\n", monitor->handle, monitor->devicename(), (monitor == primary_monitor) ? "(primary)" : "");
	226	osd_printf_verbose("Video: Monitor %p = \"%s\" %s\n", monitor->handle(), monitor->devicename(), (monitor == primary_monitor) ? "(primary)" : "");
229	227	}
230	228	}
231	229	}
r243701	r243702
236	234	//  monitor_enum_callback
237	235	//============================================================
238	236
239		static BOOL CALLBACK monitor_enum_callback(HMONITOR handle, HDC dc, LPRECT rect, LPARAM data)
	237	BOOL CALLBACK win_monitor_info::monitor_enum_callback(HMONITOR handle, HDC dc, LPRECT rect, LPARAM data)
240	238	{
241	239	win_monitor_info ***tailptr = (win_monitor_info ***)data;
242	240	win_monitor_info *monitor;
r243701	r243702
253	251	monitor = global_alloc(win_monitor_info);
254	252
255	253	// copy in the data
256		monitor->handle = handle;
257		monitor->info = info;
	254	monitor->m_handle = handle;
	255	monitor->m_info = info;
258	256
259	257	// guess the aspect ratio assuming square pixels
260	258	monitor->set_aspect((float)(info.rcMonitor.right - info.rcMonitor.left) / (float)(info.rcMonitor.bottom - info.rcMonitor.top));
261	259
262	260	// save the primary monitor handle
263		if (monitor->info.dwFlags & MONITORINFOF_PRIMARY)
	261	if (monitor->m_info.dwFlags & MONITORINFOF_PRIMARY)
264	262	primary_monitor = monitor;
265	263
266	264	// hook us into the list
267	265	**tailptr = monitor;
268		*tailptr = &monitor->next;
	266	*tailptr = &monitor->m_next;
269	267
270	268	// enumerate all the available monitors so to list their names in verbose mode
271	269	return TRUE;
r243701	r243702
297	295
298	296	// look for a match in the name first
299	297	if (scrname[0] != 0)
300		for (monitor = win_monitor_list; monitor != NULL; monitor = monitor->next)
	298	for (monitor = win_monitor_list; monitor != NULL; monitor = monitor->m_next)
301	299	{
302	300	int rc = 1;
303	301
r243701	r243702
311	309
312	310	// didn't find it; alternate monitors until we hit the jackpot
313	311	index %= moncount;
314		for (monitor = win_monitor_list; monitor != NULL; monitor = monitor->next)
	312	for (monitor = win_monitor_list; monitor != NULL; monitor = monitor->m_next)
315	313	if (index-- == 0)
316	314	goto finishit;
317	315
r243701	r243702
320	318
321	319	finishit:
322	320	if (aspect != 0)
	321	{
323	322	monitor->set_aspect(aspect);
	323	}
324	324	return monitor;
325	325	}
326	326
r243701	r243702
355	355	//  extract_video_config
356	356	//============================================================
357	357
358		static void extract_video_config(running_machine &machine)
	358	void windows_osd_interface::extract_video_config()
359	359	{
360		windows_options &options = downcast<windows_options &>(machine.options());
361	360	const char *stemp;
362	361
363	362	// global options: extract the data
364		video_config.windowed      = options.window();
365		video_config.prescale      = options.prescale();
366		video_config.keepaspect    = options.keep_aspect();
367		video_config.numscreens    = options.numscreens();
	363	video_config.windowed      = options().window();
	364	video_config.prescale      = options().prescale();
	365	video_config.keepaspect    = options().keep_aspect();
	366	video_config.numscreens    = options().numscreens();
368	367
369	368	// if we are in debug mode, never go full screen
370		if (machine.debug_flags & DEBUG_FLAG_OSD_ENABLED)
	369	if (machine().debug_flags & DEBUG_FLAG_OSD_ENABLED)
371	370	video_config.windowed = TRUE;
372	371
373	372	// per-window options: extract the data
374		const char *default_resolution = options.resolution();
375		get_resolution(default_resolution, options.resolution(0), &video_config.window[0], TRUE);
376		get_resolution(default_resolution, options.resolution(1), &video_config.window[1], TRUE);
377		get_resolution(default_resolution, options.resolution(2), &video_config.window[2], TRUE);
378		get_resolution(default_resolution, options.resolution(3), &video_config.window[3], TRUE);
	373	const char *default_resolution = options().resolution();
	374	get_resolution(default_resolution, options().resolution(0), &video_config.window[0], TRUE);
	375	get_resolution(default_resolution, options().resolution(1), &video_config.window[1], TRUE);
	376	get_resolution(default_resolution, options().resolution(2), &video_config.window[2], TRUE);
	377	get_resolution(default_resolution, options().resolution(3), &video_config.window[3], TRUE);
379	378
380	379	// video options: extract the data
381		stemp = options.video();
	380	stemp = options().video();
382	381	if (strcmp(stemp, "d3d") == 0)
383	382	video_config.mode = VIDEO_MODE_D3D;
384	383	else if (strcmp(stemp, "auto") == 0)
r243701	r243702
392	391	else if (strcmp(stemp, "none") == 0)
393	392	{
394	393	video_config.mode = VIDEO_MODE_NONE;
395		if (options.seconds_to_run() == 0)
	394	if (options().seconds_to_run() == 0)
396	395	osd_printf_warning("Warning: -video none doesn't make much sense without -seconds_to_run\n");
397	396	}
	397	#if (USE_OPENGL)
	398	else if (strcmp(stemp, "opengl") == 0)
	399	video_config.mode = VIDEO_MODE_OPENGL;
	400	#endif
398	401	else
399	402	{
400	403	osd_printf_warning("Invalid video value %s; reverting to gdi\n", stemp);
401	404	video_config.mode = VIDEO_MODE_GDI;
402	405	}
403		video_config.waitvsync     = options.wait_vsync();
404		video_config.syncrefresh   = options.sync_refresh();
405		video_config.triplebuf     = options.triple_buffer();
406		video_config.switchres     = options.switch_res();
	406	video_config.waitvsync     = options().wait_vsync();
	407	video_config.syncrefresh   = options().sync_refresh();
	408	video_config.triplebuf     = options().triple_buffer();
	409	video_config.switchres     = options().switch_res();
407	410
408	411	// ddraw options: extract the data
409		video_config.hwstretch     = options.hwstretch();
	412	video_config.hwstretch     = options().hwstretch();
410	413
411	414	// d3d options: extract the data
412		video_config.filter        = options.filter();
	415	video_config.filter        = options().filter();
413	416	if (video_config.prescale == 0)
414	417	video_config.prescale = 1;
415	418	}
r243701	r243702
424	427	{
425	428	int num = 0, den = 1;
426	429
427		if (strcmp(data, "auto") == 0)
	430	if (strcmp(data, OSDOPTVAL_AUTO) == 0)
428	431	{
429		if (strcmp(defdata, "auto") == 0)
	432	if (strcmp(defdata,OSDOPTVAL_AUTO) == 0)
430	433	return 0;
431	434	data = defdata;
432	435	}
r243701	r243702
436	439	}
437	440
438	441
439
440	442	//============================================================
441	443	//  get_resolution
442	444	//============================================================
r243701	r243702
444	446	static void get_resolution(const char *defdata, const char *data, win_window_config *config, int report_error)
445	447	{
446	448	config->width = config->height = config->refresh = 0;
447		if (strcmp(data, "auto") == 0)
	449	if (strcmp(data, OSDOPTVAL_AUTO) == 0)
448	450	{
449		if (strcmp(defdata, "auto") == 0)
	451	if (strcmp(defdata, OSDOPTVAL_AUTO) == 0)
450	452	return;
451	453	data = defdata;
452	454	}

trunk/src/osd/windows/video.h

r243701	r243702
18	18
19	19	#define MAX_WINDOWS         4
20	20
21		#define VIDEO_MODE_NONE     0
22		#define VIDEO_MODE_GDI      1
23		#define VIDEO_MODE_DDRAW    2
24		#define VIDEO_MODE_D3D      3
25		#define VIDEO_MODE_BGFX     4
	21	enum {
	22	VIDEO_MODE_NONE,
	23	VIDEO_MODE_GDI,
	24	VIDEO_MODE_DDRAW,
	25	VIDEO_MODE_D3D,
	26	VIDEO_MODE_BGFX,
	27	#if (USE_OPENGL)
	28	VIDEO_MODE_OPENGL,
	29	#endif
	30	};
26	31
	32	#define GLSL_SHADER_MAX 10
27	33
28
29	34	//============================================================
30	35	//  TYPE DEFINITIONS
31	36	//============================================================
r243701	r243702
37	42	virtual ~win_monitor_info();
38	43
39	44	void refresh();
40		float aspect();
41		void set_aspect(float a) { m_aspect = a; }
	45
	46	const HMONITOR handle() { return m_handle; }
	47	const RECT &position_size() { refresh(); return m_info.rcMonitor; }
	48	const RECT &usuable_position_size() { refresh(); return m_info.rcWork; }
	49	bool is_primary() { return (m_info.dwFlags & MONITORINFOF_PRIMARY) != 0; }
42	50	const char *devicename() { refresh(); return (m_name != NULL) ? m_name : "UNKNOWN"; }
43	51
44		win_monitor_info  * next;                   // pointer to next monitor in list
45		HMONITOR            handle;                 // handle to the monitor
46		MONITORINFOEX       info;                   // most recently retrieved info
	52	float aspect();
	53
	54	void set_aspect(const float a) { m_aspect = a; }
	55
	56	win_monitor_info  * m_next;                   // pointer to next monitor in list
	57
	58	// static
	59
	60	static BOOL CALLBACK monitor_enum_callback(HMONITOR handle, HDC dc, LPRECT rect, LPARAM data);
	61
47	62	private:
	63	HMONITOR            m_handle;                 // handle to the monitor
	64	MONITORINFOEX       m_info;                   // most recently retrieved info
	65
48	66	float               m_aspect;               // computed/configured aspect ratio of the physical device
49		int                 reqwidth;               // requested width for this monitor
50		int                 reqheight;              // requested height for this monitor
51	67	char *             m_name;
52	68	};
53	69
r243701	r243702
85	101
86	102	// d3d options
87	103	int                 filter;                     // enable filtering
	104
	105	// OpenGL options
	106	//int                 filter;         // enable filtering, disabled if glsl_filter>0
	107	int                 glsl;
	108	int                 glsl_filter;        // glsl filtering, >0 disables filter
	109	char *              glsl_shader_mamebm[GLSL_SHADER_MAX]; // custom glsl shader set, mame bitmap
	110	int                 glsl_shader_mamebm_num; // custom glsl shader set number, mame bitmap
	111	char *              glsl_shader_scrn[GLSL_SHADER_MAX]; // custom glsl shader set, screen bitmap
	112	int                 glsl_shader_scrn_num; // custom glsl shader number, screen bitmap
	113	int                 pbo;
	114	int                 vbo;
	115	int                 allowtexturerect;   // allow GL_ARB_texture_rectangle, default: no
	116	int                 forcepow2texture;   // force power of two textures, default: no
88	117	};
89	118
90	119

trunk/src/osd/windows/window.c

r243701	r243702
40	40	extern int drawdd_init(running_machine &machine, osd_draw_callbacks *callbacks);
41	41	extern int drawd3d_init(running_machine &machine, osd_draw_callbacks *callbacks);
42	42	extern int drawbgfx_init(running_machine &machine, osd_draw_callbacks *callbacks);
	43	#if (USE_OPENGL)
	44	extern int drawogl_init(running_machine &machine, osd_draw_callbacks *callbacks);
	45	#endif
43	46
44
45	47	//============================================================
46	48	//  PARAMETERS
47	49	//============================================================
r243701	r243702
245	247	drawbgfx_init(machine(), &draw);
246	248	if (video_config.mode == VIDEO_MODE_NONE)
247	249	drawnone_init(machine(), &draw);
248
	250	#if (USE_OPENGL)
	251	if (video_config.mode == VIDEO_MODE_OPENGL)
	252	drawogl_init(machine(), &draw);
	253	#endif
249	254	// set up the window list
250	255	last_window_ptr = &win_window_list;
251	256
r243701	r243702
1173	1178	assert(GetCurrentThreadId() == window_threadid);
1174	1179
1175	1180	// get the monitor bounds
1176		monitorbounds = window->m_monitor->info.rcMonitor;
	1181	monitorbounds = window->m_monitor->position_size();
1177	1182
1178	1183	// create the window menu if needed
1179	1184	if (downcast<windows_options &>(window->machine().options()).menu())
r243701	r243702
1561	1566	// clamp against the maximum (fit on one screen for full screen mode)
1562	1567	if (window->m_fullscreen)
1563	1568	{
1564		maxwidth = rect_width(&monitor->info.rcMonitor) - extrawidth;
1565		maxheight = rect_height(&monitor->info.rcMonitor) - extraheight;
	1569	maxwidth = rect_width(&monitor->position_size()) - extrawidth;
	1570	maxheight = rect_height(&monitor->position_size()) - extraheight;
1566	1571	}
1567	1572	else
1568	1573	{
1569		maxwidth = rect_width(&monitor->info.rcWork) - extrawidth;
1570		maxheight = rect_height(&monitor->info.rcWork) - extraheight;
	1574	maxwidth = rect_width(&monitor->usuable_position_size()) - extrawidth;
	1575	maxheight = rect_height(&monitor->usuable_position_size()) - extraheight;
1571	1576
1572	1577	// further clamp to the maximum width/height in the window
1573	1578	if (window->m_maxwidth != 0)
r243701	r243702
1695	1700
1696	1701	// compute the maximum client area
1697	1702	window->m_monitor->refresh();
1698		maximum = window->m_monitor->info.rcWork;
	1703	maximum = window->m_monitor->usuable_position_size();
1699	1704
1700	1705	// clamp to the window's max
1701	1706	if (window->m_maxwidth != 0)
r243701	r243702
1721	1726	}
1722	1727
1723	1728	// center within the work area
1724		bounds->left = window->m_monitor->info.rcWork.left + (rect_width(&window->m_monitor->info.rcWork) - rect_width(&maximum)) / 2;
1725		bounds->top = window->m_monitor->info.rcWork.top + (rect_height(&window->m_monitor->info.rcWork) - rect_height(&maximum)) / 2;
	1729	RECT work = window->m_monitor->usuable_position_size();
	1730	bounds->left = work.left + (rect_width(&work) - rect_width(&maximum)) / 2;
	1731	bounds->top = work.top + (rect_height(&work) - rect_height(&maximum)) / 2;
1726	1732	bounds->right = bounds->left + rect_width(&maximum);
1727	1733	bounds->bottom = bounds->top + rect_height(&maximum);
1728	1734	}
r243701	r243702
1823	1829	else
1824	1830	{
1825	1831	win_monitor_info *monitor = window->winwindow_video_window_monitor(NULL);
1826		newrect = monitor->info.rcMonitor;
	1832	newrect = monitor->position_size();
1827	1833	}
1828	1834
1829	1835	// adjust the position if different

trunk/src/osd/windows/window.h

r243701	r243702
66	66
67	67	float aspect() const { return monitor()->aspect(); }
68	68
	69	virtual void get_size(int &w, int &h) = 0;
	70
69	71	#ifdef OSD_SDL
70	72	virtual void blit_surface_size(int &blitwidth, int &blitheight) = 0;
71	73	virtual sdl_monitor_info *monitor() const = 0;
72		virtual void get_size(int &w, int &h) = 0;
73	74	#if (SDLMAME_SDL2)
74	75	virtual SDL_Window *sdl_window() = 0;
75	76	#else
r243701	r243702
169	170	return GetMenu(m_hwnd) ? true : false;
170	171	}
171	172
	173	/* virtual */ void get_size(int &w, int &h)
	174	{
	175	RECT client;
	176	GetClientRect(m_hwnd, &client);
	177	w = client.right - client.left;
	178	h = client.bottom - client.top;
	179	}
	180
172	181	win_monitor_info *monitor() const { return m_monitor; }
173	182
174	183	win_window_info *   m_next;

trunk/src/osd/windows/windows.mak

r243701	r243702
66	66	# uncomment next line to use SDL library for sound and video output
67	67	# USE_SDL = 1
68	68
	69	# uncomment next line to compile OpenGL video renderer
	70	# USE_OPENGL = 1
	71
69	72	# uncomment next line to use QT debugger
70	73	# USE_QTDEBUG = 1
71	74
r243701	r243702
395	398	$(OSDOBJ)/modules/netdev/taptun.o \
396	399	$(OSDOBJ)/modules/netdev/none.o \
397	400
	401	ifdef USE_OPENGL
	402	OSDOBJS +=    $(WINOBJ)/../sdl/drawogl.o $(WINOBJ)/../sdl/gl_shader_tool.o $(WINOBJ)/../sdl/gl_shader_mgr.o
	403	OBJDIRS += $(WINOBJ)/../sdl
	404
	405	DEFS += -DUSE_OPENGL=1
	406	LIBS += -lopengl32
	407
	408	else
	409	DEFS += -DUSE_OPENGL=0
	410	endif
	411
398	412	ifdef USE_SDL
399	413	DEFS += -DUSE_SDL_SOUND
400	414	endif

trunk/src/osd/windows/winmain.c

r243701	r243702
503	503	//============================================================
504	504
505	505	windows_osd_interface::windows_osd_interface(windows_options &options)
506		: osd_common_t(options)
	506	: osd_common_t(options), m_options(options)
507	507	{
508	508	}
509	509

trunk/src/osd/windows/winmain.h

r243701	r243702
269	269	virtual void input_exit();
270	270	virtual void output_exit();
271	271
	272	void extract_video_config();
	273
	274	windows_options &options() { return m_options; }
	275
272	276	private:
273	277	void osd_exit();
	278	windows_options &m_options;
274	279
275	280	static const int DEFAULT_FONT_HEIGHT = 200;
276	281	};
r243701	r243702
296	301	void winmain_watchdog_ping(void);
297	302	void winmain_dump_stack();
298	303
299		#endif
		No newline at end of file
	304	#endif

https://github.com/mamedev/mame/commit/d2ea4df4ad7b439697aa1db1ce022dba49aeffdc

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team