directx.c@ 64572

最後變更在這個檔案從64572是 63478,由 vboxsync 提交於 8 年前
Devices: warnings (clang)
屬性 svn:eol-style 設為 `native` 屬性 svn:keywords 設為 `Author Date Id Revision`
檔案大小: 117.3 KB

行
1	/*
2	* IWineD3D implementation
3	*
4	* Copyright 2002-2004 Jason Edmeades
5	* Copyright 2003-2004 Raphael Junqueira
6	* Copyright 2004 Christian Costa
7	* Copyright 2005 Oliver Stieber
8	* Copyright 2007-2008 Stefan Dösinger for CodeWeavers
9	* Copyright 2009 Henri Verbeet for CodeWeavers
10	*
11	* This library is free software; you can redistribute it and/or
12	* modify it under the terms of the GNU Lesser General Public
13	* License as published by the Free Software Foundation; either
14	* version 2.1 of the License, or (at your option) any later version.
15	*
16	* This library is distributed in the hope that it will be useful,
17	* but WITHOUT ANY WARRANTY; without even the implied warranty of
18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19	* Lesser General Public License for more details.
20	*
21	* You should have received a copy of the GNU Lesser General Public
22	* License along with this library; if not, write to the Free Software
23	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24	*/
25
26	/*
27	* Oracle LGPL Disclaimer: For the avoidance of doubt, except that if any license choice
28	* other than GPL or LGPL is available it will apply instead, Oracle elects to use only
29	* the Lesser General Public License version 2.1 (LGPLv2) at this time for any software where
30	* a choice of LGPL license versions is made available with the language indicating
31	* that LGPLv2 or any later version may be used, or where a choice of which version
32	* of the LGPL is applied is otherwise unspecified.
33	*/
34
35	#include "config.h"
36	#include <stdio.h>
37	#include "wined3d_private.h"
38
39	#ifdef VBOX_WITH_WDDM
40	# include <VBox/VBoxCrHgsmi.h>
41	#endif
42
43	#ifdef VBOX_WITH_VMSVGA
44	# ifdef RT_OS_WINDOWS
45	DECLIMPORT(void) APIENTRY glFinish(void);
46	# else
47	void glFinish(void);
48	# endif
49	#endif
50
51	WINE_DEFAULT_DEBUG_CHANNEL(d3d);
52	WINE_DECLARE_DEBUG_CHANNEL(d3d_caps);
53
54	#define GLINFO_LOCATION (*gl_info)
55	#define WINE_DEFAULT_VIDMEM (64 * 1024 * 1024)
56
57	/* The d3d device ID */
58	#if 0 /* VBox: unused */
59	static const GUID IID_D3DDEVICE_D3DUID = { 0xaeb2cdd4, 0x6e41, 0x43ea, { 0x94,0x1c,0x83,0x61,0xcc,0x76,0x07,0x81 } };
60	#endif
61
62
63	/* Extension detection */
64	static const struct {
65	const char *extension_string;
66	GL_SupportedExt extension;
67	DWORD version;
68	} EXTENSION_MAP[] = {
69	/* APPLE */
70	{"GL_APPLE_client_storage", APPLE_CLIENT_STORAGE, 0 },
71	{"GL_APPLE_fence", APPLE_FENCE, 0 },
72	{"GL_APPLE_float_pixels", APPLE_FLOAT_PIXELS, 0 },
73	{"GL_APPLE_flush_buffer_range", APPLE_FLUSH_BUFFER_RANGE, 0 },
74	{"GL_APPLE_flush_render", APPLE_FLUSH_RENDER, 0 },
75	{"GL_APPLE_ycbcr_422", APPLE_YCBCR_422, 0 },
76
77	/* ARB */
78	{"GL_ARB_color_buffer_float", ARB_COLOR_BUFFER_FLOAT, 0 },
79	{"GL_ARB_depth_buffer_float", ARB_DEPTH_BUFFER_FLOAT, 0 },
80	{"GL_ARB_depth_clamp", ARB_DEPTH_CLAMP, 0 },
81	{"GL_ARB_depth_texture", ARB_DEPTH_TEXTURE, 0 },
82	{"GL_ARB_draw_buffers", ARB_DRAW_BUFFERS, 0 },
83	{"GL_ARB_fragment_program", ARB_FRAGMENT_PROGRAM, 0 },
84	{"GL_ARB_fragment_shader", ARB_FRAGMENT_SHADER, 0 },
85	{"GL_ARB_framebuffer_object", ARB_FRAMEBUFFER_OBJECT, 0 },
86	{"GL_ARB_geometry_shader4", ARB_GEOMETRY_SHADER4, 0 },
87	{"GL_ARB_half_float_pixel", ARB_HALF_FLOAT_PIXEL, 0 },
88	{"GL_ARB_half_float_vertex", ARB_HALF_FLOAT_VERTEX, 0 },
89	{"GL_ARB_imaging", ARB_IMAGING, 0 },
90	{"GL_ARB_map_buffer_range", ARB_MAP_BUFFER_RANGE, 0 },
91	{"GL_ARB_multisample", ARB_MULTISAMPLE, 0 }, /* needs GLX_ARB_MULTISAMPLE as well */
92	{"GL_ARB_multitexture", ARB_MULTITEXTURE, 0 },
93	{"GL_ARB_occlusion_query", ARB_OCCLUSION_QUERY, 0 },
94	{"GL_ARB_pixel_buffer_object", ARB_PIXEL_BUFFER_OBJECT, 0 },
95	{"GL_ARB_point_parameters", ARB_POINT_PARAMETERS, 0 },
96	{"GL_ARB_point_sprite", ARB_POINT_SPRITE, 0 },
97	{"GL_ARB_provoking_vertex", ARB_PROVOKING_VERTEX, 0 },
98	{"GL_ARB_shader_objects", ARB_SHADER_OBJECTS, 0 },
99	{"GL_ARB_shader_texture_lod", ARB_SHADER_TEXTURE_LOD, 0 },
100	{"GL_ARB_shading_language_100", ARB_SHADING_LANGUAGE_100, 0 },
101	{"GL_ARB_sync", ARB_SYNC, 0 },
102	{"GL_ARB_texture_border_clamp", ARB_TEXTURE_BORDER_CLAMP, 0 },
103	{"GL_ARB_texture_compression", ARB_TEXTURE_COMPRESSION, 0 },
104	{"GL_ARB_texture_cube_map", ARB_TEXTURE_CUBE_MAP, 0 },
105	{"GL_ARB_texture_env_add", ARB_TEXTURE_ENV_ADD, 0 },
106	{"GL_ARB_texture_env_combine", ARB_TEXTURE_ENV_COMBINE, 0 },
107	{"GL_ARB_texture_env_dot3", ARB_TEXTURE_ENV_DOT3, 0 },
108	{"GL_ARB_texture_float", ARB_TEXTURE_FLOAT, 0 },
109	{"GL_ARB_texture_mirrored_repeat", ARB_TEXTURE_MIRRORED_REPEAT, 0 },
110	{"GL_IBM_texture_mirrored_repeat", ARB_TEXTURE_MIRRORED_REPEAT, 0 },
111	{"GL_ARB_texture_non_power_of_two", ARB_TEXTURE_NON_POWER_OF_TWO, MAKEDWORD_VERSION(2, 0) },
112	{"GL_ARB_texture_rectangle", ARB_TEXTURE_RECTANGLE, 0 },
113	{"GL_ARB_texture_rg", ARB_TEXTURE_RG, 0 },
114	{"GL_ARB_vertex_array_bgra", ARB_VERTEX_ARRAY_BGRA, 0 },
115	{"GL_ARB_vertex_blend", ARB_VERTEX_BLEND, 0 },
116	{"GL_ARB_vertex_buffer_object", ARB_VERTEX_BUFFER_OBJECT, 0 },
117	{"GL_ARB_vertex_program", ARB_VERTEX_PROGRAM, 0 },
118	{"GL_ARB_vertex_shader", ARB_VERTEX_SHADER, 0 },
119
120	/* ATI */
121	{"GL_ATI_fragment_shader", ATI_FRAGMENT_SHADER, 0 },
122	{"GL_ATI_separate_stencil", ATI_SEPARATE_STENCIL, 0 },
123	{"GL_ATI_texture_compression_3dc", ATI_TEXTURE_COMPRESSION_3DC, 0 },
124	{"GL_ATI_texture_env_combine3", ATI_TEXTURE_ENV_COMBINE3, 0 },
125	{"GL_ATI_texture_mirror_once", ATI_TEXTURE_MIRROR_ONCE, 0 },
126
127	/* EXT */
128	{"GL_EXT_blend_color", EXT_BLEND_COLOR, 0 },
129	{"GL_EXT_blend_equation_separate", EXT_BLEND_EQUATION_SEPARATE, 0 },
130	{"GL_EXT_blend_func_separate", EXT_BLEND_FUNC_SEPARATE, 0 },
131	{"GL_EXT_blend_minmax", EXT_BLEND_MINMAX, 0 },
132	{"GL_EXT_draw_buffers2", EXT_DRAW_BUFFERS2, 0 },
133	{"GL_EXT_fog_coord", EXT_FOG_COORD, 0 },
134	{"GL_EXT_framebuffer_blit", EXT_FRAMEBUFFER_BLIT, 0 },
135	{"GL_EXT_framebuffer_multisample", EXT_FRAMEBUFFER_MULTISAMPLE, 0 },
136	{"GL_EXT_framebuffer_object", EXT_FRAMEBUFFER_OBJECT, 0 },
137	{"GL_EXT_gpu_program_parameters", EXT_GPU_PROGRAM_PARAMETERS, 0 },
138	{"GL_EXT_gpu_shader4", EXT_GPU_SHADER4, 0 },
139	{"GL_EXT_packed_depth_stencil", EXT_PACKED_DEPTH_STENCIL, 0 },
140	{"GL_EXT_paletted_texture", EXT_PALETTED_TEXTURE, 0 },
141	{"GL_EXT_point_parameters", EXT_POINT_PARAMETERS, 0 },
142	{"GL_EXT_provoking_vertex", EXT_PROVOKING_VERTEX, 0 },
143	{"GL_EXT_secondary_color", EXT_SECONDARY_COLOR, 0 },
144	{"GL_EXT_stencil_two_side", EXT_STENCIL_TWO_SIDE, 0 },
145	{"GL_EXT_stencil_wrap", EXT_STENCIL_WRAP, 0 },
146	{"GL_EXT_texture3D", EXT_TEXTURE3D, MAKEDWORD_VERSION(1, 2) },
147	{"GL_EXT_texture_compression_rgtc", EXT_TEXTURE_COMPRESSION_RGTC, 0 },
148	{"GL_EXT_texture_compression_s3tc", EXT_TEXTURE_COMPRESSION_S3TC, 0 },
149	{"GL_EXT_texture_env_add", EXT_TEXTURE_ENV_ADD, 0 },
150	{"GL_EXT_texture_env_combine", EXT_TEXTURE_ENV_COMBINE, 0 },
151	{"GL_EXT_texture_env_dot3", EXT_TEXTURE_ENV_DOT3, 0 },
152	{"GL_EXT_texture_filter_anisotropic", EXT_TEXTURE_FILTER_ANISOTROPIC, 0 },
153	{"GL_EXT_texture_lod_bias", EXT_TEXTURE_LOD_BIAS, 0 },
154	{"GL_EXT_texture_sRGB", EXT_TEXTURE_SRGB, 0 },
155	{"GL_EXT_vertex_array_bgra", EXT_VERTEX_ARRAY_BGRA, 0 },
156
157	/* NV */
158	{"GL_NV_depth_clamp", NV_DEPTH_CLAMP, 0 },
159	{"GL_NV_fence", NV_FENCE, 0 },
160	{"GL_NV_fog_distance", NV_FOG_DISTANCE, 0 },
161	{"GL_NV_fragment_program", NV_FRAGMENT_PROGRAM, 0 },
162	{"GL_NV_fragment_program2", NV_FRAGMENT_PROGRAM2, 0 },
163	{"GL_NV_fragment_program_option", NV_FRAGMENT_PROGRAM_OPTION, 0 },
164	{"GL_NV_half_float", NV_HALF_FLOAT, 0 },
165	{"GL_NV_light_max_exponent", NV_LIGHT_MAX_EXPONENT, 0 },
166	{"GL_NV_register_combiners", NV_REGISTER_COMBINERS, 0 },
167	{"GL_NV_register_combiners2", NV_REGISTER_COMBINERS2, 0 },
168	{"GL_NV_texgen_reflection", NV_TEXGEN_REFLECTION, 0 },
169	{"GL_NV_texture_env_combine4", NV_TEXTURE_ENV_COMBINE4, 0 },
170	{"GL_NV_texture_shader", NV_TEXTURE_SHADER, 0 },
171	{"GL_NV_texture_shader2", NV_TEXTURE_SHADER2, 0 },
172	{"GL_NV_vertex_program", NV_VERTEX_PROGRAM, 0 },
173	{"GL_NV_vertex_program1_1", NV_VERTEX_PROGRAM1_1, 0 },
174	{"GL_NV_vertex_program2", NV_VERTEX_PROGRAM2, 0 },
175	{"GL_NV_vertex_program2_option", NV_VERTEX_PROGRAM2_OPTION, 0 },
176	{"GL_NV_vertex_program3", NV_VERTEX_PROGRAM3, 0 },
177
178	/* SGI */
179	{"GL_SGIS_generate_mipmap", SGIS_GENERATE_MIPMAP, 0 },
180	};
181
182	/**********************************************************
183	* Utility functions follow
184	**********************************************************/
185
186	const struct min_lookup minMipLookup[] =
187	{
188	/* NONE POINT LINEAR */
189	{{GL_NEAREST, GL_NEAREST, GL_NEAREST}}, /* NONE */
190	{{GL_NEAREST, GL_NEAREST_MIPMAP_NEAREST, GL_NEAREST_MIPMAP_LINEAR}}, /* POINT*/
191	{{GL_LINEAR, GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR_MIPMAP_LINEAR}}, /* LINEAR */
192	};
193
194	const struct min_lookup minMipLookup_noFilter[] =
195	{
196	/* NONE POINT LINEAR */
197	{{GL_NEAREST, GL_NEAREST, GL_NEAREST}}, /* NONE */
198	{{GL_NEAREST, GL_NEAREST, GL_NEAREST}}, /* POINT */
199	{{GL_NEAREST, GL_NEAREST, GL_NEAREST}}, /* LINEAR */
200	};
201
202	const struct min_lookup minMipLookup_noMip[] =
203	{
204	/* NONE POINT LINEAR */
205	{{GL_NEAREST, GL_NEAREST, GL_NEAREST}}, /* NONE */
206	{{GL_NEAREST, GL_NEAREST, GL_NEAREST}}, /* POINT */
207	{{GL_LINEAR, GL_LINEAR, GL_LINEAR }}, /* LINEAR */
208	};
209
210	const GLenum magLookup[] =
211	{
212	/* NONE POINT LINEAR */
213	GL_NEAREST, GL_NEAREST, GL_LINEAR,
214	};
215
216	const GLenum magLookup_noFilter[] =
217	{
218	/* NONE POINT LINEAR */
219	GL_NEAREST, GL_NEAREST, GL_NEAREST,
220	};
221
222	/* drawStridedSlow attributes */
223	glAttribFunc position_funcs[WINED3D_FFP_EMIT_COUNT];
224	glAttribFunc diffuse_funcs[WINED3D_FFP_EMIT_COUNT];
225	glAttribFunc specular_func_3ubv;
226	glAttribFunc specular_funcs[WINED3D_FFP_EMIT_COUNT];
227	glAttribFunc normal_funcs[WINED3D_FFP_EMIT_COUNT];
228	glMultiTexCoordFunc multi_texcoord_funcs[WINED3D_FFP_EMIT_COUNT];
229
230
231	/**********************************************************
232	* IWineD3D parts follows
233	**********************************************************/
234
235	/* GL locking is done by the caller */
236	static inline BOOL test_arb_vs_offset_limit(const struct wined3d_gl_info *gl_info)
237	{
238	GLuint prog;
239	BOOL ret = FALSE;
240	const char *testcode =
241	"!!ARBvp1.0\n"
242	"PARAM C[66] = { program.env[0..65] };\n"
243	"ADDRESS A0;"
244	"PARAM zero = {0.0, 0.0, 0.0, 0.0};\n"
245	"ARL A0.x, zero.x;\n"
246	"MOV result.position, C[A0.x + 65];\n"
247	"END\n";
248
249	while(glGetError());
250	GL_EXTCALL(glGenProgramsARB(1, &prog));
251	if(!prog) {
252	ERR("Failed to create an ARB offset limit test program\n");
253	}
254	GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, prog));
255	GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
256	(GLsizei)strlen(testcode), testcode));
257	if(glGetError() != 0) {
258	TRACE("OpenGL implementation does not allow indirect addressing offsets > 63\n");
259	TRACE("error: %s\n", debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
260	ret = TRUE;
261	} else TRACE("OpenGL implementation allows offsets > 63\n");
262
263	GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, 0));
264	GL_EXTCALL(glDeleteProgramsARB(1, &prog));
265	checkGLcall("ARB vp offset limit test cleanup");
266
267	return ret;
268	}
269
270	static DWORD ver_for_ext(GL_SupportedExt ext)
271	{
272	unsigned int i;
273	for (i = 0; i < (sizeof(EXTENSION_MAP) / sizeof(*EXTENSION_MAP)); ++i) {
274	if(EXTENSION_MAP[i].extension == ext) {
275	return EXTENSION_MAP[i].version;
276	}
277	}
278	return 0;
279	}
280
281	static BOOL match_ati_r300_to_500(const struct wined3d_gl_info gl_info, const char gl_renderer,
282	enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
283	{
284	if (card_vendor != HW_VENDOR_ATI) return FALSE;
285	if (device == CARD_ATI_RADEON_9500) return TRUE;
286	if (device == CARD_ATI_RADEON_X700) return TRUE;
287	if (device == CARD_ATI_RADEON_X1600) return TRUE;
288	return FALSE;
289	}
290
291	static BOOL match_geforce5(const struct wined3d_gl_info gl_info, const char gl_renderer,
292	enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
293	{
294	if (card_vendor == HW_VENDOR_NVIDIA)
295	{
296	if (device == CARD_NVIDIA_GEFORCEFX_5800 \|\| device == CARD_NVIDIA_GEFORCEFX_5600)
297	{
298	return TRUE;
299	}
300	}
301	return FALSE;
302	}
303
304	static BOOL match_apple(const struct wined3d_gl_info gl_info, const char gl_renderer,
305	enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
306	{
307	/* MacOS has various specialities in the extensions it advertises. Some have to be loaded from
308	* the opengl 1.2+ core, while other extensions are advertised, but software emulated. So try to
309	* detect the Apple OpenGL implementation to apply some extension fixups afterwards.
310	*
311	* Detecting this isn't really easy. The vendor string doesn't mention Apple. Compile-time checks
312	* aren't sufficient either because a Linux binary may display on a macos X server via remote X11.
313	* So try to detect the GL implementation by looking at certain Apple extensions. Some extensions
314	* like client storage might be supported on other implementations too, but GL_APPLE_flush_render
315	* is specific to the Mac OS X window management, and GL_APPLE_ycbcr_422 is QuickTime specific. So
316	* the chance that other implementations support them is rather small since Win32 QuickTime uses
317	* DirectDraw, not OpenGL.
318	*
319	* This test has been moved into wined3d_guess_gl_vendor()
320	*/
321	if (gl_vendor == GL_VENDOR_APPLE)
322	{
323	return TRUE;
324	}
325	return FALSE;
326	}
327
328	/* Context activation is done by the caller. */
329	static void test_pbo_functionality(struct wined3d_gl_info *gl_info)
330	{
331	/* Some OpenGL implementations, namely Apple's Geforce 8 driver, advertises PBOs,
332	* but glTexSubImage from a PBO fails miserably, with the first line repeated over
333	* all the texture. This function detects this bug by its symptom and disables PBOs
334	* if the test fails.
335	*
336	* The test uploads a 4x4 texture via the PBO in the "native" format GL_BGRA,
337	* GL_UNSIGNED_INT_8_8_8_8_REV. This format triggers the bug, and it is what we use
338	* for D3DFMT_A8R8G8B8. Then the texture is read back without any PBO and the data
339	* read back is compared to the original. If they are equal PBOs are assumed to work,
340	* otherwise the PBO extension is disabled. */
341	GLuint texture, pbo;
342	static const unsigned int pattern[] =
343	{
344	0x00000000, 0x000000ff, 0x0000ff00, 0x40ff0000,
345	0x80ffffff, 0x40ffff00, 0x00ff00ff, 0x0000ffff,
346	0x00ffff00, 0x00ff00ff, 0x0000ffff, 0x000000ff,
347	0x80ff00ff, 0x0000ffff, 0x00ff00ff, 0x40ff00ff
348	};
349	unsigned int check[sizeof(pattern) / sizeof(pattern[0])];
350
351	/* No PBO -> No point in testing them. */
352	if (!gl_info->supported[ARB_PIXEL_BUFFER_OBJECT]) return;
353
354	ENTER_GL();
355
356	while (glGetError());
357	glGenTextures(1, &texture);
358	glBindTexture(GL_TEXTURE_2D, texture);
359
360	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
361	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 4, 4, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, 0);
362	checkGLcall("Specifying the PBO test texture");
363
364	GL_EXTCALL(glGenBuffersARB(1, &pbo));
365	GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pbo));
366	GL_EXTCALL(glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, sizeof(pattern), pattern, GL_STREAM_DRAW_ARB));
367	checkGLcall("Specifying the PBO test pbo");
368
369	glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL);
370	checkGLcall("Loading the PBO test texture");
371
372	GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
373	#ifdef VBOX_WITH_VMSVGA
374	glFinish();
375	#else
376	wglFinish(); /* just to be sure */
377	#endif
378	memset(check, 0, sizeof(check));
379	glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, check);
380	checkGLcall("Reading back the PBO test texture");
381
382	glDeleteTextures(1, &texture);
383	GL_EXTCALL(glDeleteBuffersARB(1, &pbo));
384	checkGLcall("PBO test cleanup");
385
386	LEAVE_GL();
387
388	if (memcmp(check, pattern, sizeof(check)))
389	{
390	WARN_(d3d_caps)("PBO test failed, read back data doesn't match original.\n");
391	WARN_(d3d_caps)("Disabling PBOs. This may result in slower performance.\n");
392	gl_info->supported[ARB_PIXEL_BUFFER_OBJECT] = FALSE;
393	}
394	else
395	{
396	TRACE_(d3d_caps)("PBO test successful.\n");
397	}
398	}
399
400	static BOOL match_apple_intel(const struct wined3d_gl_info gl_info, const char gl_renderer,
401	enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
402	{
403	return (card_vendor == HW_VENDOR_INTEL) && (gl_vendor == GL_VENDOR_APPLE);
404	}
405
406	static BOOL match_apple_nonr500ati(const struct wined3d_gl_info gl_info, const char gl_renderer,
407	enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
408	{
409	if (gl_vendor != GL_VENDOR_APPLE) return FALSE;
410	if (card_vendor != HW_VENDOR_ATI) return FALSE;
411	if (device == CARD_ATI_RADEON_X1600) return FALSE;
412	return TRUE;
413	}
414
415	static BOOL match_fglrx(const struct wined3d_gl_info gl_info, const char gl_renderer,
416	enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
417	{
418	return gl_vendor == GL_VENDOR_FGLRX;
419
420	}
421
422	static BOOL match_dx10_capable(const struct wined3d_gl_info gl_info, const char gl_renderer,
423	enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
424	{
425	/* DX9 cards support 40 single float varyings in hardware, most drivers report 32. ATI misreports
426	* 44 varyings. So assume that if we have more than 44 varyings we have a dx10 card.
427	* This detection is for the gl_ClipPos varying quirk. If a d3d9 card really supports more than 44
428	* varyings and we subtract one in dx9 shaders its not going to hurt us because the dx9 limit is
429	* hardcoded
430	*
431	* dx10 cards usually have 64 varyings */
432	return gl_info->limits.glsl_varyings > 44;
433	}
434
435	/* A GL context is provided by the caller */
436	static BOOL match_allows_spec_alpha(const struct wined3d_gl_info gl_info, const char gl_renderer,
437	enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
438	{
439	GLenum error;
440	DWORD data[16];
441
442	if (!gl_info->supported[EXT_SECONDARY_COLOR]) return FALSE;
443
444	ENTER_GL();
445	while(glGetError());
446	GL_EXTCALL(glSecondaryColorPointerEXT)(4, GL_UNSIGNED_BYTE, 4, data);
447	error = glGetError();
448	LEAVE_GL();
449
450	if(error == GL_NO_ERROR)
451	{
452	TRACE("GL Implementation accepts 4 component specular color pointers\n");
453	return TRUE;
454	}
455	else
456	{
457	TRACE("GL implementation does not accept 4 component specular colors, error %s\n",
458	debug_glerror(error));
459	return FALSE;
460	}
461	}
462
463	static BOOL match_apple_nvts(const struct wined3d_gl_info gl_info, const char gl_renderer,
464	enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
465	{
466	if (!match_apple(gl_info, gl_renderer, gl_vendor, card_vendor, device)) return FALSE;
467	return gl_info->supported[NV_TEXTURE_SHADER];
468	}
469
470	/* A GL context is provided by the caller */
471	static BOOL match_broken_nv_clip(const struct wined3d_gl_info gl_info, const char gl_renderer,
472	enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
473	{
474	GLuint prog;
475	BOOL ret = FALSE;
476	GLint pos;
477	const char *testcode =
478	"!!ARBvp1.0\n"
479	"OPTION NV_vertex_program2;\n"
480	"MOV result.clip[0], 0.0;\n"
481	"MOV result.position, 0.0;\n"
482	"END\n";
483
484	if (!gl_info->supported[NV_VERTEX_PROGRAM2_OPTION]) return FALSE;
485
486	ENTER_GL();
487	while(glGetError());
488
489	GL_EXTCALL(glGenProgramsARB(1, &prog));
490	if(!prog)
491	{
492	ERR("Failed to create the NVvp clip test program\n");
493	LEAVE_GL();
494	return FALSE;
495	}
496	GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, prog));
497	GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
498	(GLsizei)strlen(testcode), testcode));
499	glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &pos);
500	if(pos != -1)
501	{
502	WARN("GL_NV_vertex_program2_option result.clip[] test failed\n");
503	TRACE("error: %s\n", debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
504	ret = TRUE;
505	while(glGetError());
506	}
507	else TRACE("GL_NV_vertex_program2_option result.clip[] test passed\n");
508
509	GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, 0));
510	GL_EXTCALL(glDeleteProgramsARB(1, &prog));
511	checkGLcall("GL_NV_vertex_program2_option result.clip[] test cleanup");
512
513	LEAVE_GL();
514	return ret;
515	}
516
517	/* Context activation is done by the caller. */
518	static BOOL match_fbo_tex_update(const struct wined3d_gl_info gl_info, const char gl_renderer,
519	enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
520	{
521	char data[4 * 4 * 4];
522	GLuint tex, fbo;
523	GLenum status;
524
525	#ifndef VBOX_WITH_VMSVGA
526	if (wined3d_settings.offscreen_rendering_mode != ORM_FBO) return FALSE;
527	#endif
528	memset(data, 0xcc, sizeof(data));
529
530	ENTER_GL();
531
532	glGenTextures(1, &tex);
533	glBindTexture(GL_TEXTURE_2D, tex);
534	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
535	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
536	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 4, 4, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL);
537	checkGLcall("glTexImage2D");
538
539	gl_info->fbo_ops.glGenFramebuffers(1, &fbo);
540	gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
541	gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0);
542	checkGLcall("glFramebufferTexture2D");
543
544	status = gl_info->fbo_ops.glCheckFramebufferStatus(GL_FRAMEBUFFER);
545	if (status != GL_FRAMEBUFFER_COMPLETE) ERR("FBO status %#x\n", status);
546	checkGLcall("glCheckFramebufferStatus");
547
548	memset(data, 0x11, sizeof(data));
549	glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, data);
550	checkGLcall("glTexSubImage2D");
551
552	glClearColor(0.996, 0.729, 0.745, 0.792);
553	glClear(GL_COLOR_BUFFER_BIT);
554	checkGLcall("glClear");
555
556	glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, data);
557	checkGLcall("glGetTexImage");
558
559	gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
560	gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, 0);
561	glBindTexture(GL_TEXTURE_2D, 0);
562	checkGLcall("glBindTexture");
563
564	gl_info->fbo_ops.glDeleteFramebuffers(1, &fbo);
565	glDeleteTextures(1, &tex);
566	checkGLcall("glDeleteTextures");
567
568	LEAVE_GL();
569
570	return (DWORD )data == 0x11111111;
571	}
572
573	static void quirk_arb_constants(struct wined3d_gl_info *gl_info)
574	{
575	TRACE_(d3d_caps)("Using ARB vs constant limit(=%u) for GLSL.\n", gl_info->limits.arb_vs_native_constants);
576	gl_info->limits.glsl_vs_float_constants = gl_info->limits.arb_vs_native_constants;
577	TRACE_(d3d_caps)("Using ARB ps constant limit(=%u) for GLSL.\n", gl_info->limits.arb_ps_native_constants);
578	gl_info->limits.glsl_ps_float_constants = gl_info->limits.arb_ps_native_constants;
579	}
580
581	static void quirk_apple_glsl_constants(struct wined3d_gl_info *gl_info)
582	{
583	quirk_arb_constants(gl_info);
584	/* MacOS needs uniforms for relative addressing offsets. This can accumulate to quite a few uniforms.
585	* Beyond that the general uniform isn't optimal, so reserve a number of uniforms. 12 vec4's should
586	* allow 48 different offsets or other helper immediate values. */
587	TRACE_(d3d_caps)("Reserving 12 GLSL constants for compiler private use.\n");
588	gl_info->reserved_glsl_constants = max(gl_info->reserved_glsl_constants, 12);
589	}
590
591	/* fglrx crashes with a very bad kernel panic if GL_POINT_SPRITE_ARB is set to GL_COORD_REPLACE_ARB
592	* on more than one texture unit. This means that the d3d9 visual point size test will cause a
593	* kernel panic on any machine running fglrx 9.3(latest that supports r300 to r500 cards). This
594	* quirk only enables point sprites on the first texture unit. This keeps point sprites working in
595	* most games, but avoids the crash
596	*
597	* A more sophisticated way would be to find all units that need texture coordinates and enable
598	* point sprites for one if only one is found, and software emulate point sprites in drawStridedSlow
599	* if more than one unit needs texture coordinates(This requires software ffp and vertex shaders though)
600	*
601	* Note that disabling the extension entirely does not gain predictability because there is no point
602	* sprite capability flag in d3d, so the potential rendering bugs are the same if we disable the extension. */
603	static void quirk_one_point_sprite(struct wined3d_gl_info *gl_info)
604	{
605	if (gl_info->supported[ARB_POINT_SPRITE])
606	{
607	TRACE("Limiting point sprites to one texture unit.\n");
608	gl_info->limits.point_sprite_units = 1;
609	}
610	}
611
612	static void quirk_ati_dx9(struct wined3d_gl_info *gl_info)
613	{
614	quirk_arb_constants(gl_info);
615
616	/* MacOS advertises GL_ARB_texture_non_power_of_two on ATI r500 and earlier cards, although
617	* these cards only support GL_ARB_texture_rectangle(D3DPTEXTURECAPS_NONPOW2CONDITIONAL).
618	* If real NP2 textures are used, the driver falls back to software. We could just remove the
619	* extension and use GL_ARB_texture_rectangle instead, but texture_rectangle is inconventient
620	* due to the non-normalized texture coordinates. Thus set an internal extension flag,
621	* GL_WINE_normalized_texrect, which signals the code that it can use non power of two textures
622	* as per GL_ARB_texture_non_power_of_two, but has to stick to the texture_rectangle limits.
623	*
624	* fglrx doesn't advertise GL_ARB_texture_non_power_of_two, but it advertises opengl 2.0 which
625	* has this extension promoted to core. The extension loading code sets this extension supported
626	* due to that, so this code works on fglrx as well. */
627	if(gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO])
628	{
629	TRACE("GL_ARB_texture_non_power_of_two advertised on R500 or earlier card, removing.\n");
630	gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] = FALSE;
631	gl_info->supported[WINE_NORMALIZED_TEXRECT] = TRUE;
632	}
633
634	/* fglrx has the same structural issues as the one described in quirk_apple_glsl_constants, although
635	* it is generally more efficient. Reserve just 8 constants. */
636	TRACE_(d3d_caps)("Reserving 8 GLSL constants for compiler private use.\n");
637	gl_info->reserved_glsl_constants = max(gl_info->reserved_glsl_constants, 8);
638	}
639
640	static void quirk_no_np2(struct wined3d_gl_info *gl_info)
641	{
642	/* The nVidia GeForceFX series reports OpenGL 2.0 capabilities with the latest drivers versions, but
643	* doesn't explicitly advertise the ARB_tex_npot extension in the GL extension string.
644	* This usually means that ARB_tex_npot is supported in hardware as long as the application is staying
645	* within the limits enforced by the ARB_texture_rectangle extension. This however is not true for the
646	* FX series, which instantly falls back to a slower software path as soon as ARB_tex_npot is used.
647	* We therefore completely remove ARB_tex_npot from the list of supported extensions.
648	*
649	* Note that wine_normalized_texrect can't be used in this case because internally it uses ARB_tex_npot,
650	* triggering the software fallback. There is not much we can do here apart from disabling the
651	* software-emulated extension and reenable ARB_tex_rect (which was previously disabled
652	* in IWineD3DImpl_FillGLCaps).
653	* This fixup removes performance problems on both the FX 5900 and FX 5700 (e.g. for framebuffer
654	* post-processing effects in the game "Max Payne 2").
655	* The behaviour can be verified through a simple test app attached in bugreport #14724. */
656	TRACE("GL_ARB_texture_non_power_of_two advertised through OpenGL 2.0 on NV FX card, removing.\n");
657	gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] = FALSE;
658	gl_info->supported[ARB_TEXTURE_RECTANGLE] = TRUE;
659	}
660
661	static void quirk_texcoord_w(struct wined3d_gl_info *gl_info)
662	{
663	/* The Intel GPUs on MacOS set the .w register of texcoords to 0.0 by default, which causes problems
664	* with fixed function fragment processing. Ideally this flag should be detected with a test shader
665	* and OpenGL feedback mode, but some GL implementations (MacOS ATI at least, probably all MacOS ones)
666	* do not like vertex shaders in feedback mode and return an error, even though it should be valid
667	* according to the spec.
668	*
669	* We don't want to enable this on all cards, as it adds an extra instruction per texcoord used. This
670	* makes the shader slower and eats instruction slots which should be available to the d3d app.
671	*
672	* ATI Radeon HD 2xxx cards on MacOS have the issue. Instead of checking for the buggy cards, blacklist
673	* all radeon cards on Macs and whitelist the good ones. That way we're prepared for the future. If
674	* this workaround is activated on cards that do not need it, it won't break things, just affect
675	* performance negatively. */
676	TRACE("Enabling vertex texture coord fixes in vertex shaders.\n");
677	gl_info->quirks \|= WINED3D_QUIRK_SET_TEXCOORD_W;
678	}
679
680	static void quirk_clip_varying(struct wined3d_gl_info *gl_info)
681	{
682	gl_info->quirks \|= WINED3D_QUIRK_GLSL_CLIP_VARYING;
683	}
684
685	static void quirk_allows_specular_alpha(struct wined3d_gl_info *gl_info)
686	{
687	gl_info->quirks \|= WINED3D_QUIRK_ALLOWS_SPECULAR_ALPHA;
688	}
689
690	static void quirk_apple_nvts(struct wined3d_gl_info *gl_info)
691	{
692	gl_info->supported[NV_TEXTURE_SHADER] = FALSE;
693	gl_info->supported[NV_TEXTURE_SHADER2] = FALSE;
694	}
695
696	static void quirk_disable_nvvp_clip(struct wined3d_gl_info *gl_info)
697	{
698	gl_info->quirks \|= WINED3D_QUIRK_NV_CLIP_BROKEN;
699	}
700
701	static void quirk_fbo_tex_update(struct wined3d_gl_info *gl_info)
702	{
703	gl_info->quirks \|= WINED3D_QUIRK_FBO_TEX_UPDATE;
704	}
705
706	static BOOL match_ati_hd4800(const struct wined3d_gl_info gl_info, const char gl_renderer,
707	enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
708	{
709	if (card_vendor != HW_VENDOR_ATI) return FALSE;
710	if (device == CARD_ATI_RADEON_HD4800) return TRUE;
711	return FALSE;
712	}
713
714	static void quirk_fullsize_blit(struct wined3d_gl_info *gl_info)
715	{
716	gl_info->quirks \|= WINED3D_QUIRK_FULLSIZE_BLIT;
717	}
718
719	#ifdef VBOX_WITH_WDDM
720	static BOOL match_mesa_nvidia(const struct wined3d_gl_info gl_info, const char gl_renderer,
721	enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
722	{
723	if (card_vendor != HW_VENDOR_NVIDIA) return FALSE;
724	if (gl_vendor != GL_VENDOR_MESA) return FALSE;
725	return TRUE;
726	}
727
728	static void quirk_no_shader_3(struct wined3d_gl_info *gl_info)
729	{
730	int vs_selected_mode, ps_selected_mode;
731	select_shader_mode(gl_info, &ps_selected_mode, &vs_selected_mode);
732	if (vs_selected_mode != SHADER_GLSL && ps_selected_mode != SHADER_GLSL)
733	return;
734
735	gl_info->limits.arb_ps_instructions = 512;
736	}
737	#endif
738
739	static BOOL match_intel(const struct wined3d_gl_info gl_info, const char gl_renderer,
740	enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
741	{
742	if (card_vendor == HW_VENDOR_INTEL) return TRUE;
743	if (gl_vendor == GL_VENDOR_INTEL) return TRUE;
744	return FALSE;
745	}
746
747	static void quirk_force_blit(struct wined3d_gl_info *gl_info)
748	{
749	gl_info->quirks \|= WINED3D_QUIRK_FORCE_BLIT;
750	}
751
752	struct driver_quirk
753	{
754	BOOL (match)(const struct wined3d_gl_info gl_info, const char *gl_renderer,
755	enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device);
756	void (apply)(struct wined3d_gl_info gl_info);
757	const char *description;
758	};
759
760	static const struct driver_quirk quirk_table[] =
761	{
762	{
763	match_ati_r300_to_500,
764	quirk_ati_dx9,
765	"ATI GLSL constant and normalized texrect quirk"
766	},
767	/* MacOS advertises more GLSL vertex shader uniforms than supported by the hardware, and if more are
768	* used it falls back to software. While the compiler can detect if the shader uses all declared
769	* uniforms, the optimization fails if the shader uses relative addressing. So any GLSL shader
770	* using relative addressing falls back to software.
771	*
772	* ARB vp gives the correct amount of uniforms, so use it instead of GLSL. */
773	{
774	match_apple,
775	quirk_apple_glsl_constants,
776	"Apple GLSL uniform override"
777	},
778	{
779	match_geforce5,
780	quirk_no_np2,
781	"Geforce 5 NP2 disable"
782	},
783	{
784	match_apple_intel,
785	quirk_texcoord_w,
786	"Init texcoord .w for Apple Intel GPU driver"
787	},
788	{
789	match_apple_nonr500ati,
790	quirk_texcoord_w,
791	"Init texcoord .w for Apple ATI >= r600 GPU driver"
792	},
793	{
794	match_fglrx,
795	quirk_one_point_sprite,
796	"Fglrx point sprite crash workaround"
797	},
798	{
799	match_dx10_capable,
800	quirk_clip_varying,
801	"Reserved varying for gl_ClipPos"
802	},
803	{
804	/* GL_EXT_secondary_color does not allow 4 component secondary colors, but most
805	* GL implementations accept it. The Mac GL is the only implementation known to
806	* reject it.
807	*
808	* If we can pass 4 component specular colors, do it, because (a) we don't have
809	* to screw around with the data, and (b) the D3D fixed function vertex pipeline
810	* passes specular alpha to the pixel shader if any is used. Otherwise the
811	* specular alpha is used to pass the fog coordinate, which we pass to opengl
812	* via GL_EXT_fog_coord.
813	*/
814	match_allows_spec_alpha,
815	quirk_allows_specular_alpha,
816	"Allow specular alpha quirk"
817	},
818	{
819	/* The pixel formats provided by GL_NV_texture_shader are broken on OSX
820	* (rdar://5682521).
821	*/
822	match_apple_nvts,
823	quirk_apple_nvts,
824	"Apple NV_texture_shader disable"
825	},
826	#ifndef VBOX_WITH_VMSVGA
827	{
828	match_broken_nv_clip,
829	quirk_disable_nvvp_clip,
830	"Apple NV_vertex_program clip bug quirk"
831	},
832	#endif
833	{
834	match_fbo_tex_update,
835	quirk_fbo_tex_update,
836	"FBO rebind for attachment updates"
837	},
838	{
839	match_ati_hd4800,
840	quirk_fullsize_blit,
841	"Fullsize blit"
842	},
843	#ifdef VBOX_WITH_WDDM
844	{
845	match_mesa_nvidia,
846	quirk_no_shader_3,
847	"disable shader 3 support"
848	},
849	#endif
850	{
851	match_intel,
852	quirk_force_blit,
853	"force framebuffer blit when possible"
854	}
855	};
856
857	/* Context activation is done by the caller. */
858	static void fixup_extensions(struct wined3d_gl_info gl_info, const char gl_renderer,
859	enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
860	{
861	unsigned int i;
862
863	for (i = 0; i < (sizeof(quirk_table) / sizeof(*quirk_table)); ++i)
864	{
865	if (!quirk_table[i].match(gl_info, gl_renderer, gl_vendor, card_vendor, device)) continue;
866	TRACE_(d3d_caps)("Applying driver quirk \"%s\".\n", quirk_table[i].description);
867	quirk_table[i].apply(gl_info);
868	}
869
870	/* Find out if PBOs work as they are supposed to. */
871	test_pbo_functionality(gl_info);
872	}
873
874
875	/* Certain applications (Steam) complain if we report an outdated driver version. In general,
876	* reporting a driver version is moot because we are not the Windows driver, and we have different
877	* bugs, features, etc.
878	*
879	* The driver version has the form "x.y.z.w".
880	*
881	* "x" is the Windows version the driver is meant for:
882	* 4 -> 95/98/NT4
883	* 5 -> 2000
884	* 6 -> 2000/XP
885	* 7 -> Vista
886	* 8 -> Win 7
887	*
888	* "y" is the Direct3D level the driver supports:
889	* 11 -> d3d6
890	* 12 -> d3d7
891	* 13 -> d3d8
892	* 14 -> d3d9
893	* 15 -> d3d10
894	*
895	* "z" is unknown, possibly vendor specific.
896	*
897	* "w" is the vendor specific driver version.
898	*/
899	struct driver_version_information
900	{
901	WORD vendor; /* reported PCI card vendor ID */
902	WORD card; /* reported PCI card device ID */
903	const char description; / Description of the card e.g. NVIDIA RIVA TNT */
904	WORD d3d_level; /* driver hiword to report */
905	WORD lopart_hi, lopart_lo; /* driver loword to report */
906	};
907
908	#if 0 /* VBox: unused */
909	static const struct driver_version_information driver_version_table[] =
910	{
911	/* Nvidia drivers. Geforce6 and newer cards are supported by the current driver (180.x)
912	* GeforceFX support is up to 173.x, - driver uses numbering x.y.11.7341 for 173.41 where x is the windows revision (6=2000/xp, 7=vista), y is unknown
913	* Geforce2MX/3/4 up to 96.x - driver uses numbering 9.6.8.9 for 96.89
914	* TNT/Geforce1/2 up to 71.x - driver uses numbering 7.1.8.6 for 71.86
915	*
916	* All version numbers used below are from the Linux nvidia drivers. */
917	{HW_VENDOR_NVIDIA, CARD_NVIDIA_RIVA_TNT, "NVIDIA RIVA TNT", 1, 8, 6 },
918	{HW_VENDOR_NVIDIA, CARD_NVIDIA_RIVA_TNT2, "NVIDIA RIVA TNT2/TNT2 Pro", 1, 8, 6 },
919	{HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE, "NVIDIA GeForce 256", 1, 8, 6 },
920	{HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE2_MX, "NVIDIA GeForce2 MX/MX 400", 6, 4, 3 },
921	{HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE2, "NVIDIA GeForce2 GTS/GeForce2 Pro", 1, 8, 6 },
922	{HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE3, "NVIDIA GeForce3", 6, 10, 9371 },
923	{HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE4_MX, "NVIDIA GeForce4 MX 460", 6, 10, 9371 },
924	{HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE4_TI4200, "NVIDIA GeForce4 Ti 4200", 6, 10, 9371 },
925	{HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCEFX_5200, "NVIDIA GeForce FX 5200", 15, 11, 7516 },
926	{HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCEFX_5600, "NVIDIA GeForce FX 5600", 15, 11, 7516 },
927	{HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCEFX_5800, "NVIDIA GeForce FX 5800", 15, 11, 7516 },
928	{HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_6200, "NVIDIA GeForce 6200", 15, 11, 8618 },
929	{HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_6600GT, "NVIDIA GeForce 6600 GT", 15, 11, 8618 },
930	{HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_6800, "NVIDIA GeForce 6800", 15, 11, 8618 },
931	{HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7300, "NVIDIA GeForce Go 7300", 15, 11, 8585 },
932	{HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7400, "NVIDIA GeForce Go 7400", 15, 11, 8585 },
933	{HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7600, "NVIDIA GeForce 7600 GT", 15, 11, 8618 },
934	{HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7800GT, "NVIDIA GeForce 7800 GT", 15, 11, 8618 },
935	{HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8300GS, "NVIDIA GeForce 8300 GS", 15, 11, 8618 },
936	{HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8600GT, "NVIDIA GeForce 8600 GT", 15, 11, 8618 },
937	{HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8600MGT, "NVIDIA GeForce 8600M GT", 15, 11, 8585 },
938	{HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8800GTS, "NVIDIA GeForce 8800 GTS", 15, 11, 8618 },
939	{HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9200, "NVIDIA GeForce 9200", 15, 11, 8618 },
940	{HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9400GT, "NVIDIA GeForce 9400 GT", 15, 11, 8618 },
941	{HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9500GT, "NVIDIA GeForce 9500 GT", 15, 11, 8618 },
942	{HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9600GT, "NVIDIA GeForce 9600 GT", 15, 11, 8618 },
943	{HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9800GT, "NVIDIA GeForce 9800 GT", 15, 11, 8618 },
944	{HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX260, "NVIDIA GeForce GTX 260", 15, 11, 8618 },
945	{HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX275, "NVIDIA GeForce GTX 275", 15, 11, 8618 },
946	{HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX280, "NVIDIA GeForce GTX 280", 15, 11, 8618 },
947	{HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT240, "NVIDIA GeForce GT 240", 15, 11, 8618 },
948
949	/* ATI cards. The driver versions are somewhat similar, but not quite the same. Let's hardcode. */
950	{HW_VENDOR_ATI, CARD_ATI_RADEON_9500, "ATI Radeon 9500", 14, 10, 6764 },
951	{HW_VENDOR_ATI, CARD_ATI_RADEON_X700, "ATI Radeon X700 SE", 14, 10, 6764 },
952	{HW_VENDOR_ATI, CARD_ATI_RADEON_X1600, "ATI Radeon X1600 Series", 14, 10, 6764 },
953	{HW_VENDOR_ATI, CARD_ATI_RADEON_HD2350, "ATI Mobility Radeon HD 2350", 14, 10, 6764 },
954	{HW_VENDOR_ATI, CARD_ATI_RADEON_HD2600, "ATI Mobility Radeon HD 2600", 14, 10, 6764 },
955	{HW_VENDOR_ATI, CARD_ATI_RADEON_HD2900, "ATI Radeon HD 2900 XT", 14, 10, 6764 },
956	{HW_VENDOR_ATI, CARD_ATI_RADEON_HD4350, "ATI Radeon HD 4350", 14, 10, 6764 },
957	{HW_VENDOR_ATI, CARD_ATI_RADEON_HD4600, "ATI Radeon HD 4600 Series", 14, 10, 6764 },
958	{HW_VENDOR_ATI, CARD_ATI_RADEON_HD4700, "ATI Radeon HD 4700 Series", 14, 10, 6764 },
959	{HW_VENDOR_ATI, CARD_ATI_RADEON_HD4800, "ATI Radeon HD 4800 Series", 14, 10, 6764 },
960	{HW_VENDOR_ATI, CARD_ATI_RADEON_HD5700, "ATI Radeon HD 5700 Series", 14, 10, 8681 },
961	{HW_VENDOR_ATI, CARD_ATI_RADEON_HD5800, "ATI Radeon HD 5800 Series", 14, 10, 8681 },
962
963	/* TODO: Add information about legacy ATI hardware, Intel and other cards. */
964	};
965	#endif /* VBox: unused */
966
967
968	static DWORD wined3d_parse_gl_version(const char *gl_version)
969	{
970	const char *ptr = gl_version;
971	int major, minor;
972
973	major = atoi(ptr);
974	if (major <= 0) ERR_(d3d_caps)("Invalid opengl major version: %d.\n", major);
975
976	while (isdigit(*ptr)) ++ptr;
977	if (*ptr++ != '.') ERR_(d3d_caps)("Invalid opengl version string: %s.\n", debugstr_a(gl_version));
978
979	minor = atoi(ptr);
980
981	TRACE_(d3d_caps)("Found OpenGL version: %d.%d.\n", major, minor);
982
983	return MAKEDWORD_VERSION(major, minor);
984	}
985
986	static enum wined3d_gl_vendor wined3d_guess_gl_vendor(struct wined3d_gl_info gl_info, const char gl_vendor_string, const char *gl_renderer)
987	{
988
989	/* MacOS has various specialities in the extensions it advertises. Some have to be loaded from
990	* the opengl 1.2+ core, while other extensions are advertised, but software emulated. So try to
991	* detect the Apple OpenGL implementation to apply some extension fixups afterwards.
992	*
993	* Detecting this isn't really easy. The vendor string doesn't mention Apple. Compile-time checks
994	* aren't sufficient either because a Linux binary may display on a macos X server via remote X11.
995	* So try to detect the GL implementation by looking at certain Apple extensions. Some extensions
996	* like client storage might be supported on other implementations too, but GL_APPLE_flush_render
997	* is specific to the Mac OS X window management, and GL_APPLE_ycbcr_422 is QuickTime specific. So
998	* the chance that other implementations support them is rather small since Win32 QuickTime uses
999	* DirectDraw, not OpenGL. */
1000	if (gl_info->supported[APPLE_FENCE]
1001	&& gl_info->supported[APPLE_CLIENT_STORAGE]
1002	&& gl_info->supported[APPLE_FLUSH_RENDER]
1003	&& gl_info->supported[APPLE_YCBCR_422])
1004	return GL_VENDOR_APPLE;
1005
1006	if (strstr(gl_vendor_string, "NVIDIA"))
1007	return GL_VENDOR_NVIDIA;
1008
1009	if (strstr(gl_vendor_string, "ATI"))
1010	return GL_VENDOR_FGLRX;
1011
1012	if (strstr(gl_vendor_string, "Intel(R)")
1013	\|\| strstr(gl_renderer, "Intel(R)")
1014	\|\| strstr(gl_vendor_string, "Intel Inc."))
1015	{
1016	if (strstr(gl_renderer, "Mesa"))
1017	return GL_VENDOR_MESA;
1018	return GL_VENDOR_INTEL;
1019	}
1020
1021	if (strstr(gl_vendor_string, "Mesa")
1022	\|\| strstr(gl_vendor_string, "Advanced Micro Devices, Inc.")
1023	\|\| strstr(gl_vendor_string, "DRI R300 Project")
1024	\|\| strstr(gl_vendor_string, "X.Org R300 Project")
1025	\|\| strstr(gl_vendor_string, "Tungsten Graphics, Inc")
1026	\|\| strstr(gl_vendor_string, "VMware, Inc.")
1027	\|\| strstr(gl_renderer, "Mesa")
1028	\|\| strstr(gl_renderer, "Gallium"))
1029	return GL_VENDOR_MESA;
1030
1031	FIXME_(d3d_caps)("Received unrecognized GL_VENDOR %s. Returning GL_VENDOR_UNKNOWN.\n",
1032	debugstr_a(gl_vendor_string));
1033
1034	return GL_VENDOR_UNKNOWN;
1035	}
1036
1037	static enum wined3d_pci_vendor wined3d_guess_card_vendor(const char gl_vendor_string, const char gl_renderer)
1038	{
1039	if (strstr(gl_vendor_string, "NVIDIA"))
1040	return HW_VENDOR_NVIDIA;
1041
1042	if (strstr(gl_vendor_string, "ATI")
1043	\|\| strstr(gl_vendor_string, "Advanced Micro Devices, Inc.")
1044	\|\| strstr(gl_vendor_string, "X.Org R300 Project")
1045	\|\| strstr(gl_vendor_string, "DRI R300 Project"))
1046	return HW_VENDOR_ATI;
1047
1048	if (strstr(gl_vendor_string, "Intel(R)")
1049	\|\| strstr(gl_renderer, "Intel(R)")
1050	\|\| strstr(gl_vendor_string, "Intel Inc."))
1051	return HW_VENDOR_INTEL;
1052
1053	if (strstr(gl_vendor_string, "Mesa")
1054	\|\| strstr(gl_vendor_string, "Tungsten Graphics, Inc")
1055	\|\| strstr(gl_vendor_string, "VMware, Inc."))
1056	return HW_VENDOR_SOFTWARE;
1057
1058	FIXME_(d3d_caps)("Received unrecognized GL_VENDOR %s. Returning HW_VENDOR_NVIDIA.\n", debugstr_a(gl_vendor_string));
1059
1060	return HW_VENDOR_NVIDIA;
1061	}
1062
1063
1064
1065	static enum wined3d_pci_device select_card_nvidia_binary(const struct wined3d_gl_info *gl_info,
1066	const char gl_renderer, unsigned int vidmem)
1067	{
1068	#ifndef VBOX_WITH_WDDM
1069	if (WINE_D3D10_CAPABLE(gl_info))
1070	#endif
1071	{
1072	/* Geforce 200 - highend */
1073	if (strstr(gl_renderer, "GTX 280")
1074	\|\| strstr(gl_renderer, "GTX 285")
1075	\|\| strstr(gl_renderer, "GTX 295"))
1076	{
1077	*vidmem = 1024;
1078	return CARD_NVIDIA_GEFORCE_GTX280;
1079	}
1080
1081	/* Geforce 200 - midend high */
1082	if (strstr(gl_renderer, "GTX 275"))
1083	{
1084	*vidmem = 896;
1085	return CARD_NVIDIA_GEFORCE_GTX275;
1086	}
1087
1088	/* Geforce 200 - midend */
1089	if (strstr(gl_renderer, "GTX 260"))
1090	{
1091	*vidmem = 1024;
1092	return CARD_NVIDIA_GEFORCE_GTX260;
1093	}
1094	/* Geforce 200 - midend */
1095	if (strstr(gl_renderer, "GT 240"))
1096	{
1097	*vidmem = 512;
1098	return CARD_NVIDIA_GEFORCE_GT240;
1099	}
1100
1101	/* Geforce9 - highend / Geforce 200 - midend (GTS 150/250 are based on the same core) */
1102	if (strstr(gl_renderer, "9800")
1103	\|\| strstr(gl_renderer, "GTS 150")
1104	\|\| strstr(gl_renderer, "GTS 250"))
1105	{
1106	*vidmem = 512;
1107	return CARD_NVIDIA_GEFORCE_9800GT;
1108	}
1109
1110	/* Geforce9 - midend */
1111	if (strstr(gl_renderer, "9600"))
1112	{
1113	vidmem = 384; / The 9600GSO has 384MB, the 9600GT has 512-1024MB */
1114	return CARD_NVIDIA_GEFORCE_9600GT;
1115	}
1116
1117	/* Geforce9 - midend low / Geforce 200 - low */
1118	if (strstr(gl_renderer, "9500")
1119	\|\| strstr(gl_renderer, "GT 120")
1120	\|\| strstr(gl_renderer, "GT 130"))
1121	{
1122	vidmem = 256; / The 9500GT has 256-1024MB */
1123	return CARD_NVIDIA_GEFORCE_9500GT;
1124	}
1125
1126	/* Geforce9 - lowend */
1127	if (strstr(gl_renderer, "9400"))
1128	{
1129	vidmem = 256; / The 9400GT has 256-1024MB */
1130	return CARD_NVIDIA_GEFORCE_9400GT;
1131	}
1132
1133	/* Geforce9 - lowend low */
1134	if (strstr(gl_renderer, "9100")
1135	\|\| strstr(gl_renderer, "9200")
1136	\|\| strstr(gl_renderer, "9300")
1137	\|\| strstr(gl_renderer, "G 100"))
1138	{
1139	vidmem = 256; / The 9100-9300 cards have 256MB */
1140	return CARD_NVIDIA_GEFORCE_9200;
1141	}
1142
1143	/* Geforce8 - highend */
1144	if (strstr(gl_renderer, "8800"))
1145	{
1146	vidmem = 320; / The 8800GTS uses 320MB, a 8800GTX can have 768MB */
1147	return CARD_NVIDIA_GEFORCE_8800GTS;
1148	}
1149
1150	/* Geforce8 - midend mobile */
1151	if (strstr(gl_renderer, "8600 M"))
1152	{
1153	*vidmem = 512;
1154	return CARD_NVIDIA_GEFORCE_8600MGT;
1155	}
1156
1157	/* Geforce8 - midend */
1158	if (strstr(gl_renderer, "8600")
1159	\|\| strstr(gl_renderer, "8700"))
1160	{
1161	*vidmem = 256;
1162	return CARD_NVIDIA_GEFORCE_8600GT;
1163	}
1164
1165	/* Geforce8 - lowend */
1166	if (strstr(gl_renderer, "8100")
1167	\|\| strstr(gl_renderer, "8200")
1168	\|\| strstr(gl_renderer, "8300")
1169	\|\| strstr(gl_renderer, "8400")
1170	\|\| strstr(gl_renderer, "8500"))
1171	{
1172	vidmem = 128; / 128-256MB for a 8300, 256-512MB for a 8400 */
1173	return CARD_NVIDIA_GEFORCE_8300GS;
1174	}
1175
1176	/* Geforce8-compatible fall back if the GPU is not in the list yet */
1177	*vidmem = 128;
1178	return CARD_NVIDIA_GEFORCE_8300GS;
1179	}
1180
1181	/* Both the GeforceFX, 6xxx and 7xxx series support D3D9. The last two types have more
1182	* shader capabilities, so we use the shader capabilities to distinguish between FX and 6xxx/7xxx.
1183	*/
1184	if (WINE_D3D9_CAPABLE(gl_info) && gl_info->supported[NV_VERTEX_PROGRAM3])
1185	{
1186	/* Geforce7 - highend */
1187	if (strstr(gl_renderer, "7800")
1188	\|\| strstr(gl_renderer, "7900")
1189	\|\| strstr(gl_renderer, "7950")
1190	\|\| strstr(gl_renderer, "Quadro FX 4")
1191	\|\| strstr(gl_renderer, "Quadro FX 5"))
1192	{
1193	vidmem = 256; / A 7800GT uses 256MB while highend 7900 cards can use 512MB */
1194	return CARD_NVIDIA_GEFORCE_7800GT;
1195	}
1196
1197	/* Geforce7 midend */
1198	if (strstr(gl_renderer, "7600")
1199	\|\| strstr(gl_renderer, "7700"))
1200	{
1201	vidmem = 256; / The 7600 uses 256-512MB */
1202	return CARD_NVIDIA_GEFORCE_7600;
1203	}
1204
1205	/* Geforce7 lower medium */
1206	if (strstr(gl_renderer, "7400"))
1207	{
1208	vidmem = 256; / The 7400 uses 256-512MB */
1209	return CARD_NVIDIA_GEFORCE_7400;
1210	}
1211
1212	/* Geforce7 lowend */
1213	if (strstr(gl_renderer, "7300"))
1214	{
1215	vidmem = 256; / Mac Pros with this card have 256 MB */
1216	return CARD_NVIDIA_GEFORCE_7300;
1217	}
1218
1219	/* Geforce6 highend */
1220	if (strstr(gl_renderer, "6800"))
1221	{
1222	vidmem = 128; / The 6800 uses 128-256MB, the 7600 uses 256-512MB */
1223	return CARD_NVIDIA_GEFORCE_6800;
1224	}
1225
1226	/* Geforce6 - midend */
1227	if (strstr(gl_renderer, "6600")
1228	\|\| strstr(gl_renderer, "6610")
1229	\|\| strstr(gl_renderer, "6700"))
1230	{
1231	vidmem = 128; / A 6600GT has 128-256MB */
1232	return CARD_NVIDIA_GEFORCE_6600GT;
1233	}
1234
1235	/* Geforce6/7 lowend */
1236	vidmem = 64; / */
1237	return CARD_NVIDIA_GEFORCE_6200; /* Geforce 6100/6150/6200/7300/7400/7500 */
1238	}
1239
1240	if (WINE_D3D9_CAPABLE(gl_info))
1241	{
1242	/* GeforceFX - highend */
1243	if (strstr(gl_renderer, "5800")
1244	\|\| strstr(gl_renderer, "5900")
1245	\|\| strstr(gl_renderer, "5950")
1246	\|\| strstr(gl_renderer, "Quadro FX"))
1247	{
1248	vidmem = 256; / 5800-5900 cards use 256MB */
1249	return CARD_NVIDIA_GEFORCEFX_5800;
1250	}
1251
1252	/* GeforceFX - midend */
1253	if (strstr(gl_renderer, "5600")
1254	\|\| strstr(gl_renderer, "5650")
1255	\|\| strstr(gl_renderer, "5700")
1256	\|\| strstr(gl_renderer, "5750"))
1257	{
1258	vidmem = 128; / A 5600 uses 128-256MB */
1259	return CARD_NVIDIA_GEFORCEFX_5600;
1260	}
1261
1262	/* GeforceFX - lowend */
1263	vidmem = 64; / Normal FX5200 cards use 64-256MB; laptop (non-standard) can have less */
1264	return CARD_NVIDIA_GEFORCEFX_5200; /* GeforceFX 5100/5200/5250/5300/5500 */
1265	}
1266
1267	if (WINE_D3D8_CAPABLE(gl_info))
1268	{
1269	if (strstr(gl_renderer, "GeForce4 Ti") \|\| strstr(gl_renderer, "Quadro4"))
1270	{
1271	vidmem = 64; / Geforce4 Ti cards have 64-128MB */
1272	return CARD_NVIDIA_GEFORCE4_TI4200; /* Geforce4 Ti4200/Ti4400/Ti4600/Ti4800, Quadro4 */
1273	}
1274
1275	vidmem = 64; / Geforce3 cards have 64-128MB */
1276	return CARD_NVIDIA_GEFORCE3; /* Geforce3 standard/Ti200/Ti500, Quadro DCC */
1277	}
1278
1279	if (WINE_D3D7_CAPABLE(gl_info))
1280	{
1281	if (strstr(gl_renderer, "GeForce4 MX"))
1282	{
1283	/* Most Geforce4MX GPUs have at least 64MB of memory, some
1284	* early models had 32MB but most have 64MB or even 128MB. */
1285	*vidmem = 64;
1286	return CARD_NVIDIA_GEFORCE4_MX; /* MX420/MX440/MX460/MX4000 */
1287	}
1288
1289	if (strstr(gl_renderer, "GeForce2 MX") \|\| strstr(gl_renderer, "Quadro2 MXR"))
1290	{
1291	vidmem = 32; / Geforce2MX GPUs have 32-64MB of video memory */
1292	return CARD_NVIDIA_GEFORCE2_MX; /* Geforce2 standard/MX100/MX200/MX400, Quadro2 MXR */
1293	}
1294
1295	if (strstr(gl_renderer, "GeForce2") \|\| strstr(gl_renderer, "Quadro2"))
1296	{
1297	vidmem = 32; / Geforce2 GPUs have 32-64MB of video memory */
1298	return CARD_NVIDIA_GEFORCE2; /* Geforce2 GTS/Pro/Ti/Ultra, Quadro2 */
1299	}
1300
1301	/* Most Geforce1 cards have 32MB, there are also some rare 16
1302	* and 64MB (Dell) models. */
1303	*vidmem = 32;
1304	return CARD_NVIDIA_GEFORCE; /* Geforce 256/DDR, Quadro */
1305	}
1306
1307	if (strstr(gl_renderer, "TNT2"))
1308	{
1309	vidmem = 32; / Most TNT2 boards have 32MB, though there are 16MB boards too */
1310	return CARD_NVIDIA_RIVA_TNT2; /* Riva TNT2 standard/M64/Pro/Ultra */
1311	}
1312
1313	vidmem = 16; / Most TNT boards have 16MB, some rare models have 8MB */
1314	return CARD_NVIDIA_RIVA_TNT; /* Riva TNT, Vanta */
1315
1316	}
1317
1318	static enum wined3d_pci_device select_card_ati_binary(const struct wined3d_gl_info *gl_info,
1319	const char gl_renderer, unsigned int vidmem)
1320	{
1321	/* See http://developer.amd.com/drivers/pc_vendor_id/Pages/default.aspx
1322	*
1323	* Beware: renderer string do not match exact card model,
1324	* eg HD 4800 is returned for multiple cards, even for RV790 based ones. */
1325	#ifndef VBOX_WITH_WDDM
1326	if (WINE_D3D10_CAPABLE(gl_info))
1327	#endif
1328	{
1329	/* Radeon EG CYPRESS XT / PRO HD5800 - highend */
1330	if (strstr(gl_renderer, "HD 5800") /* Radeon EG CYPRESS HD58xx generic renderer string */
1331	\|\| strstr(gl_renderer, "HD 5850") /* Radeon EG CYPRESS XT */
1332	\|\| strstr(gl_renderer, "HD 5870")) /* Radeon EG CYPRESS PRO */
1333	{
1334	vidmem = 1024; / note: HD58xx cards use 1024MB */
1335	return CARD_ATI_RADEON_HD5800;
1336	}
1337
1338	/* Radeon EG JUNIPER XT / LE HD5700 - midend */
1339	if (strstr(gl_renderer, "HD 5700") /* Radeon EG JUNIPER HD57xx generic renderer string */
1340	\|\| strstr(gl_renderer, "HD 5750") /* Radeon EG JUNIPER LE */
1341	\|\| strstr(gl_renderer, "HD 5770")) /* Radeon EG JUNIPER XT */
1342	{
1343	vidmem = 512; / note: HD5770 cards use 1024MB and HD5750 cards use 512MB or 1024MB */
1344	return CARD_ATI_RADEON_HD5700;
1345	}
1346
1347	/* Radeon R7xx HD4800 - highend */
1348	if (strstr(gl_renderer, "HD 4800") /* Radeon RV7xx HD48xx generic renderer string */
1349	\|\| strstr(gl_renderer, "HD 4830") /* Radeon RV770 */
1350	\|\| strstr(gl_renderer, "HD 4850") /* Radeon RV770 */
1351	\|\| strstr(gl_renderer, "HD 4870") /* Radeon RV770 */
1352	\|\| strstr(gl_renderer, "HD 4890")) /* Radeon RV790 */
1353	{
1354	vidmem = 512; / note: HD4890 cards use 1024MB */
1355	return CARD_ATI_RADEON_HD4800;
1356	}
1357
1358	/* Radeon R740 HD4700 - midend */
1359	if (strstr(gl_renderer, "HD 4700") /* Radeon RV770 */
1360	\|\| strstr(gl_renderer, "HD 4770")) /* Radeon RV740 */
1361	{
1362	*vidmem = 512;
1363	return CARD_ATI_RADEON_HD4700;
1364	}
1365
1366	/* Radeon R730 HD4600 - midend */
1367	if (strstr(gl_renderer, "HD 4600") /* Radeon RV730 */
1368	\|\| strstr(gl_renderer, "HD 4650") /* Radeon RV730 */
1369	\|\| strstr(gl_renderer, "HD 4670")) /* Radeon RV730 */
1370	{
1371	*vidmem = 512;
1372	return CARD_ATI_RADEON_HD4600;
1373	}
1374
1375	/* Radeon R710 HD4500/HD4350 - lowend */
1376	if (strstr(gl_renderer, "HD 4350") /* Radeon RV710 */
1377	\|\| strstr(gl_renderer, "HD 4550")) /* Radeon RV710 */
1378	{
1379	*vidmem = 256;
1380	return CARD_ATI_RADEON_HD4350;
1381	}
1382
1383	/* Radeon R6xx HD2900/HD3800 - highend */
1384	if (strstr(gl_renderer, "HD 2900")
1385	\|\| strstr(gl_renderer, "HD 3870")
1386	\|\| strstr(gl_renderer, "HD 3850"))
1387	{
1388	vidmem = 512; / HD2900/HD3800 uses 256-1024MB */
1389	return CARD_ATI_RADEON_HD2900;
1390	}
1391
1392	/* Radeon R6xx HD2600/HD3600 - midend; HD3830 is China-only midend */
1393	if (strstr(gl_renderer, "HD 2600")
1394	\|\| strstr(gl_renderer, "HD 3830")
1395	\|\| strstr(gl_renderer, "HD 3690")
1396	\|\| strstr(gl_renderer, "HD 3650"))
1397	{
1398	vidmem = 256; / HD2600/HD3600 uses 256-512MB */
1399	return CARD_ATI_RADEON_HD2600;
1400	}
1401
1402	/* Radeon R6xx HD2350/HD2400/HD3400 - lowend
1403	* Note HD2300=DX9, HD2350=DX10 */
1404	if (strstr(gl_renderer, "HD 2350")
1405	\|\| strstr(gl_renderer, "HD 2400")
1406	\|\| strstr(gl_renderer, "HD 3470")
1407	\|\| strstr(gl_renderer, "HD 3450")
1408	\|\| strstr(gl_renderer, "HD 3430")
1409	\|\| strstr(gl_renderer, "HD 3400"))
1410	{
1411	vidmem = 256; / HD2350/2400 use 256MB, HD34xx use 256-512MB */
1412	return CARD_ATI_RADEON_HD2350;
1413	}
1414
1415	/* Radeon R6xx/R7xx integrated */
1416	if (strstr(gl_renderer, "HD 3100")
1417	\|\| strstr(gl_renderer, "HD 3200")
1418	\|\| strstr(gl_renderer, "HD 3300"))
1419	{
1420	vidmem = 128; / 128MB */
1421	return CARD_ATI_RADEON_HD3200;
1422	}
1423
1424	/* Default for when no GPU has been found */
1425	vidmem = 128; / 128MB */
1426	return CARD_ATI_RADEON_HD3200;
1427	}
1428
1429	if (WINE_D3D8_CAPABLE(gl_info))
1430	{
1431	/* Radeon R5xx */
1432	if (strstr(gl_renderer, "X1600")
1433	\|\| strstr(gl_renderer, "X1650")
1434	\|\| strstr(gl_renderer, "X1800")
1435	\|\| strstr(gl_renderer, "X1900")
1436	\|\| strstr(gl_renderer, "X1950"))
1437	{
1438	vidmem = 128; / X1600 uses 128-256MB, >=X1800 uses 256MB */
1439	return CARD_ATI_RADEON_X1600;
1440	}
1441
1442	/* Radeon R4xx + X1300/X1400/X1450/X1550/X2300/X2500/HD2300 (lowend R5xx)
1443	* Note X2300/X2500/HD2300 are R5xx GPUs with a 2xxx naming but they are still DX9-only */
1444	if (strstr(gl_renderer, "X700")
1445	\|\| strstr(gl_renderer, "X800")
1446	\|\| strstr(gl_renderer, "X850")
1447	\|\| strstr(gl_renderer, "X1300")
1448	\|\| strstr(gl_renderer, "X1400")
1449	\|\| strstr(gl_renderer, "X1450")
1450	\|\| strstr(gl_renderer, "X1550")
1451	\|\| strstr(gl_renderer, "X2300")
1452	\|\| strstr(gl_renderer, "X2500")
1453	\|\| strstr(gl_renderer, "HD 2300")
1454	)
1455	{
1456	vidmem = 128; / x700/x80 use 128-256MB, >=x1300 128-512MB /
1457	return CARD_ATI_RADEON_X700;
1458	}
1459
1460	/* Radeon Xpress Series - onboard, DX9b, Shader 2.0, 300-400MHz */
1461	if (strstr(gl_renderer, "Radeon Xpress"))
1462	{
1463	vidmem = 64; / Shared RAM, BIOS configurable, 64-256M */
1464	return CARD_ATI_RADEON_XPRESS_200M;
1465	}
1466
1467	/* Radeon R3xx */
1468	vidmem = 64; / Radeon 9500 uses 64MB, higher models use up to 256MB */
1469	return CARD_ATI_RADEON_9500; /* Radeon 9500/9550/9600/9700/9800/X300/X550/X600 */
1470	}
1471
1472	if (WINE_D3D8_CAPABLE(gl_info))
1473	{
1474	vidmem = 64; / 8500/9000 cards use mostly 64MB, though there are 32MB and 128MB models */
1475	return CARD_ATI_RADEON_8500; /* Radeon 8500/9000/9100/9200/9300 */
1476	}
1477
1478	if (WINE_D3D7_CAPABLE(gl_info))
1479	{
1480	vidmem = 32; / There are models with up to 64MB */
1481	return CARD_ATI_RADEON_7200; /* Radeon 7000/7100/7200/7500 */
1482	}
1483
1484	vidmem = 16; / There are 16-32MB models */
1485	return CARD_ATI_RAGE_128PRO;
1486
1487	}
1488
1489	static enum wined3d_pci_device select_card_intel_binary(const struct wined3d_gl_info *gl_info,
1490	const char gl_renderer, unsigned int vidmem)
1491	{
1492	if (strstr(gl_renderer, "X3100"))
1493	{
1494	/* MacOS calls the card GMA X3100, Google findings also suggest the name GM965 */
1495	*vidmem = 128;
1496	return CARD_INTEL_X3100;
1497	}
1498
1499	if (strstr(gl_renderer, "GMA 950") \|\| strstr(gl_renderer, "945GM"))
1500	{
1501	/* MacOS calls the card GMA 950, but everywhere else the PCI ID is named 945GM */
1502	*vidmem = 64;
1503	return CARD_INTEL_I945GM;
1504	}
1505
1506	if (strstr(gl_renderer, "915GM")) return CARD_INTEL_I915GM;
1507	if (strstr(gl_renderer, "915G")) return CARD_INTEL_I915G;
1508	if (strstr(gl_renderer, "865G")) return CARD_INTEL_I865G;
1509	if (strstr(gl_renderer, "855G")) return CARD_INTEL_I855G;
1510	if (strstr(gl_renderer, "830G")) return CARD_INTEL_I830G;
1511	return CARD_INTEL_I915G;
1512
1513	}
1514
1515	static enum wined3d_pci_device select_card_ati_mesa(const struct wined3d_gl_info *gl_info,
1516	const char gl_renderer, unsigned int vidmem)
1517	{
1518	/* See http://developer.amd.com/drivers/pc_vendor_id/Pages/default.aspx
1519	*
1520	* Beware: renderer string do not match exact card model,
1521	* eg HD 4800 is returned for multiple cards, even for RV790 based ones. */
1522	if (strstr(gl_renderer, "Gallium"))
1523	{
1524	/* Radeon R7xx HD4800 - highend */
1525	if (strstr(gl_renderer, "R700") /* Radeon R7xx HD48xx generic renderer string */
1526	\|\| strstr(gl_renderer, "RV770") /* Radeon RV770 */
1527	\|\| strstr(gl_renderer, "RV790")) /* Radeon RV790 */
1528	{
1529	vidmem = 512; / note: HD4890 cards use 1024MB */
1530	return CARD_ATI_RADEON_HD4800;
1531	}
1532
1533	/* Radeon R740 HD4700 - midend */
1534	if (strstr(gl_renderer, "RV740")) /* Radeon RV740 */
1535	{
1536	*vidmem = 512;
1537	return CARD_ATI_RADEON_HD4700;
1538	}
1539
1540	/* Radeon R730 HD4600 - midend */
1541	if (strstr(gl_renderer, "RV730")) /* Radeon RV730 */
1542	{
1543	*vidmem = 512;
1544	return CARD_ATI_RADEON_HD4600;
1545	}
1546
1547	/* Radeon R710 HD4500/HD4350 - lowend */
1548	if (strstr(gl_renderer, "RV710")) /* Radeon RV710 */
1549	{
1550	*vidmem = 256;
1551	return CARD_ATI_RADEON_HD4350;
1552	}
1553
1554	/* Radeon R6xx HD2900/HD3800 - highend */
1555	if (strstr(gl_renderer, "R600")
1556	\|\| strstr(gl_renderer, "RV670")
1557	\|\| strstr(gl_renderer, "R680"))
1558	{
1559	vidmem = 512; / HD2900/HD3800 uses 256-1024MB */
1560	return CARD_ATI_RADEON_HD2900;
1561	}
1562
1563	/* Radeon R6xx HD2600/HD3600 - midend; HD3830 is China-only midend */
1564	if (strstr(gl_renderer, "RV630")
1565	\|\| strstr(gl_renderer, "RV635"))
1566	{
1567	vidmem = 256; / HD2600/HD3600 uses 256-512MB */
1568	return CARD_ATI_RADEON_HD2600;
1569	}
1570
1571	/* Radeon R6xx HD2350/HD2400/HD3400 - lowend */
1572	if (strstr(gl_renderer, "RV610")
1573	\|\| strstr(gl_renderer, "RV620"))
1574	{
1575	vidmem = 256; / HD2350/2400 use 256MB, HD34xx use 256-512MB */
1576	return CARD_ATI_RADEON_HD2350;
1577	}
1578
1579	/* Radeon R6xx/R7xx integrated */
1580	if (strstr(gl_renderer, "RS780")
1581	\|\| strstr(gl_renderer, "RS880"))
1582	{
1583	vidmem = 128; / 128MB */
1584	return CARD_ATI_RADEON_HD3200;
1585	}
1586
1587	/* Radeon R5xx */
1588	if (strstr(gl_renderer, "RV530")
1589	\|\| strstr(gl_renderer, "RV535")
1590	\|\| strstr(gl_renderer, "RV560")
1591	\|\| strstr(gl_renderer, "R520")
1592	\|\| strstr(gl_renderer, "RV570")
1593	\|\| strstr(gl_renderer, "R580"))
1594	{
1595	vidmem = 128; / X1600 uses 128-256MB, >=X1800 uses 256MB */
1596	return CARD_ATI_RADEON_X1600;
1597	}
1598
1599	/* Radeon R4xx + X1300/X1400/X1450/X1550/X2300 (lowend R5xx) */
1600	if (strstr(gl_renderer, "R410")
1601	\|\| strstr(gl_renderer, "R420")
1602	\|\| strstr(gl_renderer, "R423")
1603	\|\| strstr(gl_renderer, "R430")
1604	\|\| strstr(gl_renderer, "R480")
1605	\|\| strstr(gl_renderer, "R481")
1606	\|\| strstr(gl_renderer, "RV410")
1607	\|\| strstr(gl_renderer, "RV515")
1608	\|\| strstr(gl_renderer, "RV516"))
1609	{
1610	vidmem = 128; / x700/x80 use 128-256MB, >=x1300 128-512MB /
1611	return CARD_ATI_RADEON_X700;
1612	}
1613
1614	/* Radeon Xpress Series - onboard, DX9b, Shader 2.0, 300-400MHz */
1615	if (strstr(gl_renderer, "RS400")
1616	\|\| strstr(gl_renderer, "RS480")
1617	\|\| strstr(gl_renderer, "RS482")
1618	\|\| strstr(gl_renderer, "RS485")
1619	\|\| strstr(gl_renderer, "RS600")
1620	\|\| strstr(gl_renderer, "RS690")
1621	\|\| strstr(gl_renderer, "RS740"))
1622	{
1623	vidmem = 64; / Shared RAM, BIOS configurable, 64-256M */
1624	return CARD_ATI_RADEON_XPRESS_200M;
1625	}
1626
1627	/* Radeon R3xx */
1628	if (strstr(gl_renderer, "R300")
1629	\|\| strstr(gl_renderer, "RV350")
1630	\|\| strstr(gl_renderer, "RV351")
1631	\|\| strstr(gl_renderer, "RV360")
1632	\|\| strstr(gl_renderer, "RV370")
1633	\|\| strstr(gl_renderer, "R350")
1634	\|\| strstr(gl_renderer, "R360"))
1635	{
1636	vidmem = 64; / Radeon 9500 uses 64MB, higher models use up to 256MB */
1637	return CARD_ATI_RADEON_9500; /* Radeon 9500/9550/9600/9700/9800/X300/X550/X600 */
1638	}
1639	}
1640
1641	if (WINE_D3D9_CAPABLE(gl_info))
1642	{
1643	/* Radeon R7xx HD4800 - highend */
1644	if (strstr(gl_renderer, "(R700") /* Radeon R7xx HD48xx generic renderer string */
1645	\|\| strstr(gl_renderer, "(RV770") /* Radeon RV770 */
1646	\|\| strstr(gl_renderer, "(RV790")) /* Radeon RV790 */
1647	{
1648	vidmem = 512; / note: HD4890 cards use 1024MB */
1649	return CARD_ATI_RADEON_HD4800;
1650	}
1651
1652	/* Radeon R740 HD4700 - midend */
1653	if (strstr(gl_renderer, "(RV740")) /* Radeon RV740 */
1654	{
1655	*vidmem = 512;
1656	return CARD_ATI_RADEON_HD4700;
1657	}
1658
1659	/* Radeon R730 HD4600 - midend */
1660	if (strstr(gl_renderer, "(RV730")) /* Radeon RV730 */
1661	{
1662	*vidmem = 512;
1663	return CARD_ATI_RADEON_HD4600;
1664	}
1665
1666	/* Radeon R710 HD4500/HD4350 - lowend */
1667	if (strstr(gl_renderer, "(RV710")) /* Radeon RV710 */
1668	{
1669	*vidmem = 256;
1670	return CARD_ATI_RADEON_HD4350;
1671	}
1672
1673	/* Radeon R6xx HD2900/HD3800 - highend */
1674	if (strstr(gl_renderer, "(R600")
1675	\|\| strstr(gl_renderer, "(RV670")
1676	\|\| strstr(gl_renderer, "(R680"))
1677	{
1678	vidmem = 512; / HD2900/HD3800 uses 256-1024MB */
1679	return CARD_ATI_RADEON_HD2900;
1680	}
1681
1682	/* Radeon R6xx HD2600/HD3600 - midend; HD3830 is China-only midend */
1683	if (strstr(gl_renderer, "(RV630")
1684	\|\| strstr(gl_renderer, "(RV635"))
1685	{
1686	vidmem = 256; / HD2600/HD3600 uses 256-512MB */
1687	return CARD_ATI_RADEON_HD2600;
1688	}
1689
1690	/* Radeon R6xx HD2300/HD2400/HD3400 - lowend */
1691	if (strstr(gl_renderer, "(RV610")
1692	\|\| strstr(gl_renderer, "(RV620"))
1693	{
1694	vidmem = 256; / HD2350/2400 use 256MB, HD34xx use 256-512MB */
1695	return CARD_ATI_RADEON_HD2350;
1696	}
1697
1698	/* Radeon R6xx/R7xx integrated */
1699	if (strstr(gl_renderer, "(RS780")
1700	\|\| strstr(gl_renderer, "(RS880"))
1701	{
1702	vidmem = 128; / 128MB */
1703	return CARD_ATI_RADEON_HD3200;
1704	}
1705	}
1706
1707	if (WINE_D3D8_CAPABLE(gl_info))
1708	{
1709	vidmem = 64; / 8500/9000 cards use mostly 64MB, though there are 32MB and 128MB models */
1710	return CARD_ATI_RADEON_8500; /* Radeon 8500/9000/9100/9200/9300 */
1711	}
1712
1713	if (WINE_D3D7_CAPABLE(gl_info))
1714	{
1715	vidmem = 32; / There are models with up to 64MB */
1716	return CARD_ATI_RADEON_7200; /* Radeon 7000/7100/7200/7500 */
1717	}
1718
1719	vidmem = 16; / There are 16-32MB models */
1720	return CARD_ATI_RAGE_128PRO;
1721
1722	}
1723
1724	static enum wined3d_pci_device select_card_nvidia_mesa(const struct wined3d_gl_info *gl_info,
1725	const char gl_renderer, unsigned int vidmem)
1726	{
1727	FIXME_(d3d_caps)("Card selection not handled for Mesa Nouveau driver\n");
1728	#ifndef VBOX_WITH_WDDM
1729	if (WINE_D3D9_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCEFX_5600;
1730	#else
1731	/* tmp work around to disable quirk_no_np2 quirk for mesa drivers */
1732	if (WINE_D3D9_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCE_6200;
1733	#endif
1734	if (WINE_D3D8_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCE3;
1735	if (WINE_D3D7_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCE;
1736	if (WINE_D3D6_CAPABLE(gl_info)) return CARD_NVIDIA_RIVA_TNT;
1737	return CARD_NVIDIA_RIVA_128;
1738	}
1739
1740	static enum wined3d_pci_device select_card_intel_cmn(const struct wined3d_gl_info *gl_info,
1741	const char gl_renderer, unsigned int vidmem)
1742	{
1743	if (strstr(gl_renderer, "HD Graphics")
1744	\|\| strstr(gl_renderer, "Sandybridge"))
1745	return CARD_INTEL_SBHD;
1746	FIXME_(d3d_caps)("Card selection not handled for Windows Intel driver\n");
1747	return CARD_INTEL_I915G;
1748	}
1749
1750	static enum wined3d_pci_device select_card_intel_mesa(const struct wined3d_gl_info *gl_info,
1751	const char gl_renderer, unsigned int vidmem)
1752	{
1753	return select_card_intel_cmn(gl_info, gl_renderer, vidmem);
1754	}
1755
1756	struct vendor_card_selection
1757	{
1758	enum wined3d_gl_vendor gl_vendor;
1759	enum wined3d_pci_vendor card_vendor;
1760	const char description; / Description of the card selector i.e. Apple OS/X Intel */
1761	enum wined3d_pci_device (select_card)(const struct wined3d_gl_info gl_info, const char *gl_renderer,
1762	unsigned int *vidmem );
1763	};
1764
1765	static const struct vendor_card_selection vendor_card_select_table[] =
1766	{
1767	{GL_VENDOR_NVIDIA, HW_VENDOR_NVIDIA, "Nvidia binary driver", select_card_nvidia_binary},
1768	{GL_VENDOR_APPLE, HW_VENDOR_NVIDIA, "Apple OSX NVidia binary driver", select_card_nvidia_binary},
1769	{GL_VENDOR_APPLE, HW_VENDOR_ATI, "Apple OSX AMD/ATI binary driver", select_card_ati_binary},
1770	{GL_VENDOR_APPLE, HW_VENDOR_INTEL, "Apple OSX Intel binary driver", select_card_intel_binary},
1771	{GL_VENDOR_FGLRX, HW_VENDOR_ATI, "AMD/ATI binary driver", select_card_ati_binary},
1772	{GL_VENDOR_MESA, HW_VENDOR_ATI, "Mesa AMD/ATI driver", select_card_ati_mesa},
1773	{GL_VENDOR_MESA, HW_VENDOR_NVIDIA, "Mesa Nouveau driver", select_card_nvidia_mesa},
1774	{GL_VENDOR_MESA, HW_VENDOR_INTEL, "Mesa Intel driver", select_card_intel_mesa},
1775	{GL_VENDOR_INTEL, HW_VENDOR_INTEL, "Windows Intel binary driver", select_card_intel_cmn}
1776	};
1777
1778
1779	static enum wined3d_pci_device wined3d_guess_card(const struct wined3d_gl_info gl_info, const char gl_renderer,
1780	enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, unsigned int *vidmem)
1781	{
1782	/* Above is a list of Nvidia and ATI GPUs. Both vendors have dozens of
1783	* different GPUs with roughly the same features. In most cases GPUs from a
1784	* certain family differ in clockspeeds, the amount of video memory and the
1785	* number of shader pipelines.
1786	*
1787	* A Direct3D device object contains the PCI id (vendor + device) of the
1788	* videocard which is used for rendering. Various applications use this
1789	* information to get a rough estimation of the features of the card and
1790	* some might use it for enabling 3d effects only on certain types of
1791	* videocards. In some cases games might even use it to work around bugs
1792	* which happen on certain videocards/driver combinations. The problem is
1793	* that OpenGL only exposes a rendering string containing the name of the
1794	* videocard and not the PCI id.
1795	*
1796	* Various games depend on the PCI id, so somehow we need to provide one.
1797	* A simple option is to parse the renderer string and translate this to
1798	* the right PCI id. This is a lot of work because there are more than 200
1799	* GPUs just for Nvidia. Various cards share the same renderer string, so
1800	* the amount of code might be 'small' but there are quite a number of
1801	* exceptions which would make this a pain to maintain. Another way would
1802	* be to query the PCI id from the operating system (assuming this is the
1803	* videocard which is used for rendering which is not always the case).
1804	* This would work but it is not very portable. Second it would not work
1805	* well in, let's say, a remote X situation in which the amount of 3d
1806	* features which can be used is limited.
1807	*
1808	* As said most games only use the PCI id to get an indication of the
1809	* capabilities of the card. It doesn't really matter if the given id is
1810	* the correct one if we return the id of a card with similar 3d features.
1811	*
1812	* The code below checks the OpenGL capabilities of a videocard and matches
1813	* that to a certain level of Direct3D functionality. Once a card passes
1814	* the Direct3D9 check, we know that the card (in case of Nvidia) is at
1815	* least a GeforceFX. To give a better estimate we do a basic check on the
1816	* renderer string but if that won't pass we return a default card. This
1817	* way is better than maintaining a full card database as even without a
1818	* full database we can return a card with similar features. Second the
1819	* size of the database can be made quite small because when you know what
1820	* type of 3d functionality a card has, you know to which GPU family the
1821	* GPU must belong. Because of this you only have to check a small part of
1822	* the renderer string to distinguishes between different models from that
1823	* family.
1824	*
1825	* The code also selects a default amount of video memory which we will
1826	* use for an estimation of the amount of free texture memory. In case of
1827	* real D3D the amount of texture memory includes video memory and system
1828	* memory (to be specific AGP memory or in case of PCIE TurboCache /
1829	* HyperMemory). We don't know how much system memory can be addressed by
1830	* the system but we can make a reasonable estimation about the amount of
1831	* video memory. If the value is slightly wrong it doesn't matter as we
1832	* didn't include AGP-like memory which makes the amount of addressable
1833	* memory higher and second OpenGL isn't that critical it moves to system
1834	* memory behind our backs if really needed. Note that the amount of video
1835	* memory can be overruled using a registry setting. */
1836
1837	#ifndef VBOX
1838	int i;
1839	#else
1840	size_t i;
1841	#endif
1842
1843	for (i = 0; i < (sizeof(vendor_card_select_table) / sizeof(*vendor_card_select_table)); ++i)
1844	{
1845	if ((vendor_card_select_table[i].gl_vendor != *gl_vendor)
1846	\|\| (vendor_card_select_table[i].card_vendor != *card_vendor))
1847	continue;
1848	TRACE_(d3d_caps)("Applying card_selector \"%s\".\n", vendor_card_select_table[i].description);
1849	return vendor_card_select_table[i].select_card(gl_info, gl_renderer, vidmem);
1850	}
1851
1852	FIXME_(d3d_caps)("No card selector available for GL vendor %d and card vendor %04x.\n",
1853	gl_vendor, card_vendor);
1854
1855	/* Default to generic Nvidia hardware based on the supported OpenGL extensions. The choice
1856	* for Nvidia was because the hardware and drivers they make are of good quality. This makes
1857	* them a good generic choice. */
1858	*card_vendor = HW_VENDOR_NVIDIA;
1859	#ifndef VBOX_WITH_WDDM
1860	if (WINE_D3D9_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCEFX_5600;
1861	#else
1862	/* tmp work around to disable quirk_no_np2 quirk for not-recognized drivers */
1863	if (WINE_D3D9_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCE_6200;
1864	#endif
1865
1866	if (WINE_D3D8_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCE3;
1867	if (WINE_D3D7_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCE;
1868	if (WINE_D3D6_CAPABLE(gl_info)) return CARD_NVIDIA_RIVA_TNT;
1869	return CARD_NVIDIA_RIVA_128;
1870	}
1871
1872	#ifndef VBOX_WITH_VMSVGA
1873	static const struct fragment_pipeline select_fragment_implementation(struct wined3d_adapter adapter)
1874	{
1875	const struct wined3d_gl_info *gl_info = &adapter->gl_info;
1876	int vs_selected_mode, ps_selected_mode;
1877
1878	select_shader_mode(gl_info, &ps_selected_mode, &vs_selected_mode);
1879	if ((ps_selected_mode == SHADER_ARB \|\| ps_selected_mode == SHADER_GLSL)
1880	&& gl_info->supported[ARB_FRAGMENT_PROGRAM]) return &arbfp_fragment_pipeline;
1881	else if (ps_selected_mode == SHADER_ATI) return &atifs_fragment_pipeline;
1882	else if (gl_info->supported[NV_REGISTER_COMBINERS]
1883	&& gl_info->supported[NV_TEXTURE_SHADER2]) return &nvts_fragment_pipeline;
1884	else if (gl_info->supported[NV_REGISTER_COMBINERS]) return &nvrc_fragment_pipeline;
1885	else return &ffp_fragment_pipeline;
1886	}
1887	#endif
1888
1889	static const shader_backend_t select_shader_backend(struct wined3d_adapter adapter)
1890	{
1891	int vs_selected_mode, ps_selected_mode;
1892
1893	select_shader_mode(&adapter->gl_info, &ps_selected_mode, &vs_selected_mode);
1894	if (vs_selected_mode == SHADER_GLSL \|\| ps_selected_mode == SHADER_GLSL) return &glsl_shader_backend;
1895	#ifndef VBOX_WITH_VMSVGA
1896	if (vs_selected_mode == SHADER_ARB \|\| ps_selected_mode == SHADER_ARB) return &arb_program_shader_backend;
1897	#endif
1898	return &none_shader_backend;
1899	}
1900
1901	#ifndef VBOX_WITH_VMSVGA
1902	static const struct blit_shader select_blit_implementation(struct wined3d_adapter adapter)
1903	{
1904	const struct wined3d_gl_info *gl_info = &adapter->gl_info;
1905	int vs_selected_mode, ps_selected_mode;
1906
1907	select_shader_mode(gl_info, &ps_selected_mode, &vs_selected_mode);
1908	if ((ps_selected_mode == SHADER_ARB \|\| ps_selected_mode == SHADER_GLSL)
1909	&& gl_info->supported[ARB_FRAGMENT_PROGRAM]) return &arbfp_blit;
1910	else return &ffp_blit;
1911	}
1912	#endif
1913
1914	#ifdef VBOX_WITH_VMSVGA
1915	/** Checks if @a pszExtension is one of the extensions we're looking for and
1916	* updates @a pGlInfo->supported accordingly. */
1917	static void check_gl_extension(struct wined3d_gl_info pGlInfo, const char pszExtension)
1918	{
1919	size_t i;
1920	TRACE_(d3d_caps)("- %s\n", debugstr_a(pszExtension));
1921	for (i = 0; i < RT_ELEMENTS(EXTENSION_MAP); i++)
1922	if (!strcmp(pszExtension, EXTENSION_MAP[i].extension_string))
1923	{
1924	TRACE_(d3d_caps)(" FOUND: %s support.\n", EXTENSION_MAP[i].extension_string);
1925	pGlInfo->supported[EXTENSION_MAP[i].extension] = TRUE;
1926	return;
1927	}
1928	}
1929	#endif
1930
1931	/* Context activation is done by the caller. */
1932	BOOL IWineD3DImpl_FillGLCaps(struct wined3d_adapter adapter, struct VBOXVMSVGASHADERIF pVBoxShaderIf)
1933	{
1934	#ifndef VBOX_WITH_VMSVGA
1935	struct wined3d_driver_info *driver_info = &adapter->driver_info;
1936	#endif
1937	struct wined3d_gl_info *gl_info = &adapter->gl_info;
1938	#ifndef VBOX_WITH_VMSVGA
1939	const char *GL_Extensions = NULL;
1940	const char *WGL_Extensions = NULL;
1941	#endif
1942	const char gl_vendor_str, gl_renderer_str, *gl_version_str;
1943	#ifndef VBOX_WITH_VMSVGA
1944	struct fragment_caps fragment_caps;
1945	#endif
1946	enum wined3d_gl_vendor gl_vendor;
1947	enum wined3d_pci_vendor card_vendor;
1948	enum wined3d_pci_device device;
1949	GLint gl_max;
1950	GLfloat gl_floatv[2];
1951	unsigned i;
1952	#ifndef VBOX_WITH_VMSVGA
1953	HDC hdc;
1954	#endif
1955	unsigned int vidmem=0;
1956	DWORD gl_version;
1957	#ifndef VBOX_WITH_VMSVGA
1958	size_t len;
1959	#endif
1960
1961	TRACE_(d3d_caps)("(%p)\n", gl_info);
1962
1963	ENTER_GL();
1964
1965	VBOX_CHECK_GL_CALL(gl_renderer_str = (const char *)glGetString(GL_RENDERER));
1966	TRACE_(d3d_caps)("GL_RENDERER: %s.\n", debugstr_a(gl_renderer_str));
1967	if (!gl_renderer_str)
1968	{
1969	LEAVE_GL();
1970	ERR_(d3d_caps)("Received a NULL GL_RENDERER.\n");
1971	return FALSE;
1972	}
1973
1974	VBOX_CHECK_GL_CALL(gl_vendor_str = (const char *)glGetString(GL_VENDOR));
1975	TRACE_(d3d_caps)("GL_VENDOR: %s.\n", debugstr_a(gl_vendor_str));
1976	if (!gl_vendor_str)
1977	{
1978	LEAVE_GL();
1979	ERR_(d3d_caps)("Received a NULL GL_VENDOR.\n");
1980	return FALSE;
1981	}
1982
1983	/* Parse the GL_VERSION field into major and minor information */
1984	VBOX_CHECK_GL_CALL(gl_version_str = (const char *)glGetString(GL_VERSION));
1985	TRACE_(d3d_caps)("GL_VERSION: %s.\n", debugstr_a(gl_version_str));
1986	if (!gl_version_str)
1987	{
1988	LEAVE_GL();
1989	ERR_(d3d_caps)("Received a NULL GL_VERSION.\n");
1990	return FALSE;
1991	}
1992	gl_version = wined3d_parse_gl_version(gl_version_str);
1993
1994	/*
1995	* Initialize openGL extension related variables
1996	* with Default values
1997	*/
1998	memset(gl_info->supported, 0, sizeof(gl_info->supported));
1999	gl_info->limits.blends = 1;
2000	gl_info->limits.buffers = 1;
2001	gl_info->limits.textures = 1;
2002	gl_info->limits.fragment_samplers = 1;
2003	gl_info->limits.vertex_samplers = 0;
2004	gl_info->limits.combined_samplers = gl_info->limits.fragment_samplers + gl_info->limits.vertex_samplers;
2005	gl_info->limits.sampler_stages = 1;
2006	gl_info->limits.glsl_vs_float_constants = 0;
2007	gl_info->limits.glsl_ps_float_constants = 0;
2008	gl_info->limits.arb_vs_float_constants = 0;
2009	gl_info->limits.arb_vs_native_constants = 0;
2010	gl_info->limits.arb_vs_instructions = 0;
2011	gl_info->limits.arb_vs_temps = 0;
2012	gl_info->limits.arb_ps_float_constants = 0;
2013	gl_info->limits.arb_ps_local_constants = 0;
2014	gl_info->limits.arb_ps_instructions = 0;
2015	gl_info->limits.arb_ps_temps = 0;
2016
2017	/* Retrieve opengl defaults */
2018	VBOX_CHECK_GL_CALL(glGetIntegerv(GL_MAX_CLIP_PLANES, &gl_max));
2019	gl_info->limits.clipplanes = min(WINED3DMAXUSERCLIPPLANES, gl_max);
2020	TRACE_(d3d_caps)("ClipPlanes support - num Planes=%d\n", gl_max);
2021
2022	#ifdef VBOX_VMSVGA3D_DUAL_OPENGL_PROFILE
2023	glGetIntegerv(GL_MAX_LIGHTS, &gl_max);
2024	if (glGetError() != GL_NO_ERROR)
2025	{
2026	pVBoxShaderIf->pfnSwitchInitProfile(pVBoxShaderIf, true /fOtherProfile/);
2027	VBOX_CHECK_GL_CALL(glGetIntegerv(GL_MAX_LIGHTS, &gl_max));
2028	pVBoxShaderIf->pfnSwitchInitProfile(pVBoxShaderIf, false /fOtherProfile/);
2029	}
2030	#else
2031	VBOX_CHECK_GL_CALL(glGetIntegerv(GL_MAX_LIGHTS, &gl_max));
2032	#endif
2033	gl_info->limits.lights = gl_max;
2034	TRACE_(d3d_caps)("Lights support - max lights=%d\n", gl_max);
2035
2036	VBOX_CHECK_GL_CALL(glGetIntegerv(GL_MAX_TEXTURE_SIZE, &gl_max));
2037	gl_info->limits.texture_size = gl_max;
2038	TRACE_(d3d_caps)("Maximum texture size support - max texture size=%d\n", gl_max);
2039
2040	#ifdef VBOX_VMSVGA3D_DUAL_OPENGL_PROFILE
2041	glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, gl_floatv);
2042	if (glGetError() != GL_NO_ERROR)
2043	{
2044	pVBoxShaderIf->pfnSwitchInitProfile(pVBoxShaderIf, true /fOtherProfile/);
2045	VBOX_CHECK_GL_CALL(glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, gl_floatv));
2046	if (glGetError() != GL_NO_ERROR)
2047	gl_floatv[0] = gl_floatv[1] = 1;
2048	pVBoxShaderIf->pfnSwitchInitProfile(pVBoxShaderIf, false /fOtherProfile/);
2049	}
2050	#else
2051	VBOX_CHECK_GL_CALL(glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, gl_floatv));
2052	#endif
2053	gl_info->limits.pointsize_min = gl_floatv[0];
2054	gl_info->limits.pointsize_max = gl_floatv[1];
2055	TRACE_(d3d_caps)("Maximum point size support - max point size=%f\n", gl_floatv[1]);
2056
2057	/* Parse the gl supported features, in theory enabling parts of our code appropriately. */
2058	#ifndef VBOX_WITH_VMSVGA
2059	GL_Extensions = (const char *)glGetString(GL_EXTENSIONS);
2060	if (!GL_Extensions)
2061	{
2062	LEAVE_GL();
2063	ERR_(d3d_caps)("Received a NULL GL_EXTENSIONS.\n");
2064	return FALSE;
2065	}
2066
2067	LEAVE_GL();
2068
2069	TRACE_(d3d_caps)("GL_Extensions reported:\n");
2070	#endif
2071
2072	gl_info->supported[WINED3D_GL_EXT_NONE] = TRUE;
2073
2074	gl_info->supported[VBOX_SHARED_CONTEXTS] = TRUE;
2075
2076	#ifdef VBOX_WITH_VMSVGA
2077	{
2078	void *pvEnumCtx = NULL;
2079	char szCurExt[256];
2080	while (pVBoxShaderIf->pfnGetNextExtension(pVBoxShaderIf, &pvEnumCtx, szCurExt, sizeof(szCurExt), false /fOtherProfile/))
2081	check_gl_extension(gl_info, szCurExt);
2082
2083	/* The cheap way out. */
2084	pvEnumCtx = NULL;
2085	while (pVBoxShaderIf->pfnGetNextExtension(pVBoxShaderIf, &pvEnumCtx, szCurExt, sizeof(szCurExt), true /fOtherProfile/))
2086	check_gl_extension(gl_info, szCurExt);
2087	}
2088	#else /* !VBOX_WITH_VMSVGA */
2089	while (*GL_Extensions)
2090	{
2091	const char *start;
2092	char current_ext[256];
2093
2094	while (isspace(*GL_Extensions)) ++GL_Extensions;
2095	start = GL_Extensions;
2096	while (!isspace(GL_Extensions) && GL_Extensions) ++GL_Extensions;
2097
2098	len = GL_Extensions - start;
2099	if (!len \|\| len >= sizeof(current_ext)) continue;
2100
2101	memcpy(current_ext, start, len);
2102	current_ext[len] = '\0';
2103	TRACE_(d3d_caps)("- %s\n", debugstr_a(current_ext));
2104
2105	for (i = 0; i < (sizeof(EXTENSION_MAP) / sizeof(*EXTENSION_MAP)); ++i)
2106	{
2107	if (!strcmp(current_ext, EXTENSION_MAP[i].extension_string))
2108	{
2109	TRACE_(d3d_caps)(" FOUND: %s support.\n", EXTENSION_MAP[i].extension_string);
2110	gl_info->supported[EXTENSION_MAP[i].extension] = TRUE;
2111	break;
2112	}
2113	}
2114	}
2115	#endif /* !VBOX_WITH_VMSVGA */
2116
2117	#ifdef VBOX_WITH_VMSVGA
2118	# ifdef RT_OS_WINDOWS
2119	# define OGLGETPROCADDRESS wglGetProcAddress
2120	# elif RT_OS_DARWIN
2121	# define OGLGETPROCADDRESS(x) MyNSGLGetProcAddress(x)
2122	# else
2123	extern void (glXGetProcAddress(const GLubyte procname))( void );
2124	# define OGLGETPROCADDRESS(x) glXGetProcAddress((const GLubyte *)x)
2125	# endif
2126	#endif
2127
2128	/* Now work out what GL support this card really has */
2129	#define USE_GL_FUNC(type, pfn, ext, replace) \
2130	{ \
2131	DWORD ver = ver_for_ext(ext); \
2132	if (gl_info->supported[ext]) gl_info->pfn = (type)OGLGETPROCADDRESS(#pfn); \
2133	else if (ver && ver <= gl_version) gl_info->pfn = (type)OGLGETPROCADDRESS(#replace); \
2134	else gl_info->pfn = NULL; \
2135	}
2136	GL_EXT_FUNCS_GEN;
2137	#undef USE_GL_FUNC
2138
2139	#ifndef VBOX_WITH_VMSVGA
2140	#define USE_GL_FUNC(type, pfn, ext, replace) gl_info->pfn = (type)OGLGETPROCADDRESS(#pfn);
2141	WGL_EXT_FUNCS_GEN;
2142	#undef USE_GL_FUNC
2143	#endif
2144
2145	ENTER_GL();
2146
2147	/* Now mark all the extensions supported which are included in the opengl core version. Do this after
2148	* loading the functions, otherwise the code above will load the extension entry points instead of the
2149	* core functions, which may not work. */
2150	for (i = 0; i < (sizeof(EXTENSION_MAP) / sizeof(*EXTENSION_MAP)); ++i)
2151	{
2152	if (!gl_info->supported[EXTENSION_MAP[i].extension]
2153	&& EXTENSION_MAP[i].version <= gl_version && EXTENSION_MAP[i].version)
2154	{
2155	TRACE_(d3d_caps)(" GL CORE: %s support.\n", EXTENSION_MAP[i].extension_string);
2156	gl_info->supported[EXTENSION_MAP[i].extension] = TRUE;
2157	}
2158	}
2159
2160	if (gl_info->supported[APPLE_FENCE])
2161	{
2162	/* GL_NV_fence and GL_APPLE_fence provide the same functionality basically.
2163	* The apple extension interacts with some other apple exts. Disable the NV
2164	* extension if the apple one is support to prevent confusion in other parts
2165	* of the code. */
2166	gl_info->supported[NV_FENCE] = FALSE;
2167	}
2168	if (gl_info->supported[APPLE_FLOAT_PIXELS])
2169	{
2170	/* GL_APPLE_float_pixels == GL_ARB_texture_float + GL_ARB_half_float_pixel
2171	*
2172	* The enums are the same:
2173	* GL_RGBA16F_ARB = GL_RGBA_FLOAT16_APPLE = 0x881A
2174	* GL_RGB16F_ARB = GL_RGB_FLOAT16_APPLE = 0x881B
2175	* GL_RGBA32F_ARB = GL_RGBA_FLOAT32_APPLE = 0x8814
2176	* GL_RGB32F_ARB = GL_RGB_FLOAT32_APPLE = 0x8815
2177	* GL_HALF_FLOAT_ARB = GL_HALF_APPLE = 0x140B
2178	*/
2179	if (!gl_info->supported[ARB_TEXTURE_FLOAT])
2180	{
2181	TRACE_(d3d_caps)(" IMPLIED: GL_ARB_texture_float support(from GL_APPLE_float_pixels.\n");
2182	gl_info->supported[ARB_TEXTURE_FLOAT] = TRUE;
2183	}
2184	if (!gl_info->supported[ARB_HALF_FLOAT_PIXEL])
2185	{
2186	TRACE_(d3d_caps)(" IMPLIED: GL_ARB_half_float_pixel support(from GL_APPLE_float_pixels.\n");
2187	gl_info->supported[ARB_HALF_FLOAT_PIXEL] = TRUE;
2188	}
2189	}
2190	if (gl_info->supported[ARB_MAP_BUFFER_RANGE])
2191	{
2192	/* GL_ARB_map_buffer_range and GL_APPLE_flush_buffer_range provide the same
2193	* functionality. Prefer the ARB extension */
2194	gl_info->supported[APPLE_FLUSH_BUFFER_RANGE] = FALSE;
2195	}
2196	if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
2197	{
2198	TRACE_(d3d_caps)(" IMPLIED: NVIDIA (NV) Texture Gen Reflection support.\n");
2199	gl_info->supported[NV_TEXGEN_REFLECTION] = TRUE;
2200	}
2201	if (!gl_info->supported[ARB_DEPTH_CLAMP] && gl_info->supported[NV_DEPTH_CLAMP])
2202	{
2203	TRACE_(d3d_caps)(" IMPLIED: ARB_depth_clamp support (by NV_depth_clamp).\n");
2204	gl_info->supported[ARB_DEPTH_CLAMP] = TRUE;
2205	}
2206	if (!gl_info->supported[ARB_VERTEX_ARRAY_BGRA] && gl_info->supported[EXT_VERTEX_ARRAY_BGRA])
2207	{
2208	TRACE_(d3d_caps)(" IMPLIED: ARB_vertex_array_bgra support (by EXT_vertex_array_bgra).\n");
2209	gl_info->supported[ARB_VERTEX_ARRAY_BGRA] = TRUE;
2210	}
2211	if (gl_info->supported[NV_TEXTURE_SHADER2])
2212	{
2213	if (gl_info->supported[NV_REGISTER_COMBINERS])
2214	{
2215	/* Also disable ATI_FRAGMENT_SHADER if register combiners and texture_shader2
2216	* are supported. The nv extensions provide the same functionality as the
2217	* ATI one, and a bit more(signed pixelformats). */
2218	gl_info->supported[ATI_FRAGMENT_SHADER] = FALSE;
2219	}
2220	}
2221
2222	if (gl_info->supported[NV_REGISTER_COMBINERS])
2223	{
2224	VBOX_CHECK_GL_CALL(glGetIntegerv(GL_MAX_GENERAL_COMBINERS_NV, &gl_max));
2225	gl_info->limits.general_combiners = gl_max;
2226	TRACE_(d3d_caps)("Max general combiners: %d.\n", gl_max);
2227	}
2228	if (gl_info->supported[ARB_DRAW_BUFFERS])
2229	{
2230	VBOX_CHECK_GL_CALL(glGetIntegerv(GL_MAX_DRAW_BUFFERS_ARB, &gl_max));
2231	gl_info->limits.buffers = gl_max;
2232	TRACE_(d3d_caps)("Max draw buffers: %u.\n", gl_max);
2233	}
2234	if (gl_info->supported[ARB_MULTITEXTURE])
2235	{
2236	#ifdef VBOX_VMSVGA3D_DUAL_OPENGL_PROFILE
2237	glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &gl_max);
2238	if (glGetError() != GL_NO_ERROR)
2239	VBOX_CHECK_GL_CALL(glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &gl_max));
2240	#else
2241	VBOX_CHECK_GL_CALL(glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &gl_max));
2242	#endif
2243	gl_info->limits.textures = min(MAX_TEXTURES, gl_max);
2244	TRACE_(d3d_caps)("Max textures: %d.\n", gl_info->limits.textures);
2245
2246	if (gl_info->supported[ARB_FRAGMENT_PROGRAM])
2247	{
2248	GLint tmp;
2249	VBOX_CHECK_GL_CALL(glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS_ARB, &tmp));
2250	gl_info->limits.fragment_samplers = min(MAX_FRAGMENT_SAMPLERS, tmp);
2251	}
2252	else
2253	{
2254	gl_info->limits.fragment_samplers = max(gl_info->limits.fragment_samplers, (UINT)gl_max);
2255	}
2256	TRACE_(d3d_caps)("Max fragment samplers: %d.\n", gl_info->limits.fragment_samplers);
2257
2258	if (gl_info->supported[ARB_VERTEX_SHADER])
2259	{
2260	GLint tmp;
2261	VBOX_CHECK_GL_CALL(glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB, &tmp));
2262	gl_info->limits.vertex_samplers = tmp;
2263	VBOX_CHECK_GL_CALL(glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB, &tmp));
2264	gl_info->limits.combined_samplers = tmp;
2265
2266	/* Loading GLSL sampler uniforms is much simpler if we can assume that the sampler setup
2267	* is known at shader link time. In a vertex shader + pixel shader combination this isn't
2268	* an issue because then the sampler setup only depends on the two shaders. If a pixel
2269	* shader is used with fixed function vertex processing we're fine too because fixed function
2270	* vertex processing doesn't use any samplers. If fixed function fragment processing is
2271	* used we have to make sure that all vertex sampler setups are valid together with all
2272	* possible fixed function fragment processing setups. This is true if vsamplers + MAX_TEXTURES
2273	* <= max_samplers. This is true on all d3d9 cards that support vtf(gf 6 and gf7 cards).
2274	* dx9 radeon cards do not support vertex texture fetch. DX10 cards have 128 samplers, and
2275	* dx9 is limited to 8 fixed function texture stages and 4 vertex samplers. DX10 does not have
2276	* a fixed function pipeline anymore.
2277	*
2278	* So this is just a check to check that our assumption holds true. If not, write a warning
2279	* and reduce the number of vertex samplers or probably disable vertex texture fetch. */
2280	if (gl_info->limits.vertex_samplers && gl_info->limits.combined_samplers < 12
2281	&& MAX_TEXTURES + gl_info->limits.vertex_samplers > gl_info->limits.combined_samplers)
2282	{
2283	FIXME("OpenGL implementation supports %u vertex samplers and %u total samplers.\n",
2284	gl_info->limits.vertex_samplers, gl_info->limits.combined_samplers);
2285	FIXME("Expected vertex samplers + MAX_TEXTURES(=8) > combined_samplers.\n");
2286	if (gl_info->limits.combined_samplers > MAX_TEXTURES)
2287	gl_info->limits.vertex_samplers = gl_info->limits.combined_samplers - MAX_TEXTURES;
2288	else
2289	gl_info->limits.vertex_samplers = 0;
2290	}
2291	}
2292	else
2293	{
2294	gl_info->limits.combined_samplers = gl_info->limits.fragment_samplers;
2295	}
2296	TRACE_(d3d_caps)("Max vertex samplers: %u.\n", gl_info->limits.vertex_samplers);
2297	TRACE_(d3d_caps)("Max combined samplers: %u.\n", gl_info->limits.combined_samplers);
2298	}
2299	if (gl_info->supported[ARB_VERTEX_BLEND])
2300	{
2301	#ifdef VBOX_VMSVGA3D_DUAL_OPENGL_PROFILE
2302	glGetIntegerv(GL_MAX_VERTEX_UNITS_ARB, &gl_max);
2303	if (glGetError() != GL_NO_ERROR)
2304	{
2305	pVBoxShaderIf->pfnSwitchInitProfile(pVBoxShaderIf, true /fOtherProfile/);
2306	VBOX_CHECK_GL_CALL(glGetIntegerv(GL_MAX_VERTEX_UNITS_ARB, &gl_max));
2307	pVBoxShaderIf->pfnSwitchInitProfile(pVBoxShaderIf, false /fOtherProfile/);
2308	}
2309	#else
2310	VBOX_CHECK_GL_CALL(glGetIntegerv(GL_MAX_VERTEX_UNITS_ARB, &gl_max));
2311	#endif
2312	gl_info->limits.blends = gl_max;
2313	TRACE_(d3d_caps)("Max blends: %u.\n", gl_info->limits.blends);
2314	}
2315	if (gl_info->supported[EXT_TEXTURE3D])
2316	{
2317	VBOX_CHECK_GL_CALL(glGetIntegerv(GL_MAX_3D_TEXTURE_SIZE_EXT, &gl_max));
2318	gl_info->limits.texture3d_size = gl_max;
2319	TRACE_(d3d_caps)("Max texture3D size: %d.\n", gl_info->limits.texture3d_size);
2320	}
2321	if (gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC])
2322	{
2323	VBOX_CHECK_GL_CALL(glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &gl_max));
2324	gl_info->limits.anisotropy = gl_max;
2325	TRACE_(d3d_caps)("Max anisotropy: %d.\n", gl_info->limits.anisotropy);
2326	}
2327	if (gl_info->supported[ARB_FRAGMENT_PROGRAM])
2328	{
2329	#ifdef VBOX_VMSVGA3D_DUAL_OPENGL_PROFILE
2330	GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max));
2331	if (glGetError() != GL_NO_ERROR)
2332	pVBoxShaderIf->pfnSwitchInitProfile(pVBoxShaderIf, true /fOtherProfile/);
2333	#endif
2334	VBOX_CHECK_GL_CALL(GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max)));
2335	gl_info->limits.arb_ps_float_constants = gl_max;
2336	TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM float constants: %d.\n", gl_info->limits.arb_ps_float_constants);
2337	VBOX_CHECK_GL_CALL(GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB, &gl_max)));
2338	gl_info->limits.arb_ps_native_constants = gl_max;
2339	TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM native float constants: %d.\n",
2340	gl_info->limits.arb_ps_native_constants);
2341	VBOX_CHECK_GL_CALL(GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, &gl_max)));
2342	gl_info->limits.arb_ps_temps = gl_max;
2343	TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM native temporaries: %d.\n", gl_info->limits.arb_ps_temps);
2344	VBOX_CHECK_GL_CALL(GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, &gl_max)));
2345	gl_info->limits.arb_ps_instructions = gl_max;
2346	TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM native instructions: %d.\n", gl_info->limits.arb_ps_instructions);
2347	VBOX_CHECK_GL_CALL(GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB, &gl_max)));
2348	gl_info->limits.arb_ps_local_constants = gl_max;
2349	TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM local parameters: %d.\n", gl_info->limits.arb_ps_instructions);
2350	#ifdef VBOX_VMSVGA3D_DUAL_OPENGL_PROFILE
2351	pVBoxShaderIf->pfnSwitchInitProfile(pVBoxShaderIf, false /fOtherProfile/);
2352	#endif
2353	}
2354	if (gl_info->supported[ARB_VERTEX_PROGRAM])
2355	{
2356	#ifdef VBOX_VMSVGA3D_DUAL_OPENGL_PROFILE
2357	GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max));
2358	if (glGetError() != GL_NO_ERROR)
2359	pVBoxShaderIf->pfnSwitchInitProfile(pVBoxShaderIf, true /fOtherProfile/);
2360	#endif
2361	VBOX_CHECK_GL_CALL(GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max)));
2362	gl_info->limits.arb_vs_float_constants = gl_max;
2363	TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM float constants: %d.\n", gl_info->limits.arb_vs_float_constants);
2364	VBOX_CHECK_GL_CALL(GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB, &gl_max)));
2365	gl_info->limits.arb_vs_native_constants = gl_max;
2366	TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM native float constants: %d.\n",
2367	gl_info->limits.arb_vs_native_constants);
2368	VBOX_CHECK_GL_CALL(GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, &gl_max)));
2369	gl_info->limits.arb_vs_temps = gl_max;
2370	TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM native temporaries: %d.\n", gl_info->limits.arb_vs_temps);
2371	VBOX_CHECK_GL_CALL(GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, &gl_max)));
2372	gl_info->limits.arb_vs_instructions = gl_max;
2373	TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM native instructions: %d.\n", gl_info->limits.arb_vs_instructions);
2374	#ifdef VBOX_VMSVGA3D_DUAL_OPENGL_PROFILE
2375	pVBoxShaderIf->pfnSwitchInitProfile(pVBoxShaderIf, false /fOtherProfile/);
2376	#endif
2377	#ifndef VBOX_WITH_VMSVGA
2378	if (test_arb_vs_offset_limit(gl_info)) gl_info->quirks \|= WINED3D_QUIRK_ARB_VS_OFFSET_LIMIT;
2379	#endif
2380	}
2381	if (gl_info->supported[ARB_VERTEX_SHADER])
2382	{
2383	VBOX_CHECK_GL_CALL(glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB, &gl_max));
2384	gl_info->limits.glsl_vs_float_constants = gl_max / 4;
2385	#ifdef VBOX_WITH_WDDM
2386	/* AFAICT the " / 4" here comes from that we're going to use the glsl_vs/ps_float_constants to create vec4 arrays,
2387	* thus each array element has 4 components, so the actual number of vec4 arrays is GL_MAX_VERTEX/FRAGMENT_UNIFORM_COMPONENTS_ARB / 4
2388	* win8 Aero won't properly work with this constant < 256 in any way,
2389	* while Intel drivers I've encountered this problem with supports vec4 arrays of size > GL_MAX_VERTEX/FRAGMENT_UNIFORM_COMPONENTS_ARB / 4
2390	* so use it here.
2391	* @todo: add logging
2392	* @todo: perhaps should be movet to quirks?
2393	* */
2394	if (gl_info->limits.glsl_vs_float_constants < 256 && gl_max >= 256)
2395	{
2396	DWORD dwVersion = GetVersion();
2397	DWORD dwMajor = (DWORD)(LOBYTE(LOWORD(dwVersion)));
2398	DWORD dwMinor = (DWORD)(HIBYTE(LOWORD(dwVersion)));
2399	/* tmp workaround Win8 Aero requirement for 256 */
2400	if (dwMajor > 6 \|\| dwMinor > 1)
2401	{
2402	gl_info->limits.glsl_vs_float_constants = 256;
2403	}
2404	}
2405	#endif
2406	TRACE_(d3d_caps)("Max ARB_VERTEX_SHADER float constants: %u.\n", gl_info->limits.glsl_vs_float_constants);
2407	}
2408	if (gl_info->supported[ARB_FRAGMENT_SHADER])
2409	{
2410	VBOX_CHECK_GL_CALL(glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB, &gl_max));
2411	gl_info->limits.glsl_ps_float_constants = gl_max / 4;
2412	#ifdef VBOX_WITH_WDDM
2413	/* AFAICT the " / 4" here comes from that we're going to use the glsl_vs/ps_float_constants to create vec4 arrays,
2414	* thus each array element has 4 components, so the actual number of vec4 arrays is GL_MAX_VERTEX/FRAGMENT_UNIFORM_COMPONENTS_ARB / 4
2415	* win8 Aero won't properly work with this constant < 256 in any way,
2416	* while Intel drivers I've encountered this problem with supports vec4 arrays of size > GL_MAX_VERTEX/FRAGMENT_UNIFORM_COMPONENTS_ARB / 4
2417	* so use it here.
2418	* @todo: add logging
2419	* @todo: perhaps should be movet to quirks?
2420	* */
2421	if (gl_info->limits.glsl_ps_float_constants < 256 && gl_max >= 256)
2422	{
2423	DWORD dwVersion = GetVersion();
2424	DWORD dwMajor = (DWORD)(LOBYTE(LOWORD(dwVersion)));
2425	DWORD dwMinor = (DWORD)(HIBYTE(LOWORD(dwVersion)));
2426	/* tmp workaround Win8 Aero requirement for 256 */
2427	if (dwMajor > 6 \|\| dwMinor > 1)
2428	{
2429	gl_info->limits.glsl_ps_float_constants = 256;
2430	}
2431	}
2432	#endif
2433	TRACE_(d3d_caps)("Max ARB_FRAGMENT_SHADER float constants: %u.\n", gl_info->limits.glsl_ps_float_constants);
2434	#ifdef VBOX_VMSVGA3D_DUAL_OPENGL_PROFILE
2435	glGetIntegerv(GL_MAX_VARYING_FLOATS_ARB, &gl_max);
2436	if (glGetError() != GL_NO_ERROR)
2437	{
2438	pVBoxShaderIf->pfnSwitchInitProfile(pVBoxShaderIf, true /fOtherProfile/);
2439	VBOX_CHECK_GL_CALL(glGetIntegerv(GL_MAX_VARYING_FLOATS_ARB, &gl_max));
2440	pVBoxShaderIf->pfnSwitchInitProfile(pVBoxShaderIf, false /fOtherProfile/);
2441	}
2442	#else
2443	VBOX_CHECK_GL_CALL(glGetIntegerv(GL_MAX_VARYING_FLOATS_ARB, &gl_max));
2444	#endif
2445	gl_info->limits.glsl_varyings = gl_max;
2446	TRACE_(d3d_caps)("Max GLSL varyings: %u (%u 4 component varyings).\n", gl_max, gl_max / 4);
2447	}
2448	if (gl_info->supported[ARB_SHADING_LANGUAGE_100])
2449	{
2450	const char str = (const char )glGetString(GL_SHADING_LANGUAGE_VERSION_ARB);
2451	unsigned int major, minor;
2452
2453	TRACE_(d3d_caps)("GLSL version string: %s.\n", debugstr_a(str));
2454
2455	/* The format of the GLSL version string is "major.minor[.release] [vendor info]". */
2456	sscanf(str, "%u.%u", &major, &minor);
2457	gl_info->glsl_version = MAKEDWORD_VERSION(major, minor);
2458	}
2459	if (gl_info->supported[NV_LIGHT_MAX_EXPONENT])
2460	{
2461	#ifdef VBOX_VMSVGA3D_DUAL_OPENGL_PROFILE
2462	glGetFloatv(GL_MAX_SHININESS_NV, &gl_info->limits.shininess);
2463	if (glGetError() != GL_NO_ERROR)
2464	{
2465	pVBoxShaderIf->pfnSwitchInitProfile(pVBoxShaderIf, true /fOtherProfile/);
2466	VBOX_CHECK_GL_CALL(glGetFloatv(GL_MAX_SHININESS_NV, &gl_info->limits.shininess));
2467	pVBoxShaderIf->pfnSwitchInitProfile(pVBoxShaderIf, false /fOtherProfile/);
2468	}
2469	#else
2470	VBOX_CHECK_GL_CALL(glGetFloatv(GL_MAX_SHININESS_NV, &gl_info->limits.shininess));
2471	#endif
2472	}
2473	else
2474	{
2475	gl_info->limits.shininess = 128.0f;
2476	}
2477	if (gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO])
2478	{
2479	/* If we have full NP2 texture support, disable
2480	* GL_ARB_texture_rectangle because we will never use it.
2481	* This saves a few redundant glDisable calls. */
2482	gl_info->supported[ARB_TEXTURE_RECTANGLE] = FALSE;
2483	}
2484	if (gl_info->supported[ATI_FRAGMENT_SHADER])
2485	{
2486	/* Disable NV_register_combiners and fragment shader if this is supported.
2487	* generally the NV extensions are preferred over the ATI ones, and this
2488	* extension is disabled if register_combiners and texture_shader2 are both
2489	* supported. So we reach this place only if we have incomplete NV dxlevel 8
2490	* fragment processing support. */
2491	gl_info->supported[NV_REGISTER_COMBINERS] = FALSE;
2492	gl_info->supported[NV_REGISTER_COMBINERS2] = FALSE;
2493	gl_info->supported[NV_TEXTURE_SHADER] = FALSE;
2494	gl_info->supported[NV_TEXTURE_SHADER2] = FALSE;
2495	}
2496	if (gl_info->supported[NV_HALF_FLOAT])
2497	{
2498	/* GL_ARB_half_float_vertex is a subset of GL_NV_half_float. */
2499	gl_info->supported[ARB_HALF_FLOAT_VERTEX] = TRUE;
2500	}
2501	if (gl_info->supported[ARB_POINT_SPRITE])
2502	{
2503	gl_info->limits.point_sprite_units = gl_info->limits.textures;
2504	}
2505	else
2506	{
2507	gl_info->limits.point_sprite_units = 0;
2508	}
2509	#ifndef VBOX_WITH_VMSVGA
2510	checkGLcall("extension detection");
2511	#endif
2512	LEAVE_GL();
2513
2514	#ifndef VBOX_WITH_VMSVGA
2515	adapter->fragment_pipe = select_fragment_implementation(adapter);
2516	#endif
2517	adapter->shader_backend = select_shader_backend(adapter);
2518	#ifndef VBOX_WITH_VMSVGA
2519	adapter->blitter = select_blit_implementation(adapter);
2520
2521	adapter->fragment_pipe->get_caps(gl_info, &fragment_caps);
2522	gl_info->limits.texture_stages = fragment_caps.MaxTextureBlendStages;
2523	TRACE_(d3d_caps)("Max texture stages: %u.\n", gl_info->limits.texture_stages);
2524
2525	/* In some cases the number of texture stages can be larger than the number
2526	* of samplers. The GF4 for example can use only 2 samplers (no fragment
2527	* shaders), but 8 texture stages (register combiners). */
2528	gl_info->limits.sampler_stages = max(gl_info->limits.fragment_samplers, gl_info->limits.texture_stages);
2529	#endif
2530
2531	if (gl_info->supported[ARB_FRAMEBUFFER_OBJECT])
2532	{
2533	gl_info->fbo_ops.glIsRenderbuffer = gl_info->glIsRenderbuffer;
2534	gl_info->fbo_ops.glBindRenderbuffer = gl_info->glBindRenderbuffer;
2535	gl_info->fbo_ops.glDeleteRenderbuffers = gl_info->glDeleteRenderbuffers;
2536	gl_info->fbo_ops.glGenRenderbuffers = gl_info->glGenRenderbuffers;
2537	gl_info->fbo_ops.glRenderbufferStorage = gl_info->glRenderbufferStorage;
2538	gl_info->fbo_ops.glRenderbufferStorageMultisample = gl_info->glRenderbufferStorageMultisample;
2539	gl_info->fbo_ops.glGetRenderbufferParameteriv = gl_info->glGetRenderbufferParameteriv;
2540	gl_info->fbo_ops.glIsFramebuffer = gl_info->glIsFramebuffer;
2541	gl_info->fbo_ops.glBindFramebuffer = gl_info->glBindFramebuffer;
2542	gl_info->fbo_ops.glDeleteFramebuffers = gl_info->glDeleteFramebuffers;
2543	gl_info->fbo_ops.glGenFramebuffers = gl_info->glGenFramebuffers;
2544	gl_info->fbo_ops.glCheckFramebufferStatus = gl_info->glCheckFramebufferStatus;
2545	gl_info->fbo_ops.glFramebufferTexture1D = gl_info->glFramebufferTexture1D;
2546	gl_info->fbo_ops.glFramebufferTexture2D = gl_info->glFramebufferTexture2D;
2547	gl_info->fbo_ops.glFramebufferTexture3D = gl_info->glFramebufferTexture3D;
2548	gl_info->fbo_ops.glFramebufferRenderbuffer = gl_info->glFramebufferRenderbuffer;
2549	gl_info->fbo_ops.glGetFramebufferAttachmentParameteriv = gl_info->glGetFramebufferAttachmentParameteriv;
2550	gl_info->fbo_ops.glBlitFramebuffer = gl_info->glBlitFramebuffer;
2551	gl_info->fbo_ops.glGenerateMipmap = gl_info->glGenerateMipmap;
2552	}
2553	else
2554	{
2555	if (gl_info->supported[EXT_FRAMEBUFFER_OBJECT])
2556	{
2557	gl_info->fbo_ops.glIsRenderbuffer = gl_info->glIsRenderbufferEXT;
2558	gl_info->fbo_ops.glBindRenderbuffer = gl_info->glBindRenderbufferEXT;
2559	gl_info->fbo_ops.glDeleteRenderbuffers = gl_info->glDeleteRenderbuffersEXT;
2560	gl_info->fbo_ops.glGenRenderbuffers = gl_info->glGenRenderbuffersEXT;
2561	gl_info->fbo_ops.glRenderbufferStorage = gl_info->glRenderbufferStorageEXT;
2562	gl_info->fbo_ops.glGetRenderbufferParameteriv = gl_info->glGetRenderbufferParameterivEXT;
2563	gl_info->fbo_ops.glIsFramebuffer = gl_info->glIsFramebufferEXT;
2564	gl_info->fbo_ops.glBindFramebuffer = gl_info->glBindFramebufferEXT;
2565	gl_info->fbo_ops.glDeleteFramebuffers = gl_info->glDeleteFramebuffersEXT;
2566	gl_info->fbo_ops.glGenFramebuffers = gl_info->glGenFramebuffersEXT;
2567	gl_info->fbo_ops.glCheckFramebufferStatus = gl_info->glCheckFramebufferStatusEXT;
2568	gl_info->fbo_ops.glFramebufferTexture1D = gl_info->glFramebufferTexture1DEXT;
2569	gl_info->fbo_ops.glFramebufferTexture2D = gl_info->glFramebufferTexture2DEXT;
2570	gl_info->fbo_ops.glFramebufferTexture3D = gl_info->glFramebufferTexture3DEXT;
2571	gl_info->fbo_ops.glFramebufferRenderbuffer = gl_info->glFramebufferRenderbufferEXT;
2572	gl_info->fbo_ops.glGetFramebufferAttachmentParameteriv = gl_info->glGetFramebufferAttachmentParameterivEXT;
2573	gl_info->fbo_ops.glGenerateMipmap = gl_info->glGenerateMipmapEXT;
2574	}
2575	#ifndef VBOX_WITH_VMSVGA
2576	else if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
2577	{
2578	WARN_(d3d_caps)("Framebuffer objects not supported, falling back to backbuffer offscreen rendering mode.\n");
2579	wined3d_settings.offscreen_rendering_mode = ORM_BACKBUFFER;
2580	}
2581	#endif
2582	if (gl_info->supported[EXT_FRAMEBUFFER_BLIT])
2583	{
2584	gl_info->fbo_ops.glBlitFramebuffer = gl_info->glBlitFramebufferEXT;
2585	}
2586	if (gl_info->supported[EXT_FRAMEBUFFER_MULTISAMPLE])
2587	{
2588	gl_info->fbo_ops.glRenderbufferStorageMultisample = gl_info->glRenderbufferStorageMultisampleEXT;
2589	}
2590	}
2591
2592	#ifndef VBOX_WITH_VMSVGA
2593	/* MRTs are currently only supported when FBOs are used. */
2594	if (wined3d_settings.offscreen_rendering_mode != ORM_FBO)
2595	{
2596	gl_info->limits.buffers = 1;
2597	}
2598	#endif
2599	gl_vendor = wined3d_guess_gl_vendor(gl_info, gl_vendor_str, gl_renderer_str);
2600	card_vendor = wined3d_guess_card_vendor(gl_vendor_str, gl_renderer_str);
2601	TRACE_(d3d_caps)("found GL_VENDOR (%s)->(0x%04x/0x%04x)\n", debugstr_a(gl_vendor_str), gl_vendor, card_vendor);
2602
2603	device = wined3d_guess_card(gl_info, gl_renderer_str, &gl_vendor, &card_vendor, &vidmem);
2604	TRACE_(d3d_caps)("FOUND (fake) card: 0x%x (vendor id), 0x%x (device id)\n", card_vendor, device);
2605
2606	/* If we have an estimate use it, else default to 64MB; */
2607	if(vidmem)
2608	gl_info->vidmem = vidmem10241024; /* convert from MBs to bytes */
2609	else
2610	gl_info->vidmem = WINE_DEFAULT_VIDMEM;
2611
2612	gl_info->wrap_lookup[WINED3DTADDRESS_WRAP - WINED3DTADDRESS_WRAP] = GL_REPEAT;
2613	gl_info->wrap_lookup[WINED3DTADDRESS_MIRROR - WINED3DTADDRESS_WRAP] =
2614	gl_info->supported[ARB_TEXTURE_MIRRORED_REPEAT] ? GL_MIRRORED_REPEAT_ARB : GL_REPEAT;
2615	gl_info->wrap_lookup[WINED3DTADDRESS_CLAMP - WINED3DTADDRESS_WRAP] = GL_CLAMP_TO_EDGE;
2616	gl_info->wrap_lookup[WINED3DTADDRESS_BORDER - WINED3DTADDRESS_WRAP] =
2617	gl_info->supported[ARB_TEXTURE_BORDER_CLAMP] ? GL_CLAMP_TO_BORDER_ARB : GL_REPEAT;
2618	gl_info->wrap_lookup[WINED3DTADDRESS_MIRRORONCE - WINED3DTADDRESS_WRAP] =
2619	gl_info->supported[ATI_TEXTURE_MIRROR_ONCE] ? GL_MIRROR_CLAMP_TO_EDGE_ATI : GL_REPEAT;
2620
2621	#ifndef VBOX_WITH_VMSVGA
2622	/* Make sure there's an active HDC else the WGL extensions will fail */
2623	hdc = pwglGetCurrentDC();
2624	if (hdc) {
2625	/* Not all GL drivers might offer WGL extensions e.g. VirtualBox */
2626	if(GL_EXTCALL(wglGetExtensionsStringARB))
2627	WGL_Extensions = GL_EXTCALL(wglGetExtensionsStringARB(hdc));
2628
2629	if (NULL == WGL_Extensions) {
2630	ERR(" WGL_Extensions returns NULL\n");
2631	} else {
2632	TRACE_(d3d_caps)("WGL_Extensions reported:\n");
2633	while (*WGL_Extensions != 0x00) {
2634	const char *Start;
2635	char ThisExtn[256];
2636
2637	while (isspace(*WGL_Extensions)) WGL_Extensions++;
2638	Start = WGL_Extensions;
2639	while (!isspace(WGL_Extensions) && WGL_Extensions != 0x00) {
2640	WGL_Extensions++;
2641	}
2642
2643	len = WGL_Extensions - Start;
2644	if (len == 0 \|\| len >= sizeof(ThisExtn))
2645	continue;
2646
2647	memcpy(ThisExtn, Start, len);
2648	ThisExtn[len] = '\0';
2649	TRACE_(d3d_caps)("- %s\n", debugstr_a(ThisExtn));
2650
2651	if (!strcmp(ThisExtn, "WGL_ARB_pixel_format")) {
2652	gl_info->supported[WGL_ARB_PIXEL_FORMAT] = TRUE;
2653	TRACE_(d3d_caps)("FOUND: WGL_ARB_pixel_format support\n");
2654	}
2655	if (!strcmp(ThisExtn, "WGL_WINE_pixel_format_passthrough")) {
2656	gl_info->supported[WGL_WINE_PIXEL_FORMAT_PASSTHROUGH] = TRUE;
2657	TRACE_(d3d_caps)("FOUND: WGL_WINE_pixel_format_passthrough support\n");
2658	}
2659	}
2660	}
2661	}
2662	#endif
2663
2664	fixup_extensions(gl_info, gl_renderer_str, gl_vendor, card_vendor, device);
2665	#ifndef VBOX_WITH_VMSVGA
2666	init_driver_info(driver_info, card_vendor, device);
2667	add_gl_compat_wrappers(gl_info);
2668	#endif
2669
2670	return TRUE;
2671	}
2672

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/VBox/Devices/Graphics/shaderlib/directx.c@ 64572

以其他格式下載: