projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[REACTOS]
[reactos.git] / reactos / dll / directx / wine / wined3d / directx.c
1 /*
2 * Copyright 2002-2004 Jason Edmeades
3 * Copyright 2003-2004 Raphael Junqueira
4 * Copyright 2004 Christian Costa
5 * Copyright 2005 Oliver Stieber
6 * Copyright 2007-2008 Stefan Dösinger for CodeWeavers
7 * Copyright 2009-2011 Henri Verbeet for CodeWeavers
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 */
23
24 #include "wined3d_private.h"
25 #include <winternl.h>
26 #include <winnls.h>
27
28 #include <wine/unicode.h>
29
30 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
31 WINE_DECLARE_DEBUG_CHANNEL(d3d_perf);
32
33 #define WINE_DEFAULT_VIDMEM (64 * 1024 * 1024)
34 #define DEFAULT_REFRESH_RATE 0
35
36 /* The driver names reflect the lowest GPU supported
37 * by a certain driver, so DRIVER_AMD_R300 supports
38 * R3xx, R4xx and R5xx GPUs. */
39 enum wined3d_display_driver
40 {
41 DRIVER_AMD_RAGE_128PRO,
42 DRIVER_AMD_R100,
43 DRIVER_AMD_R300,
44 DRIVER_AMD_R600,
45 DRIVER_INTEL_GMA800,
46 DRIVER_INTEL_GMA900,
47 DRIVER_INTEL_GMA950,
48 DRIVER_INTEL_GMA3000,
49 DRIVER_NVIDIA_TNT,
50 DRIVER_NVIDIA_GEFORCE2MX,
51 DRIVER_NVIDIA_GEFORCEFX,
52 DRIVER_NVIDIA_GEFORCE6,
53 DRIVER_VMWARE,
54 DRIVER_UNKNOWN
55 };
56
57 enum wined3d_driver_model
58 {
59 DRIVER_MODEL_WIN9X,
60 DRIVER_MODEL_NT40,
61 DRIVER_MODEL_NT5X,
62 DRIVER_MODEL_NT6X
63 };
64
65 enum wined3d_gl_vendor
66 {
67 GL_VENDOR_UNKNOWN,
68 GL_VENDOR_APPLE,
69 GL_VENDOR_FGLRX,
70 GL_VENDOR_MESA,
71 GL_VENDOR_NVIDIA,
72 };
73
74 /* The d3d device ID */
75 static const GUID IID_D3DDEVICE_D3DUID = { 0xaeb2cdd4, 0x6e41, 0x43ea, { 0x94,0x1c,0x83,0x61,0xcc,0x76,0x07,0x81 } };
76
77 /* Extension detection */
78 struct wined3d_extension_map
79 {
80 const char *extension_string;
81 enum wined3d_gl_extension extension;
82 };
83
84 static const struct wined3d_extension_map gl_extension_map[] =
85 {
86 /* APPLE */
87 {"GL_APPLE_client_storage", APPLE_CLIENT_STORAGE },
88 {"GL_APPLE_fence", APPLE_FENCE },
89 {"GL_APPLE_float_pixels", APPLE_FLOAT_PIXELS },
90 {"GL_APPLE_flush_buffer_range", APPLE_FLUSH_BUFFER_RANGE },
91 {"GL_APPLE_ycbcr_422", APPLE_YCBCR_422 },
92
93 /* ARB */
94 {"GL_ARB_blend_func_extended", ARB_BLEND_FUNC_EXTENDED },
95 {"GL_ARB_color_buffer_float", ARB_COLOR_BUFFER_FLOAT },
96 {"GL_ARB_debug_output", ARB_DEBUG_OUTPUT },
97 {"GL_ARB_depth_buffer_float", ARB_DEPTH_BUFFER_FLOAT },
98 {"GL_ARB_depth_clamp", ARB_DEPTH_CLAMP },
99 {"GL_ARB_depth_texture", ARB_DEPTH_TEXTURE },
100 {"GL_ARB_draw_buffers", ARB_DRAW_BUFFERS },
101 {"GL_ARB_draw_elements_base_vertex", ARB_DRAW_ELEMENTS_BASE_VERTEX },
102 {"GL_ARB_draw_instanced", ARB_DRAW_INSTANCED },
103 {"GL_ARB_fragment_program", ARB_FRAGMENT_PROGRAM },
104 {"GL_ARB_fragment_shader", ARB_FRAGMENT_SHADER },
105 {"GL_ARB_framebuffer_object", ARB_FRAMEBUFFER_OBJECT },
106 {"GL_ARB_framebuffer_sRGB", ARB_FRAMEBUFFER_SRGB },
107 {"GL_ARB_geometry_shader4", ARB_GEOMETRY_SHADER4 },
108 {"GL_ARB_half_float_pixel", ARB_HALF_FLOAT_PIXEL },
109 {"GL_ARB_half_float_vertex", ARB_HALF_FLOAT_VERTEX },
110 {"GL_ARB_instanced_arrays", ARB_INSTANCED_ARRAYS, },
111 {"GL_ARB_internalformat_query2", ARB_INTERNALFORMAT_QUERY2, },
112 {"GL_ARB_map_buffer_alignment", ARB_MAP_BUFFER_ALIGNMENT },
113 {"GL_ARB_map_buffer_range", ARB_MAP_BUFFER_RANGE },
114 {"GL_ARB_multisample", ARB_MULTISAMPLE }, /* needs GLX_ARB_MULTISAMPLE as well */
115 {"GL_ARB_multitexture", ARB_MULTITEXTURE },
116 {"GL_ARB_occlusion_query", ARB_OCCLUSION_QUERY },
117 {"GL_ARB_pixel_buffer_object", ARB_PIXEL_BUFFER_OBJECT },
118 {"GL_ARB_point_parameters", ARB_POINT_PARAMETERS },
119 {"GL_ARB_point_sprite", ARB_POINT_SPRITE },
120 {"GL_ARB_provoking_vertex", ARB_PROVOKING_VERTEX },
121 {"GL_ARB_shader_bit_encoding", ARB_SHADER_BIT_ENCODING },
122 {"GL_ARB_shader_objects", ARB_SHADER_OBJECTS },
123 {"GL_ARB_shader_texture_lod", ARB_SHADER_TEXTURE_LOD },
124 {"GL_ARB_shading_language_100", ARB_SHADING_LANGUAGE_100 },
125 {"GL_ARB_shadow", ARB_SHADOW },
126 {"GL_ARB_sync", ARB_SYNC },
127 {"GL_ARB_texture_border_clamp", ARB_TEXTURE_BORDER_CLAMP },
128 {"GL_ARB_texture_compression", ARB_TEXTURE_COMPRESSION },
129 {"GL_ARB_texture_compression_rgtc", ARB_TEXTURE_COMPRESSION_RGTC },
130 {"GL_ARB_texture_cube_map", ARB_TEXTURE_CUBE_MAP },
131 {"GL_ARB_texture_env_add", ARB_TEXTURE_ENV_ADD },
132 {"GL_ARB_texture_env_combine", ARB_TEXTURE_ENV_COMBINE },
133 {"GL_ARB_texture_env_dot3", ARB_TEXTURE_ENV_DOT3 },
134 {"GL_ARB_texture_float", ARB_TEXTURE_FLOAT },
135 {"GL_ARB_texture_mirrored_repeat", ARB_TEXTURE_MIRRORED_REPEAT },
136 {"GL_ARB_texture_mirror_clamp_to_edge", ARB_TEXTURE_MIRROR_CLAMP_TO_EDGE},
137 {"GL_ARB_texture_non_power_of_two", ARB_TEXTURE_NON_POWER_OF_TWO },
138 {"GL_ARB_texture_rectangle", ARB_TEXTURE_RECTANGLE },
139 {"GL_ARB_texture_rg", ARB_TEXTURE_RG },
140 {"GL_ARB_timer_query", ARB_TIMER_QUERY },
141 {"GL_ARB_vertex_array_bgra", ARB_VERTEX_ARRAY_BGRA },
142 {"GL_ARB_vertex_blend", ARB_VERTEX_BLEND },
143 {"GL_ARB_vertex_buffer_object", ARB_VERTEX_BUFFER_OBJECT },
144 {"GL_ARB_vertex_program", ARB_VERTEX_PROGRAM },
145 {"GL_ARB_vertex_shader", ARB_VERTEX_SHADER },
146
147 /* ATI */
148 {"GL_ATI_fragment_shader", ATI_FRAGMENT_SHADER },
149 {"GL_ATI_separate_stencil", ATI_SEPARATE_STENCIL },
150 {"GL_ATI_texture_compression_3dc", ATI_TEXTURE_COMPRESSION_3DC },
151 {"GL_ATI_texture_env_combine3", ATI_TEXTURE_ENV_COMBINE3 },
152 {"GL_ATI_texture_mirror_once", ATI_TEXTURE_MIRROR_ONCE },
153
154 /* EXT */
155 {"GL_EXT_blend_color", EXT_BLEND_COLOR },
156 {"GL_EXT_blend_equation_separate", EXT_BLEND_EQUATION_SEPARATE },
157 {"GL_EXT_blend_func_separate", EXT_BLEND_FUNC_SEPARATE },
158 {"GL_EXT_blend_minmax", EXT_BLEND_MINMAX },
159 {"GL_EXT_blend_subtract", EXT_BLEND_SUBTRACT },
160 {"GL_EXT_depth_bounds_test", EXT_DEPTH_BOUNDS_TEST },
161 {"GL_EXT_draw_buffers2", EXT_DRAW_BUFFERS2 },
162 {"GL_EXT_fog_coord", EXT_FOG_COORD },
163 {"GL_EXT_framebuffer_blit", EXT_FRAMEBUFFER_BLIT },
164 {"GL_EXT_framebuffer_multisample", EXT_FRAMEBUFFER_MULTISAMPLE },
165 {"GL_EXT_framebuffer_object", EXT_FRAMEBUFFER_OBJECT },
166 {"GL_EXT_gpu_program_parameters", EXT_GPU_PROGRAM_PARAMETERS },
167 {"GL_EXT_gpu_shader4", EXT_GPU_SHADER4 },
168 {"GL_EXT_packed_depth_stencil", EXT_PACKED_DEPTH_STENCIL },
169 {"GL_EXT_point_parameters", EXT_POINT_PARAMETERS },
170 {"GL_EXT_provoking_vertex", EXT_PROVOKING_VERTEX },
171 {"GL_EXT_secondary_color", EXT_SECONDARY_COLOR },
172 {"GL_EXT_stencil_two_side", EXT_STENCIL_TWO_SIDE },
173 {"GL_EXT_stencil_wrap", EXT_STENCIL_WRAP },
174 {"GL_EXT_texture3D", EXT_TEXTURE3D },
175 {"GL_EXT_texture_compression_rgtc", EXT_TEXTURE_COMPRESSION_RGTC },
176 {"GL_EXT_texture_compression_s3tc", EXT_TEXTURE_COMPRESSION_S3TC },
177 {"GL_EXT_texture_env_add", EXT_TEXTURE_ENV_ADD },
178 {"GL_EXT_texture_env_combine", EXT_TEXTURE_ENV_COMBINE },
179 {"GL_EXT_texture_env_dot3", EXT_TEXTURE_ENV_DOT3 },
180 {"GL_EXT_texture_filter_anisotropic", EXT_TEXTURE_FILTER_ANISOTROPIC},
181 {"GL_EXT_texture_lod_bias", EXT_TEXTURE_LOD_BIAS },
182 {"GL_EXT_texture_mirror_clamp", EXT_TEXTURE_MIRROR_CLAMP },
183 {"GL_EXT_texture_sRGB", EXT_TEXTURE_SRGB },
184 {"GL_EXT_texture_sRGB_decode", EXT_TEXTURE_SRGB_DECODE },
185 {"GL_EXT_vertex_array_bgra", EXT_VERTEX_ARRAY_BGRA },
186
187 /* NV */
188 {"GL_NV_depth_clamp", NV_DEPTH_CLAMP },
189 {"GL_NV_fence", NV_FENCE },
190 {"GL_NV_fog_distance", NV_FOG_DISTANCE },
191 {"GL_NV_fragment_program", NV_FRAGMENT_PROGRAM },
192 {"GL_NV_fragment_program2", NV_FRAGMENT_PROGRAM2 },
193 {"GL_NV_fragment_program_option", NV_FRAGMENT_PROGRAM_OPTION },
194 {"GL_NV_half_float", NV_HALF_FLOAT },
195 {"GL_NV_light_max_exponent", NV_LIGHT_MAX_EXPONENT },
196 {"GL_NV_point_sprite", NV_POINT_SPRITE },
197 {"GL_NV_register_combiners", NV_REGISTER_COMBINERS },
198 {"GL_NV_register_combiners2", NV_REGISTER_COMBINERS2 },
199 {"GL_NV_texgen_reflection", NV_TEXGEN_REFLECTION },
200 {"GL_NV_texture_env_combine4", NV_TEXTURE_ENV_COMBINE4 },
201 {"GL_NV_texture_shader", NV_TEXTURE_SHADER },
202 {"GL_NV_texture_shader2", NV_TEXTURE_SHADER2 },
203 {"GL_NV_vertex_program", NV_VERTEX_PROGRAM },
204 {"GL_NV_vertex_program1_1", NV_VERTEX_PROGRAM1_1 },
205 {"GL_NV_vertex_program2", NV_VERTEX_PROGRAM2 },
206 {"GL_NV_vertex_program2_option", NV_VERTEX_PROGRAM2_OPTION },
207 {"GL_NV_vertex_program3", NV_VERTEX_PROGRAM3 },
208
209 /* SGI */
210 {"GL_SGIS_generate_mipmap", SGIS_GENERATE_MIPMAP },
211 };
212
213 static const struct wined3d_extension_map wgl_extension_map[] =
214 {
215 {"WGL_ARB_pixel_format", WGL_ARB_PIXEL_FORMAT },
216 {"WGL_EXT_swap_control", WGL_EXT_SWAP_CONTROL },
217 {"WGL_WINE_pixel_format_passthrough", WGL_WINE_PIXEL_FORMAT_PASSTHROUGH},
218 };
219
220 /**********************************************************
221 * Utility functions follow
222 **********************************************************/
223
224 const struct min_lookup minMipLookup[] =
225 {
226 /* NONE POINT LINEAR */
227 {{GL_NEAREST, GL_NEAREST, GL_NEAREST}}, /* NONE */
228 {{GL_NEAREST, GL_NEAREST_MIPMAP_NEAREST, GL_NEAREST_MIPMAP_LINEAR}}, /* POINT*/
229 {{GL_LINEAR, GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR_MIPMAP_LINEAR}}, /* LINEAR */
230 };
231
232 const struct min_lookup minMipLookup_noFilter[] =
233 {
234 /* NONE POINT LINEAR */
235 {{GL_NEAREST, GL_NEAREST, GL_NEAREST}}, /* NONE */
236 {{GL_NEAREST, GL_NEAREST, GL_NEAREST}}, /* POINT */
237 {{GL_NEAREST, GL_NEAREST, GL_NEAREST}}, /* LINEAR */
238 };
239
240 const struct min_lookup minMipLookup_noMip[] =
241 {
242 /* NONE POINT LINEAR */
243 {{GL_NEAREST, GL_NEAREST, GL_NEAREST}}, /* NONE */
244 {{GL_NEAREST, GL_NEAREST, GL_NEAREST}}, /* POINT */
245 {{GL_LINEAR, GL_LINEAR, GL_LINEAR }}, /* LINEAR */
246 };
247
248 const GLenum magLookup[] =
249 {
250 /* NONE POINT LINEAR */
251 GL_NEAREST, GL_NEAREST, GL_LINEAR,
252 };
253
254 const GLenum magLookup_noFilter[] =
255 {
256 /* NONE POINT LINEAR */
257 GL_NEAREST, GL_NEAREST, GL_NEAREST,
258 };
259
260 struct wined3d_caps_gl_ctx
261 {
262 HDC dc;
263 HWND wnd;
264 HGLRC gl_ctx;
265 HDC restore_dc;
266 HGLRC restore_gl_ctx;
267 };
268
269 static void wined3d_caps_gl_ctx_destroy(const struct wined3d_caps_gl_ctx *ctx)
270 {
271 TRACE("Destroying caps GL context.\n");
272
273 if (!wglMakeCurrent(NULL, NULL))
274 ERR("Failed to disable caps GL context.\n");
275
276 if (!wglDeleteContext(ctx->gl_ctx))
277 {
278 DWORD err = GetLastError();
279 ERR("wglDeleteContext(%p) failed, last error %#x.\n", ctx->gl_ctx, err);
280 }
281
282 wined3d_release_dc(ctx->wnd, ctx->dc);
283 DestroyWindow(ctx->wnd);
284
285 if (ctx->restore_gl_ctx && !wglMakeCurrent(ctx->restore_dc, ctx->restore_gl_ctx))
286 ERR("Failed to restore previous GL context.\n");
287 }
288
289 static void wined3d_caps_gl_ctx_create_attribs(struct wined3d_caps_gl_ctx *caps_gl_ctx,
290 struct wined3d_gl_info *gl_info, const GLint *ctx_attribs)
291 {
292 HGLRC new_ctx;
293
294 if (!(gl_info->p_wglCreateContextAttribsARB = (void *)wglGetProcAddress("wglCreateContextAttribsARB")))
295 return;
296
297 if (!(new_ctx = gl_info->p_wglCreateContextAttribsARB(caps_gl_ctx->dc, NULL, ctx_attribs)))
298 {
299 ERR("Failed to create a context using wglCreateContextAttribsARB(), last error %#x.\n", GetLastError());
300 gl_info->p_wglCreateContextAttribsARB = NULL;
301 return;
302 }
303
304 if (!wglMakeCurrent(caps_gl_ctx->dc, new_ctx))
305 {
306 ERR("Failed to make new context current, last error %#x.\n", GetLastError());
307 if (!wglDeleteContext(new_ctx))
308 ERR("Failed to delete new context, last error %#x.\n", GetLastError());
309 gl_info->p_wglCreateContextAttribsARB = NULL;
310 return;
311 }
312
313 if (!wglDeleteContext(caps_gl_ctx->gl_ctx))
314 ERR("Failed to delete old context, last error %#x.\n", GetLastError());
315 caps_gl_ctx->gl_ctx = new_ctx;
316 }
317
318 static BOOL wined3d_caps_gl_ctx_create(struct wined3d_caps_gl_ctx *ctx)
319 {
320 PIXELFORMATDESCRIPTOR pfd;
321 int iPixelFormat;
322
323 TRACE("getting context...\n");
324
325 ctx->restore_dc = wglGetCurrentDC();
326 ctx->restore_gl_ctx = wglGetCurrentContext();
327
328 /* We need a fake window as a hdc retrieved using GetDC(0) can't be used for much GL purposes. */
329 ctx->wnd = CreateWindowA(WINED3D_OPENGL_WINDOW_CLASS_NAME, "WineD3D fake window",
330 WS_OVERLAPPEDWINDOW, 10, 10, 10, 10, NULL, NULL, NULL, NULL);
331 if (!ctx->wnd)
332 {
333 ERR("Failed to create a window.\n");
334 goto fail;
335 }
336
337 ctx->dc = GetDC(ctx->wnd);
338 if (!ctx->dc)
339 {
340 ERR("Failed to get a DC.\n");
341 goto fail;
342 }
343
344 /* PixelFormat selection */
345 ZeroMemory(&pfd, sizeof(pfd));
346 pfd.nSize = sizeof(pfd);
347 pfd.nVersion = 1;
348 pfd.dwFlags = PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER | PFD_DRAW_TO_WINDOW; /* PFD_GENERIC_ACCELERATED */
349 pfd.iPixelType = PFD_TYPE_RGBA;
350 pfd.cColorBits = 32;
351 pfd.iLayerType = PFD_MAIN_PLANE;
352
353 if (!(iPixelFormat = ChoosePixelFormat(ctx->dc, &pfd)))
354 {
355 /* If this happens something is very wrong as ChoosePixelFormat barely fails. */
356 ERR("Failed to find a suitable pixel format.\n");
357 goto fail;
358 }
359 DescribePixelFormat(ctx->dc, iPixelFormat, sizeof(pfd), &pfd);
360 SetPixelFormat(ctx->dc, iPixelFormat, &pfd);
361
362 /* Create a GL context. */
363 if (!(ctx->gl_ctx = wglCreateContext(ctx->dc)))
364 {
365 WARN("Failed to create default context for capabilities initialization.\n");
366 goto fail;
367 }
368
369 /* Make it the current GL context. */
370 if (!wglMakeCurrent(ctx->dc, ctx->gl_ctx))
371 {
372 ERR("Failed to make caps GL context current.\n");
373 goto fail;
374 }
375
376 return TRUE;
377
378 fail:
379 if (ctx->gl_ctx) wglDeleteContext(ctx->gl_ctx);
380 ctx->gl_ctx = NULL;
381 if (ctx->dc) ReleaseDC(ctx->wnd, ctx->dc);
382 ctx->dc = NULL;
383 if (ctx->wnd) DestroyWindow(ctx->wnd);
384 ctx->wnd = NULL;
385 if (ctx->restore_gl_ctx && !wglMakeCurrent(ctx->restore_dc, ctx->restore_gl_ctx))
386 ERR("Failed to restore previous GL context.\n");
387
388 return FALSE;
389 }
390
391 /* Adjust the amount of used texture memory */
392 unsigned int adapter_adjust_memory(struct wined3d_adapter *adapter, int amount)
393 {
394 adapter->UsedTextureRam += amount;
395 TRACE("Adjusted adapter memory by %d to %d.\n", amount, adapter->UsedTextureRam);
396 return adapter->UsedTextureRam;
397 }
398
399 static void wined3d_adapter_cleanup(struct wined3d_adapter *adapter)
400 {
401 HeapFree(GetProcessHeap(), 0, adapter->gl_info.formats);
402 HeapFree(GetProcessHeap(), 0, adapter->cfgs);
403 }
404
405 ULONG CDECL wined3d_incref(struct wined3d *wined3d)
406 {
407 ULONG refcount = InterlockedIncrement(&wined3d->ref);
408
409 TRACE("%p increasing refcount to %u.\n", wined3d, refcount);
410
411 return refcount;
412 }
413
414 ULONG CDECL wined3d_decref(struct wined3d *wined3d)
415 {
416 ULONG refcount = InterlockedDecrement(&wined3d->ref);
417
418 TRACE("%p decreasing refcount to %u.\n", wined3d, refcount);
419
420 if (!refcount)
421 {
422 unsigned int i;
423
424 for (i = 0; i < wined3d->adapter_count; ++i)
425 {
426 wined3d_adapter_cleanup(&wined3d->adapters[i]);
427 }
428 HeapFree(GetProcessHeap(), 0, wined3d);
429 }
430
431 return refcount;
432 }
433
434 /* Context activation is done by the caller. */
435 static BOOL test_arb_vs_offset_limit(const struct wined3d_gl_info *gl_info)
436 {
437 GLuint prog;
438 BOOL ret = FALSE;
439 const char *testcode =
440 "!!ARBvp1.0\n"
441 "PARAM C[66] = { program.env[0..65] };\n"
442 "ADDRESS A0;"
443 "PARAM zero = {0.0, 0.0, 0.0, 0.0};\n"
444 "ARL A0.x, zero.x;\n"
445 "MOV result.position, C[A0.x + 65];\n"
446 "END\n";
447
448 while (gl_info->gl_ops.gl.p_glGetError());
449 GL_EXTCALL(glGenProgramsARB(1, &prog));
450 if(!prog) {
451 ERR("Failed to create an ARB offset limit test program\n");
452 }
453 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, prog));
454 GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
455 strlen(testcode), testcode));
456 if (gl_info->gl_ops.gl.p_glGetError())
457 {
458 TRACE("OpenGL implementation does not allow indirect addressing offsets > 63\n");
459 TRACE("error: %s\n", debugstr_a((const char *)gl_info->gl_ops.gl.p_glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
460 ret = TRUE;
461 } else TRACE("OpenGL implementation allows offsets > 63\n");
462
463 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, 0));
464 GL_EXTCALL(glDeleteProgramsARB(1, &prog));
465 checkGLcall("ARB vp offset limit test cleanup");
466
467 return ret;
468 }
469
470 static BOOL match_amd_r300_to_500(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
471 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
472 {
473 if (card_vendor != HW_VENDOR_AMD) return FALSE;
474 if (device == CARD_AMD_RADEON_9500) return TRUE;
475 if (device == CARD_AMD_RADEON_X700) return TRUE;
476 if (device == CARD_AMD_RADEON_X1600) return TRUE;
477 return FALSE;
478 }
479
480 static BOOL match_geforce5(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
481 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
482 {
483 if (card_vendor == HW_VENDOR_NVIDIA)
484 {
485 if (device == CARD_NVIDIA_GEFORCEFX_5200 ||
486 device == CARD_NVIDIA_GEFORCEFX_5600 ||
487 device == CARD_NVIDIA_GEFORCEFX_5800)
488 {
489 return TRUE;
490 }
491 }
492 return FALSE;
493 }
494
495 static BOOL match_apple(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
496 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
497 {
498 /* MacOS has various specialities in the extensions it advertises. Some have to be loaded from
499 * the opengl 1.2+ core, while other extensions are advertised, but software emulated. So try to
500 * detect the Apple OpenGL implementation to apply some extension fixups afterwards.
501 *
502 * Detecting this isn't really easy. The vendor string doesn't mention Apple. Compile-time checks
503 * aren't sufficient either because a Linux binary may display on a macos X server via remote X11.
504 * So try to detect the GL implementation by looking at certain Apple extensions. Some extensions
505 * like client storage might be supported on other implementations too, but GL_APPLE_flush_render
506 * is specific to the Mac OS X window management, and GL_APPLE_ycbcr_422 is QuickTime specific. So
507 * the chance that other implementations support them is rather small since Win32 QuickTime uses
508 * DirectDraw, not OpenGL.
509 *
510 * This test has been moved into wined3d_guess_gl_vendor()
511 */
512 if (gl_vendor == GL_VENDOR_APPLE)
513 {
514 return TRUE;
515 }
516 return FALSE;
517 }
518
519 /* Context activation is done by the caller. */
520 static void test_pbo_functionality(struct wined3d_gl_info *gl_info)
521 {
522 /* Some OpenGL implementations, namely Apple's Geforce 8 driver, advertises PBOs,
523 * but glTexSubImage from a PBO fails miserably, with the first line repeated over
524 * all the texture. This function detects this bug by its symptom and disables PBOs
525 * if the test fails.
526 *
527 * The test uploads a 4x4 texture via the PBO in the "native" format GL_BGRA,
528 * GL_UNSIGNED_INT_8_8_8_8_REV. This format triggers the bug, and it is what we use
529 * for D3DFMT_A8R8G8B8. Then the texture is read back without any PBO and the data
530 * read back is compared to the original. If they are equal PBOs are assumed to work,
531 * otherwise the PBO extension is disabled. */
532 GLuint texture, pbo;
533 static const unsigned int pattern[] =
534 {
535 0x00000000, 0x000000ff, 0x0000ff00, 0x40ff0000,
536 0x80ffffff, 0x40ffff00, 0x00ff00ff, 0x0000ffff,
537 0x00ffff00, 0x00ff00ff, 0x0000ffff, 0x000000ff,
538 0x80ff00ff, 0x0000ffff, 0x00ff00ff, 0x40ff00ff
539 };
540 unsigned int check[sizeof(pattern) / sizeof(pattern[0])];
541
542 /* No PBO -> No point in testing them. */
543 if (!gl_info->supported[ARB_PIXEL_BUFFER_OBJECT]) return;
544
545 while (gl_info->gl_ops.gl.p_glGetError());
546 gl_info->gl_ops.gl.p_glGenTextures(1, &texture);
547 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, texture);
548
549 gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
550 gl_info->gl_ops.gl.p_glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 4, 4, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, 0);
551 checkGLcall("Specifying the PBO test texture");
552
553 GL_EXTCALL(glGenBuffersARB(1, &pbo));
554 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pbo));
555 GL_EXTCALL(glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, sizeof(pattern), pattern, GL_STREAM_DRAW_ARB));
556 checkGLcall("Specifying the PBO test pbo");
557
558 gl_info->gl_ops.gl.p_glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL);
559 checkGLcall("Loading the PBO test texture");
560
561 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
562
563 gl_info->gl_ops.gl.p_glFinish(); /* just to be sure */
564
565 memset(check, 0, sizeof(check));
566 gl_info->gl_ops.gl.p_glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, check);
567 checkGLcall("Reading back the PBO test texture");
568
569 gl_info->gl_ops.gl.p_glDeleteTextures(1, &texture);
570 GL_EXTCALL(glDeleteBuffersARB(1, &pbo));
571 checkGLcall("PBO test cleanup");
572
573 if (memcmp(check, pattern, sizeof(check)))
574 {
575 WARN_(d3d_perf)("PBO test failed, read back data doesn't match original.\n"
576 "Disabling PBOs. This may result in slower performance.\n");
577 gl_info->supported[ARB_PIXEL_BUFFER_OBJECT] = FALSE;
578 }
579 else
580 {
581 TRACE("PBO test successful.\n");
582 }
583 }
584
585 static BOOL match_apple_intel(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
586 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
587 {
588 return (card_vendor == HW_VENDOR_INTEL) && (gl_vendor == GL_VENDOR_APPLE);
589 }
590
591 static BOOL match_apple_nonr500ati(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
592 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
593 {
594 if (gl_vendor != GL_VENDOR_APPLE) return FALSE;
595 if (card_vendor != HW_VENDOR_AMD) return FALSE;
596 if (device == CARD_AMD_RADEON_X1600) return FALSE;
597 return TRUE;
598 }
599
600 static BOOL match_dx10_capable(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
601 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
602 {
603 /* DX9 cards support 40 single float varyings in hardware, most drivers report 32. ATI misreports
604 * 44 varyings. So assume that if we have more than 44 varyings we have a dx10 card.
605 * This detection is for the gl_ClipPos varying quirk. If a d3d9 card really supports more than 44
606 * varyings and we subtract one in dx9 shaders it's not going to hurt us because the dx9 limit is
607 * hardcoded
608 *
609 * dx10 cards usually have 64 varyings */
610 return gl_info->limits.glsl_varyings > 44;
611 }
612
613 static BOOL match_not_dx10_capable(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
614 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
615 {
616 return !match_dx10_capable(gl_info, gl_renderer, gl_vendor, card_vendor, device);
617 }
618
619 /* A GL context is provided by the caller */
620 static BOOL match_allows_spec_alpha(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
621 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
622 {
623 GLenum error;
624 DWORD data[16];
625
626 if (!gl_info->supported[EXT_SECONDARY_COLOR])
627 return FALSE;
628
629 while (gl_info->gl_ops.gl.p_glGetError());
630 GL_EXTCALL(glSecondaryColorPointerEXT)(4, GL_UNSIGNED_BYTE, 4, data);
631 error = gl_info->gl_ops.gl.p_glGetError();
632
633 if (error == GL_NO_ERROR)
634 {
635 TRACE("GL Implementation accepts 4 component specular color pointers\n");
636 return TRUE;
637 }
638 else
639 {
640 TRACE("GL implementation does not accept 4 component specular colors, error %s\n",
641 debug_glerror(error));
642 return FALSE;
643 }
644 }
645
646 /* A GL context is provided by the caller */
647 static BOOL match_broken_nv_clip(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
648 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
649 {
650 GLuint prog;
651 BOOL ret = FALSE;
652 GLint pos;
653 const char *testcode =
654 "!!ARBvp1.0\n"
655 "OPTION NV_vertex_program2;\n"
656 "MOV result.clip[0], 0.0;\n"
657 "MOV result.position, 0.0;\n"
658 "END\n";
659
660 if (!gl_info->supported[NV_VERTEX_PROGRAM2_OPTION]) return FALSE;
661
662 while (gl_info->gl_ops.gl.p_glGetError());
663
664 GL_EXTCALL(glGenProgramsARB(1, &prog));
665 if(!prog)
666 {
667 ERR("Failed to create the NVvp clip test program\n");
668 return FALSE;
669 }
670 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, prog));
671 GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
672 strlen(testcode), testcode));
673 gl_info->gl_ops.gl.p_glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &pos);
674 if(pos != -1)
675 {
676 WARN("GL_NV_vertex_program2_option result.clip[] test failed\n");
677 TRACE("error: %s\n", debugstr_a((const char *)gl_info->gl_ops.gl.p_glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
678 ret = TRUE;
679 while (gl_info->gl_ops.gl.p_glGetError());
680 }
681 else TRACE("GL_NV_vertex_program2_option result.clip[] test passed\n");
682
683 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, 0));
684 GL_EXTCALL(glDeleteProgramsARB(1, &prog));
685 checkGLcall("GL_NV_vertex_program2_option result.clip[] test cleanup");
686
687 return ret;
688 }
689
690 /* Context activation is done by the caller. */
691 static BOOL match_fbo_tex_update(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
692 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
693 {
694 char data[4 * 4 * 4];
695 GLuint tex, fbo;
696 GLenum status;
697
698 if (wined3d_settings.offscreen_rendering_mode != ORM_FBO) return FALSE;
699
700 memset(data, 0xcc, sizeof(data));
701
702 gl_info->gl_ops.gl.p_glGenTextures(1, &tex);
703 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, tex);
704 gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
705 gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
706 gl_info->gl_ops.gl.p_glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 4, 4, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL);
707 checkGLcall("glTexImage2D");
708
709 gl_info->fbo_ops.glGenFramebuffers(1, &fbo);
710 gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
711 gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0);
712 checkGLcall("glFramebufferTexture2D");
713
714 status = gl_info->fbo_ops.glCheckFramebufferStatus(GL_FRAMEBUFFER);
715 if (status != GL_FRAMEBUFFER_COMPLETE) ERR("FBO status %#x\n", status);
716 checkGLcall("glCheckFramebufferStatus");
717
718 memset(data, 0x11, sizeof(data));
719 gl_info->gl_ops.gl.p_glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, data);
720 checkGLcall("glTexSubImage2D");
721
722 gl_info->gl_ops.gl.p_glClearColor(0.996f, 0.729f, 0.745f, 0.792f);
723 gl_info->gl_ops.gl.p_glClear(GL_COLOR_BUFFER_BIT);
724 checkGLcall("glClear");
725
726 gl_info->gl_ops.gl.p_glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, data);
727 checkGLcall("glGetTexImage");
728
729 gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
730 gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, 0);
731 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, 0);
732 checkGLcall("glBindTexture");
733
734 gl_info->fbo_ops.glDeleteFramebuffers(1, &fbo);
735 gl_info->gl_ops.gl.p_glDeleteTextures(1, &tex);
736 checkGLcall("glDeleteTextures");
737
738 return *(DWORD *)data == 0x11111111;
739 }
740
741 /* Context activation is done by the caller. */
742 static BOOL match_broken_rgba16(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
743 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
744 {
745 /* GL_RGBA16 uses GL_RGBA8 internally on Geforce 7 and older cards.
746 * This leads to graphical bugs in Half Life 2 and Unreal engine games. */
747 GLuint tex;
748 GLint size;
749
750 gl_info->gl_ops.gl.p_glGenTextures(1, &tex);
751 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, tex);
752 gl_info->gl_ops.gl.p_glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16, 4, 4, 0, GL_RGBA, GL_UNSIGNED_SHORT, NULL);
753 checkGLcall("glTexImage2D");
754
755 gl_info->gl_ops.gl.p_glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_RED_SIZE, &size);
756 checkGLcall("glGetTexLevelParameteriv");
757 TRACE("Real color depth is %d\n", size);
758
759 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, 0);
760 checkGLcall("glBindTexture");
761 gl_info->gl_ops.gl.p_glDeleteTextures(1, &tex);
762 checkGLcall("glDeleteTextures");
763
764 return size < 16;
765 }
766
767 static BOOL match_fglrx(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
768 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
769 {
770 return gl_vendor == GL_VENDOR_FGLRX;
771 }
772
773 static BOOL match_r200(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
774 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
775 {
776 if (card_vendor != HW_VENDOR_AMD) return FALSE;
777 if (device == CARD_AMD_RADEON_8500) return TRUE;
778 return FALSE;
779 }
780
781 static BOOL match_broken_arb_fog(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
782 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
783 {
784 DWORD data[4];
785 GLuint tex, fbo;
786 GLenum status;
787 float color[4] = {0.0f, 1.0f, 0.0f, 0.0f};
788 GLuint prog;
789 GLint err_pos;
790 static const char *program_code =
791 "!!ARBfp1.0\n"
792 "OPTION ARB_fog_linear;\n"
793 "MOV result.color, {1.0, 0.0, 0.0, 0.0};\n"
794 "END\n";
795
796 if (wined3d_settings.offscreen_rendering_mode != ORM_FBO)
797 return FALSE;
798 if (!gl_info->supported[ARB_FRAGMENT_PROGRAM])
799 return FALSE;
800
801 gl_info->gl_ops.gl.p_glGenTextures(1, &tex);
802 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, tex);
803 gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
804 gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
805 gl_info->gl_ops.gl.p_glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, 4, 1, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL);
806 checkGLcall("glTexImage2D");
807
808 gl_info->fbo_ops.glGenFramebuffers(1, &fbo);
809 gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
810 gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0);
811 checkGLcall("glFramebufferTexture2D");
812
813 status = gl_info->fbo_ops.glCheckFramebufferStatus(GL_FRAMEBUFFER);
814 if (status != GL_FRAMEBUFFER_COMPLETE) ERR("FBO status %#x\n", status);
815 checkGLcall("glCheckFramebufferStatus");
816
817 gl_info->gl_ops.gl.p_glClearColor(0.0f, 0.0f, 1.0f, 0.0f);
818 gl_info->gl_ops.gl.p_glClear(GL_COLOR_BUFFER_BIT);
819 checkGLcall("glClear");
820 gl_info->gl_ops.gl.p_glViewport(0, 0, 4, 1);
821 checkGLcall("glViewport");
822
823 gl_info->gl_ops.gl.p_glEnable(GL_FOG);
824 gl_info->gl_ops.gl.p_glFogf(GL_FOG_START, 0.5f);
825 gl_info->gl_ops.gl.p_glFogf(GL_FOG_END, 0.5f);
826 gl_info->gl_ops.gl.p_glFogi(GL_FOG_MODE, GL_LINEAR);
827 gl_info->gl_ops.gl.p_glHint(GL_FOG_HINT, GL_NICEST);
828 gl_info->gl_ops.gl.p_glFogfv(GL_FOG_COLOR, color);
829 checkGLcall("fog setup");
830
831 GL_EXTCALL(glGenProgramsARB(1, &prog));
832 GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, prog));
833 GL_EXTCALL(glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
834 strlen(program_code), program_code));
835 gl_info->gl_ops.gl.p_glEnable(GL_FRAGMENT_PROGRAM_ARB);
836 checkGLcall("Test fragment program setup");
837
838 gl_info->gl_ops.gl.p_glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &err_pos);
839 if (err_pos != -1)
840 {
841 const char *error_str;
842 error_str = (const char *)gl_info->gl_ops.gl.p_glGetString(GL_PROGRAM_ERROR_STRING_ARB);
843 FIXME("Fog test program error at position %d: %s\n\n", err_pos, debugstr_a(error_str));
844 }
845
846 gl_info->gl_ops.gl.p_glBegin(GL_TRIANGLE_STRIP);
847 gl_info->gl_ops.gl.p_glVertex3f(-1.0f, -1.0f, 0.0f);
848 gl_info->gl_ops.gl.p_glVertex3f( 1.0f, -1.0f, 1.0f);
849 gl_info->gl_ops.gl.p_glVertex3f(-1.0f, 1.0f, 0.0f);
850 gl_info->gl_ops.gl.p_glVertex3f( 1.0f, 1.0f, 1.0f);
851 gl_info->gl_ops.gl.p_glEnd();
852 checkGLcall("ARBfp fog test draw");
853
854 gl_info->gl_ops.gl.p_glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, data);
855 checkGLcall("glGetTexImage");
856 data[0] &= 0x00ffffff;
857 data[1] &= 0x00ffffff;
858 data[2] &= 0x00ffffff;
859 data[3] &= 0x00ffffff;
860
861 gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, 0);
862 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, 0);
863
864 gl_info->fbo_ops.glDeleteFramebuffers(1, &fbo);
865 gl_info->gl_ops.gl.p_glDeleteTextures(1, &tex);
866 gl_info->gl_ops.gl.p_glDisable(GL_FOG);
867 GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, 0));
868 gl_info->gl_ops.gl.p_glDisable(GL_FRAGMENT_PROGRAM_ARB);
869 GL_EXTCALL(glDeleteProgramsARB(1, &prog));
870 checkGLcall("ARBfp fog test teardown");
871
872 TRACE("Fog test data: %08x %08x %08x %08x\n", data[0], data[1], data[2], data[3]);
873 return data[0] != 0x00ff0000 || data[3] != 0x0000ff00;
874 }
875
876 static void quirk_apple_glsl_constants(struct wined3d_gl_info *gl_info)
877 {
878 /* MacOS needs uniforms for relative addressing offsets. This can accumulate to quite a few uniforms.
879 * Beyond that the general uniform isn't optimal, so reserve a number of uniforms. 12 vec4's should
880 * allow 48 different offsets or other helper immediate values. */
881 TRACE("Reserving 12 GLSL constants for compiler private use.\n");
882 gl_info->reserved_glsl_constants = max(gl_info->reserved_glsl_constants, 12);
883 }
884
885 static void quirk_amd_dx9(struct wined3d_gl_info *gl_info)
886 {
887 /* MacOS advertises GL_ARB_texture_non_power_of_two on ATI r500 and earlier cards, although
888 * these cards only support GL_ARB_texture_rectangle(D3DPTEXTURECAPS_NONPOW2CONDITIONAL).
889 * If real NP2 textures are used, the driver falls back to software. We could just remove the
890 * extension and use GL_ARB_texture_rectangle instead, but texture_rectangle is inconvenient
891 * due to the non-normalized texture coordinates. Thus set an internal extension flag,
892 * GL_WINE_normalized_texrect, which signals the code that it can use non power of two textures
893 * as per GL_ARB_texture_non_power_of_two, but has to stick to the texture_rectangle limits.
894 *
895 * fglrx doesn't advertise GL_ARB_texture_non_power_of_two, but it advertises opengl 2.0 which
896 * has this extension promoted to core. The extension loading code sets this extension supported
897 * due to that, so this code works on fglrx as well. */
898 if(gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO])
899 {
900 TRACE("GL_ARB_texture_non_power_of_two advertised on R500 or earlier card, removing.\n");
901 gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] = FALSE;
902 gl_info->supported[WINED3D_GL_NORMALIZED_TEXRECT] = TRUE;
903 }
904 }
905
906 static void quirk_no_np2(struct wined3d_gl_info *gl_info)
907 {
908 /* The nVidia GeForceFX series reports OpenGL 2.0 capabilities with the latest drivers versions, but
909 * doesn't explicitly advertise the ARB_tex_npot extension in the GL extension string.
910 * This usually means that ARB_tex_npot is supported in hardware as long as the application is staying
911 * within the limits enforced by the ARB_texture_rectangle extension. This however is not true for the
912 * FX series, which instantly falls back to a slower software path as soon as ARB_tex_npot is used.
913 * We therefore completely remove ARB_tex_npot from the list of supported extensions.
914 *
915 * Note that wine_normalized_texrect can't be used in this case because internally it uses ARB_tex_npot,
916 * triggering the software fallback. There is not much we can do here apart from disabling the
917 * software-emulated extension and re-enable ARB_tex_rect (which was previously disabled
918 * in wined3d_adapter_init_gl_caps).
919 * This fixup removes performance problems on both the FX 5900 and FX 5700 (e.g. for framebuffer
920 * post-processing effects in the game "Max Payne 2").
921 * The behaviour can be verified through a simple test app attached in bugreport #14724. */
922 TRACE("GL_ARB_texture_non_power_of_two advertised through OpenGL 2.0 on NV FX card, removing.\n");
923 gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] = FALSE;
924 gl_info->supported[ARB_TEXTURE_RECTANGLE] = TRUE;
925 }
926
927 static void quirk_texcoord_w(struct wined3d_gl_info *gl_info)
928 {
929 /* The Intel GPUs on MacOS set the .w register of texcoords to 0.0 by default, which causes problems
930 * with fixed function fragment processing. Ideally this flag should be detected with a test shader
931 * and OpenGL feedback mode, but some GL implementations (MacOS ATI at least, probably all MacOS ones)
932 * do not like vertex shaders in feedback mode and return an error, even though it should be valid
933 * according to the spec.
934 *
935 * We don't want to enable this on all cards, as it adds an extra instruction per texcoord used. This
936 * makes the shader slower and eats instruction slots which should be available to the d3d app.
937 *
938 * ATI Radeon HD 2xxx cards on MacOS have the issue. Instead of checking for the buggy cards, blacklist
939 * all radeon cards on Macs and whitelist the good ones. That way we're prepared for the future. If
940 * this workaround is activated on cards that do not need it, it won't break things, just affect
941 * performance negatively. */
942 TRACE("Enabling vertex texture coord fixes in vertex shaders.\n");
943 gl_info->quirks |= WINED3D_QUIRK_SET_TEXCOORD_W;
944 }
945
946 static void quirk_clip_varying(struct wined3d_gl_info *gl_info)
947 {
948 gl_info->quirks |= WINED3D_QUIRK_GLSL_CLIP_VARYING;
949 }
950
951 static void quirk_allows_specular_alpha(struct wined3d_gl_info *gl_info)
952 {
953 gl_info->quirks |= WINED3D_QUIRK_ALLOWS_SPECULAR_ALPHA;
954 }
955
956 static void quirk_disable_nvvp_clip(struct wined3d_gl_info *gl_info)
957 {
958 gl_info->quirks |= WINED3D_QUIRK_NV_CLIP_BROKEN;
959 }
960
961 static void quirk_fbo_tex_update(struct wined3d_gl_info *gl_info)
962 {
963 gl_info->quirks |= WINED3D_QUIRK_FBO_TEX_UPDATE;
964 }
965
966 static void quirk_broken_rgba16(struct wined3d_gl_info *gl_info)
967 {
968 gl_info->quirks |= WINED3D_QUIRK_BROKEN_RGBA16;
969 }
970
971 static void quirk_infolog_spam(struct wined3d_gl_info *gl_info)
972 {
973 gl_info->quirks |= WINED3D_QUIRK_INFO_LOG_SPAM;
974 }
975
976 static void quirk_limited_tex_filtering(struct wined3d_gl_info *gl_info)
977 {
978 /* Nvidia GeForce 6xxx and 7xxx support accelerated VTF only on a few
979 selected texture formats. They are apparently the only DX9 class GPUs
980 supporting VTF.
981 Also, DX9-era GPUs are somewhat limited with float textures
982 filtering and blending. */
983 gl_info->quirks |= WINED3D_QUIRK_LIMITED_TEX_FILTERING;
984 }
985
986 static void quirk_r200_constants(struct wined3d_gl_info *gl_info)
987 {
988 /* The Mesa r200 driver (and there is no other driver for this GPU Wine would run on)
989 * loads some fog parameters (start, end, exponent, but not the color) into the
990 * program.
991 *
992 * Apparently the fog hardware is only able to handle linear fog with a range of 0.0;1.0,
993 * and it is the responsibility of the vertex pipeline to handle non-linear fog and
994 * linear fog with start and end other than 0.0 and 1.0. */
995 TRACE("Reserving 1 ARB constant for compiler private use.\n");
996 gl_info->reserved_arb_constants = max(gl_info->reserved_arb_constants, 1);
997 }
998
999 static void quirk_broken_arb_fog(struct wined3d_gl_info *gl_info)
1000 {
1001 gl_info->quirks |= WINED3D_QUIRK_BROKEN_ARB_FOG;
1002 }
1003
1004 struct driver_quirk
1005 {
1006 BOOL (*match)(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
1007 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device);
1008 void (*apply)(struct wined3d_gl_info *gl_info);
1009 const char *description;
1010 };
1011
1012 static const struct driver_quirk quirk_table[] =
1013 {
1014 {
1015 match_amd_r300_to_500,
1016 quirk_amd_dx9,
1017 "AMD normalized texrect quirk"
1018 },
1019 {
1020 match_apple,
1021 quirk_apple_glsl_constants,
1022 "Apple GLSL uniform override"
1023 },
1024 {
1025 match_geforce5,
1026 quirk_no_np2,
1027 "Geforce 5 NP2 disable"
1028 },
1029 {
1030 match_apple_intel,
1031 quirk_texcoord_w,
1032 "Init texcoord .w for Apple Intel GPU driver"
1033 },
1034 {
1035 match_apple_nonr500ati,
1036 quirk_texcoord_w,
1037 "Init texcoord .w for Apple ATI >= r600 GPU driver"
1038 },
1039 {
1040 match_dx10_capable,
1041 quirk_clip_varying,
1042 "Reserved varying for gl_ClipPos"
1043 },
1044 {
1045 /* GL_EXT_secondary_color does not allow 4 component secondary colors, but most
1046 * GL implementations accept it. The Mac GL is the only implementation known to
1047 * reject it.
1048 *
1049 * If we can pass 4 component specular colors, do it, because (a) we don't have
1050 * to screw around with the data, and (b) the D3D fixed function vertex pipeline
1051 * passes specular alpha to the pixel shader if any is used. Otherwise the
1052 * specular alpha is used to pass the fog coordinate, which we pass to opengl
1053 * via GL_EXT_fog_coord.
1054 */
1055 match_allows_spec_alpha,
1056 quirk_allows_specular_alpha,
1057 "Allow specular alpha quirk"
1058 },
1059 {
1060 match_broken_nv_clip,
1061 quirk_disable_nvvp_clip,
1062 "Apple NV_vertex_program clip bug quirk"
1063 },
1064 {
1065 match_fbo_tex_update,
1066 quirk_fbo_tex_update,
1067 "FBO rebind for attachment updates"
1068 },
1069 {
1070 match_broken_rgba16,
1071 quirk_broken_rgba16,
1072 "True RGBA16 is not available"
1073 },
1074 {
1075 match_fglrx,
1076 quirk_infolog_spam,
1077 "Not printing GLSL infolog"
1078 },
1079 {
1080 match_not_dx10_capable,
1081 quirk_limited_tex_filtering,
1082 "Texture filtering, blending and VTF support is limited"
1083 },
1084 {
1085 match_r200,
1086 quirk_r200_constants,
1087 "r200 vertex shader constants"
1088 },
1089 {
1090 match_broken_arb_fog,
1091 quirk_broken_arb_fog,
1092 "ARBfp fogstart == fogend workaround"
1093 },
1094 };
1095
1096 /* Certain applications (Steam) complain if we report an outdated driver version. In general,
1097 * reporting a driver version is moot because we are not the Windows driver, and we have different
1098 * bugs, features, etc.
1099 *
1100 * The driver version has the form "x.y.z.w".
1101 *
1102 * "x" is the Windows version the driver is meant for:
1103 * 4 -> 95/98/NT4
1104 * 5 -> 2000
1105 * 6 -> 2000/XP
1106 * 7 -> Vista
1107 * 8 -> Win 7
1108 *
1109 * "y" is the maximum Direct3D version the driver supports.
1110 * y -> d3d version mapping:
1111 * 11 -> d3d6
1112 * 12 -> d3d7
1113 * 13 -> d3d8
1114 * 14 -> d3d9
1115 * 15 -> d3d10
1116 * 16 -> d3d10.1
1117 * 17 -> d3d11
1118 *
1119 * "z" is the subversion number.
1120 *
1121 * "w" is the vendor specific driver build number.
1122 */
1123
1124 struct driver_version_information
1125 {
1126 enum wined3d_display_driver driver;
1127 enum wined3d_driver_model driver_model;
1128 const char *driver_name; /* name of Windows driver */
1129 WORD version; /* version word ('y'), contained in low word of DriverVersion.HighPart */
1130 WORD subversion; /* subversion word ('z'), contained in high word of DriverVersion.LowPart */
1131 WORD build; /* build number ('w'), contained in low word of DriverVersion.LowPart */
1132 };
1133
1134 /* The driver version table contains driver information for different devices on several OS versions. */
1135 static const struct driver_version_information driver_version_table[] =
1136 {
1137 /* AMD
1138 * - Radeon HD2x00 (R600) and up supported by current drivers.
1139 * - Radeon 9500 (R300) - X1*00 (R5xx) supported up to Catalyst 9.3 (Linux) and 10.2 (XP/Vista/Win7)
1140 * - Radeon 7xxx (R100) - 9250 (RV250) supported up to Catalyst 6.11 (XP)
1141 * - Rage 128 supported up to XP, latest official build 6.13.3279 dated October 2001 */
1142 {DRIVER_AMD_RAGE_128PRO, DRIVER_MODEL_NT5X, "ati2dvaa.dll", 13, 3279, 0},
1143 {DRIVER_AMD_R100, DRIVER_MODEL_NT5X, "ati2dvag.dll", 14, 10, 6614},
1144 {DRIVER_AMD_R300, DRIVER_MODEL_NT5X, "ati2dvag.dll", 14, 10, 6764},
1145 {DRIVER_AMD_R600, DRIVER_MODEL_NT5X, "ati2dvag.dll", 14, 10, 8681},
1146 {DRIVER_AMD_R300, DRIVER_MODEL_NT6X, "atiumdag.dll", 14, 10, 741 },
1147 {DRIVER_AMD_R600, DRIVER_MODEL_NT6X, "atiumdag.dll", 14, 10, 741 },
1148
1149 /* Intel
1150 * The drivers are unified but not all versions support all GPUs. At some point the 2k/xp
1151 * drivers used ialmrnt5.dll for GMA800/GMA900 but at some point the file was renamed to
1152 * igxprd32.dll but the GMA800 driver was never updated. */
1153 {DRIVER_INTEL_GMA800, DRIVER_MODEL_NT5X, "ialmrnt5.dll", 14, 10, 3889},
1154 {DRIVER_INTEL_GMA900, DRIVER_MODEL_NT5X, "igxprd32.dll", 14, 10, 4764},
1155 {DRIVER_INTEL_GMA950, DRIVER_MODEL_NT5X, "igxprd32.dll", 14, 10, 4926},
1156 {DRIVER_INTEL_GMA3000, DRIVER_MODEL_NT5X, "igxprd32.dll", 14, 10, 5218},
1157 {DRIVER_INTEL_GMA950, DRIVER_MODEL_NT6X, "igdumd32.dll", 14, 10, 1504},
1158 {DRIVER_INTEL_GMA3000, DRIVER_MODEL_NT6X, "igdumd32.dll", 15, 10, 1666},
1159
1160 /* Nvidia
1161 * - Geforce6 and newer cards are supported by the current driver (197.x) on XP-Win7
1162 * - GeforceFX support is up to 173.x on <= XP
1163 * - Geforce2MX/3/4 up to 96.x on <= XP
1164 * - TNT/Geforce1/2 up to 71.x on <= XP
1165 * All version numbers used below are from the Linux nvidia drivers. */
1166 {DRIVER_NVIDIA_TNT, DRIVER_MODEL_NT5X, "nv4_disp.dll", 14, 10, 7186},
1167 {DRIVER_NVIDIA_GEFORCE2MX, DRIVER_MODEL_NT5X, "nv4_disp.dll", 14, 10, 9371},
1168 {DRIVER_NVIDIA_GEFORCEFX, DRIVER_MODEL_NT5X, "nv4_disp.dll", 14, 11, 7516},
1169 {DRIVER_NVIDIA_GEFORCE6, DRIVER_MODEL_NT5X, "nv4_disp.dll", 15, 12, 6658},
1170 {DRIVER_NVIDIA_GEFORCE6, DRIVER_MODEL_NT6X, "nvd3dum.dll", 15, 12, 6658},
1171
1172 /* VMware */
1173 {DRIVER_VMWARE, DRIVER_MODEL_NT5X, "vm3dum.dll", 14, 1, 1134},
1174 };
1175
1176 struct gpu_description
1177 {
1178 WORD vendor; /* reported PCI card vendor ID */
1179 WORD card; /* reported PCI card device ID */
1180 const char *description; /* Description of the card e.g. NVIDIA RIVA TNT */
1181 enum wined3d_display_driver driver;
1182 unsigned int vidmem;
1183 };
1184
1185 /* The amount of video memory stored in the gpu description table is the minimum amount of video memory
1186 * found on a board containing a specific GPU. */
1187 static const struct gpu_description gpu_description_table[] =
1188 {
1189 /* Nvidia cards */
1190 {HW_VENDOR_NVIDIA, CARD_NVIDIA_RIVA_TNT, "NVIDIA RIVA TNT", DRIVER_NVIDIA_TNT, 16 },
1191 {HW_VENDOR_NVIDIA, CARD_NVIDIA_RIVA_TNT2, "NVIDIA RIVA TNT2/TNT2 Pro", DRIVER_NVIDIA_TNT, 32 },
1192 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE, "NVIDIA GeForce 256", DRIVER_NVIDIA_TNT, 32 },
1193 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE2, "NVIDIA GeForce2 GTS/GeForce2 Pro", DRIVER_NVIDIA_TNT, 32 },
1194 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE2_MX, "NVIDIA GeForce2 MX/MX 400", DRIVER_NVIDIA_GEFORCE2MX,32 },
1195 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE3, "NVIDIA GeForce3", DRIVER_NVIDIA_GEFORCE2MX,64 },
1196 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE4_MX, "NVIDIA GeForce4 MX 460", DRIVER_NVIDIA_GEFORCE2MX,64 },
1197 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE4_TI4200, "NVIDIA GeForce4 Ti 4200", DRIVER_NVIDIA_GEFORCE2MX,64, },
1198 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCEFX_5200, "NVIDIA GeForce FX 5200", DRIVER_NVIDIA_GEFORCEFX, 64 },
1199 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCEFX_5600, "NVIDIA GeForce FX 5600", DRIVER_NVIDIA_GEFORCEFX, 128 },
1200 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCEFX_5800, "NVIDIA GeForce FX 5800", DRIVER_NVIDIA_GEFORCEFX, 256 },
1201 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_6200, "NVIDIA GeForce 6200", DRIVER_NVIDIA_GEFORCE6, 64 },
1202 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_6600GT, "NVIDIA GeForce 6600 GT", DRIVER_NVIDIA_GEFORCE6, 128 },
1203 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_6800, "NVIDIA GeForce 6800", DRIVER_NVIDIA_GEFORCE6, 128 },
1204 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7300, "NVIDIA GeForce Go 7300", DRIVER_NVIDIA_GEFORCE6, 256 },
1205 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7400, "NVIDIA GeForce Go 7400", DRIVER_NVIDIA_GEFORCE6, 256 },
1206 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7600, "NVIDIA GeForce 7600 GT", DRIVER_NVIDIA_GEFORCE6, 256 },
1207 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7800GT, "NVIDIA GeForce 7800 GT", DRIVER_NVIDIA_GEFORCE6, 256 },
1208 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8300GS, "NVIDIA GeForce 8300 GS", DRIVER_NVIDIA_GEFORCE6, 128 },
1209 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8400GS, "NVIDIA GeForce 8400 GS", DRIVER_NVIDIA_GEFORCE6, 128 },
1210 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8600GT, "NVIDIA GeForce 8600 GT", DRIVER_NVIDIA_GEFORCE6, 256 },
1211 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8600MGT, "NVIDIA GeForce 8600M GT", DRIVER_NVIDIA_GEFORCE6, 512 },
1212 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8800GTS, "NVIDIA GeForce 8800 GTS", DRIVER_NVIDIA_GEFORCE6, 320 },
1213 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8800GTX, "NVIDIA GeForce 8800 GTX", DRIVER_NVIDIA_GEFORCE6, 768 },
1214 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9200, "NVIDIA GeForce 9200", DRIVER_NVIDIA_GEFORCE6, 256 },
1215 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9300, "NVIDIA GeForce 9300", DRIVER_NVIDIA_GEFORCE6, 256 },
1216 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9400M, "NVIDIA GeForce 9400M", DRIVER_NVIDIA_GEFORCE6, 256 },
1217 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9400GT, "NVIDIA GeForce 9400 GT", DRIVER_NVIDIA_GEFORCE6, 256 },
1218 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9500GT, "NVIDIA GeForce 9500 GT", DRIVER_NVIDIA_GEFORCE6, 256 },
1219 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9600GT, "NVIDIA GeForce 9600 GT", DRIVER_NVIDIA_GEFORCE6, 384 },
1220 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9800GT, "NVIDIA GeForce 9800 GT", DRIVER_NVIDIA_GEFORCE6, 512 },
1221 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_210, "NVIDIA GeForce 210", DRIVER_NVIDIA_GEFORCE6, 512 },
1222 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT220, "NVIDIA GeForce GT 220", DRIVER_NVIDIA_GEFORCE6, 512 },
1223 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT240, "NVIDIA GeForce GT 240", DRIVER_NVIDIA_GEFORCE6, 512 },
1224 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX260, "NVIDIA GeForce GTX 260", DRIVER_NVIDIA_GEFORCE6, 1024},
1225 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX275, "NVIDIA GeForce GTX 275", DRIVER_NVIDIA_GEFORCE6, 896 },
1226 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX280, "NVIDIA GeForce GTX 280", DRIVER_NVIDIA_GEFORCE6, 1024},
1227 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_315M, "NVIDIA GeForce 315M", DRIVER_NVIDIA_GEFORCE6, 512 },
1228 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_320M, "NVIDIA GeForce 320M", DRIVER_NVIDIA_GEFORCE6, 256},
1229 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_410M, "NVIDIA GeForce 410M", DRIVER_NVIDIA_GEFORCE6, 512},
1230 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT320M, "NVIDIA GeForce GT 320M", DRIVER_NVIDIA_GEFORCE6, 1024},
1231 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT325M, "NVIDIA GeForce GT 325M", DRIVER_NVIDIA_GEFORCE6, 1024},
1232 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT330, "NVIDIA GeForce GT 330", DRIVER_NVIDIA_GEFORCE6, 1024},
1233 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTS350M, "NVIDIA GeForce GTS 350M", DRIVER_NVIDIA_GEFORCE6, 1024},
1234 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT420, "NVIDIA GeForce GT 420", DRIVER_NVIDIA_GEFORCE6, 2048},
1235 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT430, "NVIDIA GeForce GT 430", DRIVER_NVIDIA_GEFORCE6, 1024},
1236 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT440, "NVIDIA GeForce GT 440", DRIVER_NVIDIA_GEFORCE6, 1024},
1237 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTS450, "NVIDIA GeForce GTS 450", DRIVER_NVIDIA_GEFORCE6, 1024},
1238 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX460, "NVIDIA GeForce GTX 460", DRIVER_NVIDIA_GEFORCE6, 768 },
1239 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX460M, "NVIDIA GeForce GTX 460M", DRIVER_NVIDIA_GEFORCE6, 1536},
1240 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX465, "NVIDIA GeForce GTX 465", DRIVER_NVIDIA_GEFORCE6, 1024},
1241 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX470, "NVIDIA GeForce GTX 470", DRIVER_NVIDIA_GEFORCE6, 1280},
1242 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX480, "NVIDIA GeForce GTX 480", DRIVER_NVIDIA_GEFORCE6, 1536},
1243 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT520, "NVIDIA GeForce GT 520", DRIVER_NVIDIA_GEFORCE6, 1024},
1244 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT540M, "NVIDIA GeForce GT 540M", DRIVER_NVIDIA_GEFORCE6, 1024},
1245 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX550, "NVIDIA GeForce GTX 550 Ti", DRIVER_NVIDIA_GEFORCE6, 1024},
1246 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT555M, "NVIDIA GeForce GT 555M", DRIVER_NVIDIA_GEFORCE6, 1024},
1247 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX560TI, "NVIDIA GeForce GTX 560 Ti", DRIVER_NVIDIA_GEFORCE6, 1024},
1248 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX560, "NVIDIA GeForce GTX 560", DRIVER_NVIDIA_GEFORCE6, 1024},
1249 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX570, "NVIDIA GeForce GTX 570", DRIVER_NVIDIA_GEFORCE6, 1280},
1250 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX580, "NVIDIA GeForce GTX 580", DRIVER_NVIDIA_GEFORCE6, 1536},
1251 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT610, "NVIDIA GeForce GT 610", DRIVER_NVIDIA_GEFORCE6, 1024},
1252 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT630, "NVIDIA GeForce GT 630", DRIVER_NVIDIA_GEFORCE6, 1024},
1253 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT630M, "NVIDIA GeForce GT 630M", DRIVER_NVIDIA_GEFORCE6, 1024},
1254 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT640M, "NVIDIA GeForce GT 640M", DRIVER_NVIDIA_GEFORCE6, 1024},
1255 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT650M, "NVIDIA GeForce GT 650M", DRIVER_NVIDIA_GEFORCE6, 2048},
1256 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX650, "NVIDIA GeForce GTX 650", DRIVER_NVIDIA_GEFORCE6, 1024},
1257 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX650TI, "NVIDIA GeForce GTX 650 Ti", DRIVER_NVIDIA_GEFORCE6, 1024},
1258 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX660, "NVIDIA GeForce GTX 660", DRIVER_NVIDIA_GEFORCE6, 2048},
1259 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX660M, "NVIDIA GeForce GTX 660M", DRIVER_NVIDIA_GEFORCE6, 2048},
1260 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX660TI, "NVIDIA GeForce GTX 660 Ti", DRIVER_NVIDIA_GEFORCE6, 2048},
1261 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX670, "NVIDIA GeForce GTX 670", DRIVER_NVIDIA_GEFORCE6, 2048},
1262 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX670MX, "NVIDIA GeForce GTX 670MX", DRIVER_NVIDIA_GEFORCE6, 3072},
1263 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX680, "NVIDIA GeForce GTX 680", DRIVER_NVIDIA_GEFORCE6, 2048},
1264 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX750, "NVIDIA GeForce GTX 750", DRIVER_NVIDIA_GEFORCE6, 1024},
1265 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX750TI, "NVIDIA GeForce GTX 750 Ti", DRIVER_NVIDIA_GEFORCE6, 2048},
1266 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX760, "NVIDIA Geforce GTX 760", DRIVER_NVIDIA_GEFORCE6, 2048},
1267 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX765M, "NVIDIA GeForce GTX 765M", DRIVER_NVIDIA_GEFORCE6, 2048},
1268 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX770M, "NVIDIA GeForce GTX 770M", DRIVER_NVIDIA_GEFORCE6, 3072},
1269 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX770, "NVIDIA GeForce GTX 770", DRIVER_NVIDIA_GEFORCE6, 2048},
1270
1271 /* AMD cards */
1272 {HW_VENDOR_AMD, CARD_AMD_RAGE_128PRO, "ATI Rage Fury", DRIVER_AMD_RAGE_128PRO, 16 },
1273 {HW_VENDOR_AMD, CARD_AMD_RADEON_7200, "ATI RADEON 7200 SERIES", DRIVER_AMD_R100, 32 },
1274 {HW_VENDOR_AMD, CARD_AMD_RADEON_8500, "ATI RADEON 8500 SERIES", DRIVER_AMD_R100, 64 },
1275 {HW_VENDOR_AMD, CARD_AMD_RADEON_9500, "ATI Radeon 9500", DRIVER_AMD_R300, 64 },
1276 {HW_VENDOR_AMD, CARD_AMD_RADEON_XPRESS_200M, "ATI RADEON XPRESS 200M Series", DRIVER_AMD_R300, 64 },
1277 {HW_VENDOR_AMD, CARD_AMD_RADEON_X700, "ATI Radeon X700 SE", DRIVER_AMD_R300, 128 },
1278 {HW_VENDOR_AMD, CARD_AMD_RADEON_X1600, "ATI Radeon X1600 Series", DRIVER_AMD_R300, 128 },
1279 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD2350, "ATI Mobility Radeon HD 2350", DRIVER_AMD_R600, 256 },
1280 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD2600, "ATI Mobility Radeon HD 2600", DRIVER_AMD_R600, 256 },
1281 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD2900, "ATI Radeon HD 2900 XT", DRIVER_AMD_R600, 512 },
1282 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD3200, "ATI Radeon HD 3200 Graphics", DRIVER_AMD_R600, 128 },
1283 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD4200M, "ATI Mobility Radeon HD 4200", DRIVER_AMD_R600, 256 },
1284 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD4350, "ATI Radeon HD 4350", DRIVER_AMD_R600, 256 },
1285 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD4600, "ATI Radeon HD 4600 Series", DRIVER_AMD_R600, 512 },
1286 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD4700, "ATI Radeon HD 4700 Series", DRIVER_AMD_R600, 512 },
1287 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD4800, "ATI Radeon HD 4800 Series", DRIVER_AMD_R600, 512 },
1288 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD5400, "ATI Radeon HD 5400 Series", DRIVER_AMD_R600, 512 },
1289 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD5600, "ATI Radeon HD 5600 Series", DRIVER_AMD_R600, 512 },
1290 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD5700, "ATI Radeon HD 5700 Series", DRIVER_AMD_R600, 512 },
1291 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD5800, "ATI Radeon HD 5800 Series", DRIVER_AMD_R600, 1024},
1292 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD5900, "ATI Radeon HD 5900 Series", DRIVER_AMD_R600, 1024},
1293 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD6300, "AMD Radeon HD 6300 series Graphics", DRIVER_AMD_R600, 1024},
1294 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD6400, "AMD Radeon HD 6400 Series", DRIVER_AMD_R600, 1024},
1295 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD6410D, "AMD Radeon HD 6410D", DRIVER_AMD_R600, 1024},
1296 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD6550D, "AMD Radeon HD 6550D", DRIVER_AMD_R600, 1024},
1297 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD6600, "AMD Radeon HD 6600 Series", DRIVER_AMD_R600, 1024},
1298 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD6600M, "AMD Radeon HD 6600M Series", DRIVER_AMD_R600, 512 },
1299 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD6700, "AMD Radeon HD 6700 Series", DRIVER_AMD_R600, 1024},
1300 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD6800, "AMD Radeon HD 6800 Series", DRIVER_AMD_R600, 1024},
1301 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD6900, "AMD Radeon HD 6900 Series", DRIVER_AMD_R600, 2048},
1302 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD7700, "AMD Radeon HD 7700 Series", DRIVER_AMD_R600, 1024},
1303 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD7800, "AMD Radeon HD 7800 Series", DRIVER_AMD_R600, 2048},
1304 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD7900, "AMD Radeon HD 7900 Series", DRIVER_AMD_R600, 2048},
1305
1306 /* VMware */
1307 {HW_VENDOR_VMWARE, CARD_VMWARE_SVGA3D, "VMware SVGA 3D (Microsoft Corporation - WDDM)", DRIVER_VMWARE, 1024},
1308
1309 /* Intel cards */
1310 {HW_VENDOR_INTEL, CARD_INTEL_830M, "Intel(R) 82830M Graphics Controller", DRIVER_INTEL_GMA800, 32 },
1311 {HW_VENDOR_INTEL, CARD_INTEL_855GM, "Intel(R) 82852/82855 GM/GME Graphics Controller", DRIVER_INTEL_GMA800, 32 },
1312 {HW_VENDOR_INTEL, CARD_INTEL_845G, "Intel(R) 845G", DRIVER_INTEL_GMA800, 32 },
1313 {HW_VENDOR_INTEL, CARD_INTEL_865G, "Intel(R) 82865G Graphics Controller", DRIVER_INTEL_GMA800, 32 },
1314 {HW_VENDOR_INTEL, CARD_INTEL_915G, "Intel(R) 82915G/GV/910GL Express Chipset Family", DRIVER_INTEL_GMA900, 64 },
1315 {HW_VENDOR_INTEL, CARD_INTEL_E7221G, "Intel(R) E7221G", DRIVER_INTEL_GMA900, 64 },
1316 {HW_VENDOR_INTEL, CARD_INTEL_915GM, "Mobile Intel(R) 915GM/GMS,910GML Express Chipset Family", DRIVER_INTEL_GMA900, 64 },
1317 {HW_VENDOR_INTEL, CARD_INTEL_945G, "Intel(R) 945G", DRIVER_INTEL_GMA950, 64 },
1318 {HW_VENDOR_INTEL, CARD_INTEL_945GM, "Mobile Intel(R) 945GM Express Chipset Family", DRIVER_INTEL_GMA950, 64 },
1319 {HW_VENDOR_INTEL, CARD_INTEL_945GME, "Intel(R) 945GME", DRIVER_INTEL_GMA950, 64 },
1320 {HW_VENDOR_INTEL, CARD_INTEL_Q35, "Intel(R) Q35", DRIVER_INTEL_GMA950, 64 },
1321 {HW_VENDOR_INTEL, CARD_INTEL_G33, "Intel(R) G33", DRIVER_INTEL_GMA950, 64 },
1322 {HW_VENDOR_INTEL, CARD_INTEL_Q33, "Intel(R) Q33", DRIVER_INTEL_GMA950, 64 },
1323 {HW_VENDOR_INTEL, CARD_INTEL_PNVG, "Intel(R) IGD", DRIVER_INTEL_GMA950, 64 },
1324 {HW_VENDOR_INTEL, CARD_INTEL_PNVM, "Intel(R) IGD", DRIVER_INTEL_GMA950, 64 },
1325 {HW_VENDOR_INTEL, CARD_INTEL_965Q, "Intel(R) 965Q", DRIVER_INTEL_GMA3000, 128},
1326 {HW_VENDOR_INTEL, CARD_INTEL_965G, "Intel(R) 965G", DRIVER_INTEL_GMA3000, 128},
1327 {HW_VENDOR_INTEL, CARD_INTEL_946GZ, "Intel(R) 946GZ", DRIVER_INTEL_GMA3000, 128},
1328 {HW_VENDOR_INTEL, CARD_INTEL_965GM, "Mobile Intel(R) 965 Express Chipset Family", DRIVER_INTEL_GMA3000, 128},
1329 {HW_VENDOR_INTEL, CARD_INTEL_965GME, "Intel(R) 965GME", DRIVER_INTEL_GMA3000, 128},
1330 {HW_VENDOR_INTEL, CARD_INTEL_GM45, "Mobile Intel(R) GM45 Express Chipset Family", DRIVER_INTEL_GMA3000, 512},
1331 {HW_VENDOR_INTEL, CARD_INTEL_IGD, "Intel(R) Integrated Graphics Device", DRIVER_INTEL_GMA3000, 512},
1332 {HW_VENDOR_INTEL, CARD_INTEL_G45, "Intel(R) G45/G43", DRIVER_INTEL_GMA3000, 512},
1333 {HW_VENDOR_INTEL, CARD_INTEL_Q45, "Intel(R) Q45/Q43", DRIVER_INTEL_GMA3000, 512},
1334 {HW_VENDOR_INTEL, CARD_INTEL_G41, "Intel(R) G41", DRIVER_INTEL_GMA3000, 512},
1335 {HW_VENDOR_INTEL, CARD_INTEL_B43, "Intel(R) B43", DRIVER_INTEL_GMA3000, 512},
1336 {HW_VENDOR_INTEL, CARD_INTEL_ILKD, "Intel(R) Ironlake Desktop", DRIVER_INTEL_GMA3000, 1024},
1337 {HW_VENDOR_INTEL, CARD_INTEL_ILKM, "Intel(R) Ironlake Mobile", DRIVER_INTEL_GMA3000, 1024},
1338 {HW_VENDOR_INTEL, CARD_INTEL_SNBD, "Intel(R) Sandybridge Desktop", DRIVER_INTEL_GMA3000, 1024},
1339 {HW_VENDOR_INTEL, CARD_INTEL_SNBM, "Intel(R) Sandybridge Mobile", DRIVER_INTEL_GMA3000, 1024},
1340 {HW_VENDOR_INTEL, CARD_INTEL_SNBS, "Intel(R) Sandybridge Server", DRIVER_INTEL_GMA3000, 1024},
1341 {HW_VENDOR_INTEL, CARD_INTEL_IVBD, "Intel(R) Ivybridge Desktop", DRIVER_INTEL_GMA3000, 1024},
1342 {HW_VENDOR_INTEL, CARD_INTEL_IVBM, "Intel(R) Ivybridge Mobile", DRIVER_INTEL_GMA3000, 1024},
1343 {HW_VENDOR_INTEL, CARD_INTEL_IVBS, "Intel(R) Ivybridge Server", DRIVER_INTEL_GMA3000, 1024},
1344 {HW_VENDOR_INTEL, CARD_INTEL_HWM, "Intel(R) Haswell Mobile", DRIVER_INTEL_GMA3000, 1024},
1345 };
1346
1347 static const struct driver_version_information *get_driver_version_info(enum wined3d_display_driver driver,
1348 enum wined3d_driver_model driver_model)
1349 {
1350 unsigned int i;
1351
1352 TRACE("Looking up version info for driver=%d driver_model=%d\n", driver, driver_model);
1353 for (i = 0; i < (sizeof(driver_version_table) / sizeof(driver_version_table[0])); i++)
1354 {
1355 const struct driver_version_information *entry = &driver_version_table[i];
1356
1357 if (entry->driver == driver && entry->driver_model == driver_model)
1358 {
1359 TRACE("Found driver \"%s\", version %u, subversion %u, build %u.\n",
1360 entry->driver_name, entry->version, entry->subversion, entry->build);
1361 return entry;
1362 }
1363 }
1364 return NULL;
1365 }
1366
1367 static void init_driver_info(struct wined3d_driver_info *driver_info,
1368 enum wined3d_pci_vendor vendor, enum wined3d_pci_device device)
1369 {
1370 OSVERSIONINFOW os_version;
1371 WORD driver_os_version;
1372 unsigned int i;
1373 enum wined3d_display_driver driver = DRIVER_UNKNOWN;
1374 enum wined3d_driver_model driver_model;
1375 const struct driver_version_information *version_info;
1376
1377 if (wined3d_settings.pci_vendor_id != PCI_VENDOR_NONE)
1378 {
1379 TRACE("Overriding PCI vendor ID with 0x%04x.\n", wined3d_settings.pci_vendor_id);
1380 vendor = wined3d_settings.pci_vendor_id;
1381 }
1382 driver_info->vendor = vendor;
1383
1384 if (wined3d_settings.pci_device_id != PCI_DEVICE_NONE)
1385 {
1386 TRACE("Overriding PCI device ID with 0x%04x.\n", wined3d_settings.pci_device_id);
1387 device = wined3d_settings.pci_device_id;
1388 }
1389 driver_info->device = device;
1390
1391 /* Set a default amount of video memory (64 MB). In general this code isn't used unless the user
1392 * overrides the pci ids to a card which is not in our database. */
1393 driver_info->vidmem = WINE_DEFAULT_VIDMEM;
1394
1395 memset(&os_version, 0, sizeof(os_version));
1396 os_version.dwOSVersionInfoSize = sizeof(os_version);
1397 if (!GetVersionExW(&os_version))
1398 {
1399 ERR("Failed to get OS version, reporting 2000/XP.\n");
1400 driver_os_version = 6;
1401 driver_model = DRIVER_MODEL_NT5X;
1402 }
1403 else
1404 {
1405 TRACE("OS version %u.%u.\n", os_version.dwMajorVersion, os_version.dwMinorVersion);
1406 switch (os_version.dwMajorVersion)
1407 {
1408 case 4:
1409 /* If needed we could distinguish between 9x and NT4, but this code won't make
1410 * sense for NT4 since it had no way to obtain this info through DirectDraw 3.0.
1411 */
1412 driver_os_version = 4;
1413 driver_model = DRIVER_MODEL_WIN9X;
1414 break;
1415
1416 case 5:
1417 driver_os_version = 6;
1418 driver_model = DRIVER_MODEL_NT5X;
1419 break;
1420
1421 case 6:
1422 if (os_version.dwMinorVersion == 0)
1423 {
1424 driver_os_version = 7;
1425 driver_model = DRIVER_MODEL_NT6X;
1426 }
1427 else if (os_version.dwMinorVersion == 1)
1428 {
1429 driver_os_version = 8;
1430 driver_model = DRIVER_MODEL_NT6X;
1431 }
1432 else
1433 {
1434 if (os_version.dwMinorVersion > 2)
1435 {
1436 FIXME("Unhandled OS version %u.%u, reporting Win 8.\n",
1437 os_version.dwMajorVersion, os_version.dwMinorVersion);
1438 }
1439 driver_os_version = 9;
1440 driver_model = DRIVER_MODEL_NT6X;
1441 }
1442 break;
1443
1444 default:
1445 FIXME("Unhandled OS version %u.%u, reporting 2000/XP.\n",
1446 os_version.dwMajorVersion, os_version.dwMinorVersion);
1447 driver_os_version = 6;
1448 driver_model = DRIVER_MODEL_NT5X;
1449 break;
1450 }
1451 }
1452
1453 /* When we reach this stage we always have a vendor or device id (it can be a default one).
1454 * This means that unless the ids are overridden, we will always find a GPU description. */
1455 for (i = 0; i < (sizeof(gpu_description_table) / sizeof(gpu_description_table[0])); i++)
1456 {
1457 if (vendor == gpu_description_table[i].vendor && device == gpu_description_table[i].card)
1458 {
1459 TRACE("Found card %04x:%04x in driver DB.\n", vendor, device);
1460
1461 driver_info->description = gpu_description_table[i].description;
1462 driver_info->vidmem = gpu_description_table[i].vidmem * 1024*1024;
1463 driver = gpu_description_table[i].driver;
1464 break;
1465 }
1466 }
1467
1468 if (wined3d_settings.emulated_textureram)
1469 {
1470 TRACE("Overriding amount of video memory with %u bytes.\n", wined3d_settings.emulated_textureram);
1471 driver_info->vidmem = wined3d_settings.emulated_textureram;
1472 }
1473
1474 /* Try to obtain driver version information for the current Windows version. This fails in
1475 * some cases:
1476 * - the gpu is not available on the currently selected OS version:
1477 * - Geforce GTX480 on Win98. When running applications in compatibility mode on Windows,
1478 * version information for the current Windows version is returned instead of faked info.
1479 * We do the same and assume the default Windows version to emulate is WinXP.
1480 *
1481 * - Videocard is a Riva TNT but winver is set to win7 (there are no drivers for this beast)
1482 * For now return the XP driver info. Perhaps later on we should return VESA.
1483 *
1484 * - the gpu is not in our database (can happen when the user overrides the vendor_id / device_id)
1485 * This could be an indication that our database is not up to date, so this should be fixed.
1486 */
1487 version_info = get_driver_version_info(driver, driver_model);
1488 if (version_info)
1489 {
1490 driver_info->name = version_info->driver_name;
1491 driver_info->version_high = MAKEDWORD_VERSION(driver_os_version, version_info->version);
1492 driver_info->version_low = MAKEDWORD_VERSION(version_info->subversion, version_info->build);
1493 }
1494 else
1495 {
1496 version_info = get_driver_version_info(driver, DRIVER_MODEL_NT5X);
1497 if (version_info)
1498 {
1499 driver_info->name = version_info->driver_name;
1500 driver_info->version_high = MAKEDWORD_VERSION(driver_os_version, version_info->version);
1501 driver_info->version_low = MAKEDWORD_VERSION(version_info->subversion, version_info->build);
1502 }
1503 else
1504 {
1505 driver_info->description = "Direct3D HAL";
1506 driver_info->name = "Display";
1507 driver_info->version_high = MAKEDWORD_VERSION(driver_os_version, 15);
1508 driver_info->version_low = MAKEDWORD_VERSION(8, 6); /* Nvidia RIVA TNT, arbitrary */
1509
1510 FIXME("Unable to find a driver/device info for vendor_id=%#x device_id=%#x for driver_model=%d\n",
1511 vendor, device, driver_model);
1512 }
1513 }
1514
1515 TRACE("Reporting (fake) driver version 0x%08x-0x%08x.\n",
1516 driver_info->version_high, driver_info->version_low);
1517 }
1518
1519 /* Context activation is done by the caller. */
1520 static void fixup_extensions(struct wined3d_gl_info *gl_info, const char *gl_renderer,
1521 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
1522 {
1523 unsigned int i;
1524
1525 for (i = 0; i < (sizeof(quirk_table) / sizeof(*quirk_table)); ++i)
1526 {
1527 if (!quirk_table[i].match(gl_info, gl_renderer, gl_vendor, card_vendor, device)) continue;
1528 TRACE("Applying driver quirk \"%s\".\n", quirk_table[i].description);
1529 quirk_table[i].apply(gl_info);
1530 }
1531
1532 /* Find out if PBOs work as they are supposed to. */
1533 test_pbo_functionality(gl_info);
1534 }
1535
1536 static DWORD wined3d_parse_gl_version(const char *gl_version)
1537 {
1538 const char *ptr = gl_version;
1539 int major, minor;
1540
1541 major = atoi(ptr);
1542 if (major <= 0)
1543 ERR("Invalid OpenGL major version %d.\n", major);
1544
1545 while (isdigit(*ptr)) ++ptr;
1546 if (*ptr++ != '.')
1547 ERR("Invalid OpenGL version string %s.\n", debugstr_a(gl_version));
1548
1549 minor = atoi(ptr);
1550
1551 TRACE("Found OpenGL version %d.%d.\n", major, minor);
1552
1553 return MAKEDWORD_VERSION(major, minor);
1554 }
1555
1556 static enum wined3d_gl_vendor wined3d_guess_gl_vendor(const struct wined3d_gl_info *gl_info,
1557 const char *gl_vendor_string, const char *gl_renderer)
1558 {
1559
1560 /* MacOS has various specialities in the extensions it advertises. Some have to be loaded from
1561 * the opengl 1.2+ core, while other extensions are advertised, but software emulated. So try to
1562 * detect the Apple OpenGL implementation to apply some extension fixups afterwards.
1563 *
1564 * Detecting this isn't really easy. The vendor string doesn't mention Apple. Compile-time checks
1565 * aren't sufficient either because a Linux binary may display on a macos X server via remote X11.
1566 * So try to detect the GL implementation by looking at certain Apple extensions. Some extensions
1567 * like client storage might be supported on other implementations too, but GL_APPLE_flush_render
1568 * is specific to the Mac OS X window management, and GL_APPLE_ycbcr_422 is QuickTime specific. So
1569 * the chance that other implementations support them is rather small since Win32 QuickTime uses
1570 * DirectDraw, not OpenGL. */
1571 if (gl_info->supported[APPLE_FENCE]
1572 && gl_info->supported[APPLE_CLIENT_STORAGE]
1573 && gl_info->supported[APPLE_YCBCR_422])
1574 return GL_VENDOR_APPLE;
1575
1576 if (strstr(gl_vendor_string, "NVIDIA"))
1577 return GL_VENDOR_NVIDIA;
1578
1579 if (strstr(gl_vendor_string, "ATI"))
1580 return GL_VENDOR_FGLRX;
1581
1582 if (strstr(gl_vendor_string, "Mesa")
1583 || strstr(gl_vendor_string, "X.Org")
1584 || strstr(gl_vendor_string, "Advanced Micro Devices, Inc.")
1585 || strstr(gl_vendor_string, "DRI R300 Project")
1586 || strstr(gl_vendor_string, "Tungsten Graphics, Inc")
1587 || strstr(gl_vendor_string, "VMware, Inc.")
1588 || strstr(gl_vendor_string, "Intel")
1589 || strstr(gl_renderer, "Mesa")
1590 || strstr(gl_renderer, "Gallium")
1591 || strstr(gl_renderer, "Intel"))
1592 return GL_VENDOR_MESA;
1593
1594 FIXME("Received unrecognized GL_VENDOR %s. Returning GL_VENDOR_UNKNOWN.\n",
1595 debugstr_a(gl_vendor_string));
1596
1597 return GL_VENDOR_UNKNOWN;
1598 }
1599
1600 static enum wined3d_pci_vendor wined3d_guess_card_vendor(const char *gl_vendor_string, const char *gl_renderer)
1601 {
1602 if (strstr(gl_vendor_string, "NVIDIA")
1603 || strstr(gl_vendor_string, "Nouveau")
1604 || strstr(gl_vendor_string, "nouveau"))
1605 return HW_VENDOR_NVIDIA;
1606
1607 if (strstr(gl_vendor_string, "ATI")
1608 || strstr(gl_vendor_string, "Advanced Micro Devices, Inc.")
1609 || strstr(gl_vendor_string, "X.Org R300 Project")
1610 || strstr(gl_renderer, "AMD")
1611 || strstr(gl_renderer, "R100")
1612 || strstr(gl_renderer, "R200")
1613 || strstr(gl_renderer, "R300")
1614 || strstr(gl_renderer, "R600")
1615 || strstr(gl_renderer, "R700"))
1616 return HW_VENDOR_AMD;
1617
1618 if (strstr(gl_vendor_string, "Intel(R)")
1619 /* Intel switched from Intel(R) to Intel® recently, so just match Intel. */
1620 || strstr(gl_renderer, "Intel")
1621 || strstr(gl_renderer, "i915")
1622 || strstr(gl_vendor_string, "Intel Inc."))
1623 return HW_VENDOR_INTEL;
1624
1625 if (strstr(gl_renderer, "SVGA3D"))
1626 return HW_VENDOR_VMWARE;
1627
1628 if (strstr(gl_vendor_string, "Mesa")
1629 || strstr(gl_vendor_string, "Brian Paul")
1630 || strstr(gl_vendor_string, "Tungsten Graphics, Inc")
1631 || strstr(gl_vendor_string, "VMware, Inc."))
1632 return HW_VENDOR_SOFTWARE;
1633
1634 FIXME("Received unrecognized GL_VENDOR %s. Returning HW_VENDOR_NVIDIA.\n", debugstr_a(gl_vendor_string));
1635
1636 return HW_VENDOR_NVIDIA;
1637 }
1638
1639 static UINT d3d_level_from_gl_info(const struct wined3d_gl_info *gl_info)
1640 {
1641 UINT level = 0;
1642
1643 if (gl_info->supported[ARB_MULTITEXTURE])
1644 level = 6;
1645 if (gl_info->supported[ARB_TEXTURE_COMPRESSION]
1646 && gl_info->supported[ARB_TEXTURE_CUBE_MAP]
1647 && gl_info->supported[ARB_TEXTURE_ENV_DOT3])
1648 level = 7;
1649 if (level == 7 && gl_info->supported[ARB_MULTISAMPLE]
1650 && gl_info->supported[ARB_TEXTURE_BORDER_CLAMP])
1651 level = 8;
1652 if (level == 8 && gl_info->supported[ARB_FRAGMENT_PROGRAM]
1653 && gl_info->supported[ARB_VERTEX_SHADER])
1654 level = 9;
1655 if (level == 9 && gl_info->supported[EXT_GPU_SHADER4])
1656 level = 10;
1657
1658 return level;
1659 }
1660
1661 static enum wined3d_pci_device select_card_nvidia_binary(const struct wined3d_gl_info *gl_info,
1662 const char *gl_renderer)
1663 {
1664 UINT d3d_level = d3d_level_from_gl_info(gl_info);
1665 unsigned int i;
1666
1667 if (d3d_level >= 10)
1668 {
1669 static const struct
1670 {
1671 const char *renderer;
1672 enum wined3d_pci_device id;
1673 }
1674 cards[] =
1675 {
1676 {"GTX 770M", CARD_NVIDIA_GEFORCE_GTX770M}, /* Geforce 700 - midend high mobile */
1677 {"GTX 770", CARD_NVIDIA_GEFORCE_GTX770}, /* Geforce 700 - highend */
1678 {"GTX 765M", CARD_NVIDIA_GEFORCE_GTX765M}, /* Geforce 700 - midend high mobile */
1679 {"GTX 760", CARD_NVIDIA_GEFORCE_GTX760}, /* Geforce 700 - midend high */
1680 {"GTX 750 Ti", CARD_NVIDIA_GEFORCE_GTX750TI}, /* Geforce 700 - midend */
1681 {"GTX 750", CARD_NVIDIA_GEFORCE_GTX750}, /* Geforce 700 - midend */
1682 {"GTX 680", CARD_NVIDIA_GEFORCE_GTX680}, /* Geforce 600 - highend */
1683 {"GTX 670MX", CARD_NVIDIA_GEFORCE_GTX670MX}, /* Geforce 600 - highend */
1684 {"GTX 670", CARD_NVIDIA_GEFORCE_GTX670}, /* Geforce 600 - midend high */
1685 {"GTX 660 Ti", CARD_NVIDIA_GEFORCE_GTX660TI}, /* Geforce 600 - midend high */
1686 {"GTX 660M", CARD_NVIDIA_GEFORCE_GTX660M}, /* Geforce 600 - midend high mobile */
1687 {"GTX 660", CARD_NVIDIA_GEFORCE_GTX660}, /* Geforce 600 - midend high */
1688 {"GTX 650 Ti", CARD_NVIDIA_GEFORCE_GTX650TI}, /* Geforce 600 - lowend */
1689 {"GTX 650", CARD_NVIDIA_GEFORCE_GTX650}, /* Geforce 600 - lowend */
1690 {"GT 650M", CARD_NVIDIA_GEFORCE_GT650M}, /* Geforce 600 - midend mobile */
1691 {"GT 640M", CARD_NVIDIA_GEFORCE_GT640M}, /* Geforce 600 - midend mobile */
1692 {"GT 630M", CARD_NVIDIA_GEFORCE_GT630M}, /* Geforce 600 - midend mobile */
1693 {"GT 630", CARD_NVIDIA_GEFORCE_GT630}, /* Geforce 600 - lowend */
1694 {"GT 610", CARD_NVIDIA_GEFORCE_GT610}, /* Geforce 600 - lowend */
1695 {"GTX 580", CARD_NVIDIA_GEFORCE_GTX580}, /* Geforce 500 - highend */
1696 {"GTX 570", CARD_NVIDIA_GEFORCE_GTX570}, /* Geforce 500 - midend high */
1697 {"GTX 560 Ti", CARD_NVIDIA_GEFORCE_GTX560TI}, /* Geforce 500 - midend */
1698 {"GTX 560", CARD_NVIDIA_GEFORCE_GTX560}, /* Geforce 500 - midend */
1699 {"GT 555M", CARD_NVIDIA_GEFORCE_GT555M}, /* Geforce 500 - midend mobile */
1700 {"GTX 550 Ti", CARD_NVIDIA_GEFORCE_GTX550}, /* Geforce 500 - midend */
1701 {"GT 540M", CARD_NVIDIA_GEFORCE_GT540M}, /* Geforce 500 - midend mobile */
1702 {"GT 520", CARD_NVIDIA_GEFORCE_GT520}, /* Geforce 500 - lowend */
1703 {"GTX 480", CARD_NVIDIA_GEFORCE_GTX480}, /* Geforce 400 - highend */
1704 {"GTX 470", CARD_NVIDIA_GEFORCE_GTX470}, /* Geforce 400 - midend high */
1705 {"GTX 465", CARD_NVIDIA_GEFORCE_GTX465}, /* Geforce 400 - midend */
1706 {"GTX 460M", CARD_NVIDIA_GEFORCE_GTX460M}, /* Geforce 400 - highend mobile */
1707 {"GTX 460", CARD_NVIDIA_GEFORCE_GTX460}, /* Geforce 400 - midend */
1708 {"GTS 450", CARD_NVIDIA_GEFORCE_GTS450}, /* Geforce 400 - midend low */
1709 {"GT 440", CARD_NVIDIA_GEFORCE_GT440}, /* Geforce 400 - lowend */
1710 {"GT 430", CARD_NVIDIA_GEFORCE_GT430}, /* Geforce 400 - lowend */
1711 {"GT 420", CARD_NVIDIA_GEFORCE_GT420}, /* Geforce 400 - lowend */
1712 {"410M", CARD_NVIDIA_GEFORCE_410M}, /* Geforce 400 - lowend mobile */
1713 {"GT 330", CARD_NVIDIA_GEFORCE_GT330}, /* Geforce 300 - highend */
1714 {"GTS 360M", CARD_NVIDIA_GEFORCE_GTS350M}, /* Geforce 300 - highend mobile */
1715 {"GTS 350M", CARD_NVIDIA_GEFORCE_GTS350M}, /* Geforce 300 - highend mobile */
1716 {"GT 330M", CARD_NVIDIA_GEFORCE_GT325M}, /* Geforce 300 - midend mobile */
1717 {"GT 325M", CARD_NVIDIA_GEFORCE_GT325M}, /* Geforce 300 - midend mobile */
1718 {"GT 320M", CARD_NVIDIA_GEFORCE_GT320M}, /* Geforce 300 - midend mobile */
1719 {"320M", CARD_NVIDIA_GEFORCE_320M}, /* Geforce 300 - midend mobile */
1720 {"315M", CARD_NVIDIA_GEFORCE_315M}, /* Geforce 300 - midend mobile */
1721 {"GTX 295", CARD_NVIDIA_GEFORCE_GTX280}, /* Geforce 200 - highend */
1722 {"GTX 285", CARD_NVIDIA_GEFORCE_GTX280}, /* Geforce 200 - highend */
1723 {"GTX 280", CARD_NVIDIA_GEFORCE_GTX280}, /* Geforce 200 - highend */
1724 {"GTX 275", CARD_NVIDIA_GEFORCE_GTX275}, /* Geforce 200 - midend high */
1725 {"GTX 260", CARD_NVIDIA_GEFORCE_GTX260}, /* Geforce 200 - midend */
1726 {"GT 240", CARD_NVIDIA_GEFORCE_GT240}, /* Geforce 200 - midend */
1727 {"GT 220", CARD_NVIDIA_GEFORCE_GT220}, /* Geforce 200 - lowend */
1728 {"Geforce 310", CARD_NVIDIA_GEFORCE_210}, /* Geforce 200 - lowend */
1729 {"Geforce 305", CARD_NVIDIA_GEFORCE_210}, /* Geforce 200 - lowend */
1730 {"Geforce 210", CARD_NVIDIA_GEFORCE_210}, /* Geforce 200 - lowend */
1731 {"G 210", CARD_NVIDIA_GEFORCE_210}, /* Geforce 200 - lowend */
1732 {"GTS 250", CARD_NVIDIA_GEFORCE_9800GT}, /* Geforce 9 - highend / Geforce 200 - midend */
1733 {"GTS 150", CARD_NVIDIA_GEFORCE_9800GT}, /* Geforce 9 - highend / Geforce 200 - midend */
1734 {"9800", CARD_NVIDIA_GEFORCE_9800GT}, /* Geforce 9 - highend / Geforce 200 - midend */
1735 {"GT 140", CARD_NVIDIA_GEFORCE_9600GT}, /* Geforce 9 - midend */
1736 {"9600", CARD_NVIDIA_GEFORCE_9600GT}, /* Geforce 9 - midend */
1737 {"GT 130", CARD_NVIDIA_GEFORCE_9500GT}, /* Geforce 9 - midend low / Geforce 200 - low */
1738 {"GT 120", CARD_NVIDIA_GEFORCE_9500GT}, /* Geforce 9 - midend low / Geforce 200 - low */
1739 {"9500", CARD_NVIDIA_GEFORCE_9500GT}, /* Geforce 9 - midend low / Geforce 200 - low */
1740 {"9400M", CARD_NVIDIA_GEFORCE_9400M}, /* Geforce 9 - lowend */
1741 {"9400", CARD_NVIDIA_GEFORCE_9400GT}, /* Geforce 9 - lowend */
1742 {"9300", CARD_NVIDIA_GEFORCE_9300}, /* Geforce 9 - lowend low */
1743 {"9200", CARD_NVIDIA_GEFORCE_9200}, /* Geforce 9 - lowend low */
1744 {"9100", CARD_NVIDIA_GEFORCE_9200}, /* Geforce 9 - lowend low */
1745 {"G 100", CARD_NVIDIA_GEFORCE_9200}, /* Geforce 9 - lowend low */
1746 {"8800 GTX", CARD_NVIDIA_GEFORCE_8800GTX}, /* Geforce 8 - highend high */
1747 {"8800", CARD_NVIDIA_GEFORCE_8800GTS}, /* Geforce 8 - highend */
1748 {"8600M", CARD_NVIDIA_GEFORCE_8600MGT}, /* Geforce 8 - midend mobile */
1749 {"8600 M", CARD_NVIDIA_GEFORCE_8600MGT}, /* Geforce 8 - midend mobile */
1750 {"8700", CARD_NVIDIA_GEFORCE_8600GT}, /* Geforce 8 - midend */
1751 {"8600", CARD_NVIDIA_GEFORCE_8600GT}, /* Geforce 8 - midend */
1752 {"8500", CARD_NVIDIA_GEFORCE_8400GS}, /* Geforce 8 - mid-lowend */
1753 {"8400", CARD_NVIDIA_GEFORCE_8400GS}, /* Geforce 8 - mid-lowend */
1754 {"8300", CARD_NVIDIA_GEFORCE_8300GS}, /* Geforce 8 - lowend */
1755 {"8200", CARD_NVIDIA_GEFORCE_8300GS}, /* Geforce 8 - lowend */
1756 {"8100", CARD_NVIDIA_GEFORCE_8300GS}, /* Geforce 8 - lowend */
1757 };
1758
1759 for (i = 0; i < sizeof(cards) / sizeof(*cards); ++i)
1760 {
1761 if (strstr(gl_renderer, cards[i].renderer))
1762 return cards[i].id;
1763 }
1764 return PCI_DEVICE_NONE;
1765 }
1766
1767 /* Both the GeforceFX, 6xxx and 7xxx series support D3D9. The last two types have more
1768 * shader capabilities, so we use the shader capabilities to distinguish between FX and 6xxx/7xxx.
1769 */
1770 if (d3d_level >= 9 && gl_info->supported[NV_VERTEX_PROGRAM3])
1771 {
1772 static const struct
1773 {
1774 const char *renderer;
1775 enum wined3d_pci_device id;
1776 }
1777 cards[] =
1778 {
1779 {"Quadro FX 5", CARD_NVIDIA_GEFORCE_7800GT}, /* Geforce 7 - highend */
1780 {"Quadro FX 4", CARD_NVIDIA_GEFORCE_7800GT}, /* Geforce 7 - highend */
1781 {"7950", CARD_NVIDIA_GEFORCE_7800GT}, /* Geforce 7 - highend */
1782 {"7900", CARD_NVIDIA_GEFORCE_7800GT}, /* Geforce 7 - highend */
1783 {"7800", CARD_NVIDIA_GEFORCE_7800GT}, /* Geforce 7 - highend */
1784 {"7700", CARD_NVIDIA_GEFORCE_7600}, /* Geforce 7 - midend */
1785 {"7600", CARD_NVIDIA_GEFORCE_7600}, /* Geforce 7 - midend */
1786 {"7400", CARD_NVIDIA_GEFORCE_7400}, /* Geforce 7 - lower medium */
1787 {"7300", CARD_NVIDIA_GEFORCE_7300}, /* Geforce 7 - lowend */
1788 {"6800", CARD_NVIDIA_GEFORCE_6800}, /* Geforce 6 - highend */
1789 {"6700", CARD_NVIDIA_GEFORCE_6600GT}, /* Geforce 6 - midend */
1790 {"6610", CARD_NVIDIA_GEFORCE_6600GT}, /* Geforce 6 - midend */
1791 {"6600", CARD_NVIDIA_GEFORCE_6600GT}, /* Geforce 6 - midend */
1792 };
1793
1794 for (i = 0; i < sizeof(cards) / sizeof(*cards); ++i)
1795 {
1796 if (strstr(gl_renderer, cards[i].renderer))
1797 return cards[i].id;
1798 }
1799 return PCI_DEVICE_NONE;
1800 }
1801
1802 if (d3d_level >= 9)
1803 {
1804 /* GeforceFX - highend */
1805 if (strstr(gl_renderer, "5800")
1806 || strstr(gl_renderer, "5900")
1807 || strstr(gl_renderer, "5950")
1808 || strstr(gl_renderer, "Quadro FX"))
1809 {
1810 return CARD_NVIDIA_GEFORCEFX_5800;
1811 }
1812
1813 /* GeforceFX - midend */
1814 if (strstr(gl_renderer, "5600")
1815 || strstr(gl_renderer, "5650")
1816 || strstr(gl_renderer, "5700")
1817 || strstr(gl_renderer, "5750"))
1818 {
1819 return CARD_NVIDIA_GEFORCEFX_5600;
1820 }
1821
1822 /* GeforceFX - lowend */
1823 return CARD_NVIDIA_GEFORCEFX_5200; /* GeforceFX 5100/5200/5250/5300/5500 */
1824 }
1825
1826 if (d3d_level >= 8)
1827 {
1828 if (strstr(gl_renderer, "GeForce4 Ti") || strstr(gl_renderer, "Quadro4"))
1829 {
1830 return CARD_NVIDIA_GEFORCE4_TI4200; /* Geforce4 Ti4200/Ti4400/Ti4600/Ti4800, Quadro4 */
1831 }
1832
1833 return CARD_NVIDIA_GEFORCE3; /* Geforce3 standard/Ti200/Ti500, Quadro DCC */
1834 }
1835
1836 if (d3d_level >= 7)
1837 {
1838 if (strstr(gl_renderer, "GeForce4 MX"))
1839 {
1840 return CARD_NVIDIA_GEFORCE4_MX; /* MX420/MX440/MX460/MX4000 */
1841 }
1842
1843 if (strstr(gl_renderer, "GeForce2 MX") || strstr(gl_renderer, "Quadro2 MXR"))
1844 {
1845 return CARD_NVIDIA_GEFORCE2_MX; /* Geforce2 standard/MX100/MX200/MX400, Quadro2 MXR */
1846 }
1847
1848 if (strstr(gl_renderer, "GeForce2") || strstr(gl_renderer, "Quadro2"))
1849 {
1850 return CARD_NVIDIA_GEFORCE2; /* Geforce2 GTS/Pro/Ti/Ultra, Quadro2 */
1851 }
1852
1853 return CARD_NVIDIA_GEFORCE; /* Geforce 256/DDR, Quadro */
1854 }
1855
1856 if (strstr(gl_renderer, "TNT2"))
1857 {
1858 return CARD_NVIDIA_RIVA_TNT2; /* Riva TNT2 standard/M64/Pro/Ultra */
1859 }
1860
1861 return CARD_NVIDIA_RIVA_TNT; /* Riva TNT, Vanta */
1862 }
1863
1864 static enum wined3d_pci_device select_card_amd_binary(const struct wined3d_gl_info *gl_info,
1865 const char *gl_renderer)
1866 {
1867 UINT d3d_level = d3d_level_from_gl_info(gl_info);
1868
1869 /* See http://developer.amd.com/drivers/pc_vendor_id/Pages/default.aspx
1870 *
1871 * Beware: renderer string do not match exact card model,
1872 * eg HD 4800 is returned for multiple cards, even for RV790 based ones. */
1873 if (d3d_level >= 10)
1874 {
1875 unsigned int i;
1876
1877 static const struct
1878 {
1879 const char *renderer;
1880 enum wined3d_pci_device id;
1881 }
1882 cards[] =
1883 {
1884 /* Southern Islands */
1885 {"HD 7900", CARD_AMD_RADEON_HD7900},
1886 {"HD 7800", CARD_AMD_RADEON_HD7800},
1887 {"HD 7700", CARD_AMD_RADEON_HD7700},
1888 /* Northern Islands */
1889 {"HD 6970", CARD_AMD_RADEON_HD6900},
1890 {"HD 6900", CARD_AMD_RADEON_HD6900},
1891 {"HD 6800", CARD_AMD_RADEON_HD6800},
1892 {"HD 6770M",CARD_AMD_RADEON_HD6600M},
1893 {"HD 6750M",CARD_AMD_RADEON_HD6600M},
1894 {"HD 6700", CARD_AMD_RADEON_HD6700},
1895 {"HD 6670", CARD_AMD_RADEON_HD6600},
1896 {"HD 6630M",CARD_AMD_RADEON_HD6600M},
1897 {"HD 6600M",CARD_AMD_RADEON_HD6600M},
1898 {"HD 6600", CARD_AMD_RADEON_HD6600},
1899 {"HD 6570", CARD_AMD_RADEON_HD6600},
1900 {"HD 6500M",CARD_AMD_RADEON_HD6600M},
1901 {"HD 6500", CARD_AMD_RADEON_HD6600},
1902 {"HD 6400", CARD_AMD_RADEON_HD6400},
1903 {"HD 6300", CARD_AMD_RADEON_HD6300},
1904 {"HD 6200", CARD_AMD_RADEON_HD6300},
1905 /* Evergreen */
1906 {"HD 5870", CARD_AMD_RADEON_HD5800}, /* Radeon EG CYPRESS PRO */
1907 {"HD 5850", CARD_AMD_RADEON_HD5800}, /* Radeon EG CYPRESS XT */
1908 {"HD 5800", CARD_AMD_RADEON_HD5800}, /* Radeon EG CYPRESS HD58xx generic renderer string */
1909 {"HD 5770", CARD_AMD_RADEON_HD5700}, /* Radeon EG JUNIPER XT */
1910 {"HD 5750", CARD_AMD_RADEON_HD5700}, /* Radeon EG JUNIPER LE */
1911 {"HD 5700", CARD_AMD_RADEON_HD5700}, /* Radeon EG JUNIPER HD57xx generic renderer string */
1912 {"HD 5670", CARD_AMD_RADEON_HD5600}, /* Radeon EG REDWOOD XT */
1913 {"HD 5570", CARD_AMD_RADEON_HD5600}, /* Radeon EG REDWOOD PRO mapped to HD5600 series */
1914 {"HD 5550", CARD_AMD_RADEON_HD5600}, /* Radeon EG REDWOOD LE mapped to HD5600 series */
1915 {"HD 5450", CARD_AMD_RADEON_HD5400}, /* Radeon EG CEDAR PRO */
1916 {"HD 5000", CARD_AMD_RADEON_HD5600}, /* Defaulting to HD 5600 */
1917 /* R700 */
1918 {"HD 4890", CARD_AMD_RADEON_HD4800}, /* Radeon RV790 */
1919 {"HD 4870", CARD_AMD_RADEON_HD4800}, /* Radeon RV770 */
1920 {"HD 4850", CARD_AMD_RADEON_HD4800}, /* Radeon RV770 */
1921 {"HD 4830", CARD_AMD_RADEON_HD4800}, /* Radeon RV770 */
1922 {"HD 4800", CARD_AMD_RADEON_HD4800}, /* Radeon RV7xx HD48xx generic renderer string */
1923 {"HD 4770", CARD_AMD_RADEON_HD4700}, /* Radeon RV740 */
1924 {"HD 4700", CARD_AMD_RADEON_HD4700}, /* Radeon RV7xx HD47xx generic renderer string */
1925 {"HD 4670", CARD_AMD_RADEON_HD4600}, /* Radeon RV730 */
1926 {"HD 4650", CARD_AMD_RADEON_HD4600}, /* Radeon RV730 */
1927 {"HD 4600", CARD_AMD_RADEON_HD4600}, /* Radeon RV730 */
1928 {"HD 4550", CARD_AMD_RADEON_HD4350}, /* Radeon RV710 */
1929 {"HD 4350", CARD_AMD_RADEON_HD4350}, /* Radeon RV710 */
1930 /* R600/R700 integrated */
1931 {"HD 4200M", CARD_AMD_RADEON_HD4200M},
1932 {"HD 3300", CARD_AMD_RADEON_HD3200},
1933 {"HD 3200", CARD_AMD_RADEON_HD3200},
1934 {"HD 3100", CARD_AMD_RADEON_HD3200},
1935 /* R600 */
1936 {"HD 3870", CARD_AMD_RADEON_HD2900}, /* HD2900/HD3800 - highend */
1937 {"HD 3850", CARD_AMD_RADEON_HD2900}, /* HD2900/HD3800 - highend */
1938 {"HD 2900", CARD_AMD_RADEON_HD2900}, /* HD2900/HD3800 - highend */
1939 {"HD 3830", CARD_AMD_RADEON_HD2600}, /* China-only midend */
1940 {"HD 3690", CARD_AMD_RADEON_HD2600}, /* HD2600/HD3600 - midend */
1941 {"HD 3650", CARD_AMD_RADEON_HD2600}, /* HD2600/HD3600 - midend */
1942 {"HD 2600", CARD_AMD_RADEON_HD2600}, /* HD2600/HD3600 - midend */
1943 {"HD 3470", CARD_AMD_RADEON_HD2350}, /* HD2350/HD2400/HD3400 - lowend */
1944 {"HD 3450", CARD_AMD_RADEON_HD2350}, /* HD2350/HD2400/HD3400 - lowend */
1945 {"HD 3430", CARD_AMD_RADEON_HD2350}, /* HD2350/HD2400/HD3400 - lowend */
1946 {"HD 3400", CARD_AMD_RADEON_HD2350}, /* HD2350/HD2400/HD3400 - lowend */
1947 {"HD 2400", CARD_AMD_RADEON_HD2350}, /* HD2350/HD2400/HD3400 - lowend */
1948 {"HD 2350", CARD_AMD_RADEON_HD2350}, /* HD2350/HD2400/HD3400 - lowend */
1949 };
1950
1951 for (i = 0; i < sizeof(cards) / sizeof(*cards); ++i)
1952 {
1953 if (strstr(gl_renderer, cards[i].renderer))
1954 return cards[i].id;
1955 }
1956 return PCI_DEVICE_NONE;
1957 }
1958
1959 if (d3d_level >= 9)
1960 {
1961 /* Radeon R5xx */
1962 if (strstr(gl_renderer, "X1600")
1963 || strstr(gl_renderer, "X1650")
1964 || strstr(gl_renderer, "X1800")
1965 || strstr(gl_renderer, "X1900")
1966 || strstr(gl_renderer, "X1950"))
1967 {
1968 return CARD_AMD_RADEON_X1600;
1969 }
1970
1971 /* Radeon R4xx + X1300/X1400/X1450/X1550/X2300/X2500/HD2300 (lowend R5xx)
1972 * Note X2300/X2500/HD2300 are R5xx GPUs with a 2xxx naming but they are still DX9-only */
1973 if (strstr(gl_renderer, "X700")
1974 || strstr(gl_renderer, "X800")
1975 || strstr(gl_renderer, "X850")
1976 || strstr(gl_renderer, "X1300")
1977 || strstr(gl_renderer, "X1400")
1978 || strstr(gl_renderer, "X1450")
1979 || strstr(gl_renderer, "X1550")
1980 || strstr(gl_renderer, "X2300")
1981 || strstr(gl_renderer, "X2500")
1982 || strstr(gl_renderer, "HD 2300")
1983 )
1984 {
1985 return CARD_AMD_RADEON_X700;
1986 }
1987
1988 /* Radeon Xpress Series - onboard, DX9b, Shader 2.0, 300-400 MHz */
1989 if (strstr(gl_renderer, "Radeon Xpress"))
1990 {
1991 return CARD_AMD_RADEON_XPRESS_200M;
1992 }
1993 }
1994 return PCI_DEVICE_NONE;
1995 }
1996
1997 static enum wined3d_pci_device select_card_intel(const struct wined3d_gl_info *gl_info,
1998 const char *gl_renderer)
1999 {
2000 unsigned int i;
2001
2002 static const struct
2003 {
2004 const char *renderer;
2005 enum wined3d_pci_device id;
2006 }
2007 cards[] =
2008 {
2009 /* Haswell */
2010 {"Haswell Mobile", CARD_INTEL_HWM},
2011 /* Ivybridge */
2012 {"Ivybridge Server", CARD_INTEL_IVBS},
2013 {"Ivybridge Mobile", CARD_INTEL_IVBM},
2014 {"Ivybridge Desktop", CARD_INTEL_IVBD},
2015 /* Sandybridge */
2016 {"Sandybridge Server", CARD_INTEL_SNBS},
2017 {"Sandybridge Mobile", CARD_INTEL_SNBM},
2018 {"Sandybridge Desktop", CARD_INTEL_SNBD},
2019 /* Ironlake */
2020 {"Ironlake Mobile", CARD_INTEL_ILKM},
2021 {"Ironlake Desktop", CARD_INTEL_ILKD},
2022 /* G4x */
2023 {"B43", CARD_INTEL_B43},
2024 {"G41", CARD_INTEL_G41},
2025 {"G45", CARD_INTEL_G45},
2026 {"Q45", CARD_INTEL_Q45},
2027 {"Integrated Graphics Device", CARD_INTEL_IGD},
2028 {"GM45", CARD_INTEL_GM45},
2029 /* i965 */
2030 {"965GME", CARD_INTEL_965GME},
2031 {"965GM", CARD_INTEL_965GM},
2032 {"X3100", CARD_INTEL_965GM}, /* MacOS */
2033 {"946GZ", CARD_INTEL_946GZ},
2034 {"965G", CARD_INTEL_965G},
2035 {"965Q", CARD_INTEL_965Q},
2036 /* i945 */
2037 {"Pineview M", CARD_INTEL_PNVM},
2038 {"Pineview G", CARD_INTEL_PNVG},
2039 {"IGD", CARD_INTEL_PNVG},
2040 {"Q33", CARD_INTEL_Q33},
2041 {"G33", CARD_INTEL_G33},
2042 {"Q35", CARD_INTEL_Q35},
2043 {"945GME", CARD_INTEL_945GME},
2044 {"945GM", CARD_INTEL_945GM},
2045 {"GMA 950", CARD_INTEL_945GM}, /* MacOS */
2046 {"945G", CARD_INTEL_945G},
2047 /* i915 */
2048 {"915GM", CARD_INTEL_915GM},
2049 {"E7221G", CARD_INTEL_E7221G},
2050 {"915G", CARD_INTEL_915G},
2051 /* i8xx */
2052 {"865G", CARD_INTEL_865G},
2053 {"845G", CARD_INTEL_845G},
2054 {"855GM", CARD_INTEL_855GM},
2055 {"830M", CARD_INTEL_830M},
2056 };
2057
2058 for (i = 0; i < sizeof(cards) / sizeof(*cards); ++i)
2059 {
2060 if (strstr(gl_renderer, cards[i].renderer))
2061 return cards[i].id;
2062 }
2063
2064 return PCI_DEVICE_NONE;
2065 }
2066
2067 static enum wined3d_pci_device select_card_amd_mesa(const struct wined3d_gl_info *gl_info,
2068 const char *gl_renderer)
2069 {
2070 unsigned int i;
2071
2072 /* 20101109 - These are never returned by current Gallium radeon
2073 * drivers: R700, RV790, R680, RV535, RV516, R410, RS485, RV360, RV351.
2074 *
2075 * These are returned but not handled: RC410, RV380. */
2076 static const struct
2077 {
2078 const char *renderer;
2079 enum wined3d_pci_device id;
2080 }
2081 cards[] =
2082 {
2083 /* Southern Islands */
2084 {"TAHITI", CARD_AMD_RADEON_HD7900},
2085 {"PITCAIRN", CARD_AMD_RADEON_HD7800},
2086 {"CAPE VERDE", CARD_AMD_RADEON_HD7700},
2087 /* Northern Islands */
2088 {"CAYMAN", CARD_AMD_RADEON_HD6900},
2089 {"BARTS", CARD_AMD_RADEON_HD6800},
2090 {"TURKS", CARD_AMD_RADEON_HD6600},
2091 {"SUMO2", CARD_AMD_RADEON_HD6410D}, /* SUMO2 first, because we do a strstr(). */
2092 {"SUMO", CARD_AMD_RADEON_HD6550D},
2093 {"CAICOS", CARD_AMD_RADEON_HD6400},
2094 {"PALM", CARD_AMD_RADEON_HD6300},
2095 /* Evergreen */
2096 {"HEMLOCK", CARD_AMD_RADEON_HD5900},
2097 {"CYPRESS", CARD_AMD_RADEON_HD5800},
2098 {"JUNIPER", CARD_AMD_RADEON_HD5700},
2099 {"REDWOOD", CARD_AMD_RADEON_HD5600},
2100 {"CEDAR", CARD_AMD_RADEON_HD5400},
2101 /* R700 */
2102 {"R700", CARD_AMD_RADEON_HD4800},
2103 {"RV790", CARD_AMD_RADEON_HD4800},
2104 {"RV770", CARD_AMD_RADEON_HD4800},
2105 {"RV740", CARD_AMD_RADEON_HD4700},
2106 {"RV730", CARD_AMD_RADEON_HD4600},
2107 {"RV710", CARD_AMD_RADEON_HD4350},
2108 /* R600/R700 integrated */
2109 {"RS880", CARD_AMD_RADEON_HD4200M},
2110 {"RS780", CARD_AMD_RADEON_HD3200},
2111 /* R600 */
2112 {"R680", CARD_AMD_RADEON_HD2900},
2113 {"R600", CARD_AMD_RADEON_HD2900},
2114 {"RV670", CARD_AMD_RADEON_HD2900},
2115 {"RV635", CARD_AMD_RADEON_HD2600},
2116 {"RV630", CARD_AMD_RADEON_HD2600},
2117 {"RV620", CARD_AMD_RADEON_HD2350},
2118 {"RV610", CARD_AMD_RADEON_HD2350},
2119 /* R500 */
2120 {"R580", CARD_AMD_RADEON_X1600},
2121 {"R520", CARD_AMD_RADEON_X1600},
2122 {"RV570", CARD_AMD_RADEON_X1600},
2123 {"RV560", CARD_AMD_RADEON_X1600},
2124 {"RV535", CARD_AMD_RADEON_X1600},
2125 {"RV530", CARD_AMD_RADEON_X1600},
2126 {"RV516", CARD_AMD_RADEON_X700},
2127 {"RV515", CARD_AMD_RADEON_X700},
2128 /* R400 */
2129 {"R481", CARD_AMD_RADEON_X700},
2130 {"R480", CARD_AMD_RADEON_X700},
2131 {"R430", CARD_AMD_RADEON_X700},
2132 {"R423", CARD_AMD_RADEON_X700},
2133 {"R420", CARD_AMD_RADEON_X700},
2134 {"R410", CARD_AMD_RADEON_X700},
2135 {"RV410", CARD_AMD_RADEON_X700},
2136 /* Radeon Xpress - onboard, DX9b, Shader 2.0, 300-400 MHz */
2137 {"RS740", CARD_AMD_RADEON_XPRESS_200M},
2138 {"RS690", CARD_AMD_RADEON_XPRESS_200M},
2139 {"RS600", CARD_AMD_RADEON_XPRESS_200M},
2140 {"RS485", CARD_AMD_RADEON_XPRESS_200M},
2141 {"RS482", CARD_AMD_RADEON_XPRESS_200M},
2142 {"RS480", CARD_AMD_RADEON_XPRESS_200M},
2143 {"RS400", CARD_AMD_RADEON_XPRESS_200M},
2144 /* R300 */
2145 {"R360", CARD_AMD_RADEON_9500},
2146 {"R350", CARD_AMD_RADEON_9500},
2147 {"R300", CARD_AMD_RADEON_9500},
2148 {"RV370", CARD_AMD_RADEON_9500},
2149 {"RV360", CARD_AMD_RADEON_9500},
2150 {"RV351", CARD_AMD_RADEON_9500},
2151 {"RV350", CARD_AMD_RADEON_9500},
2152 };
2153
2154 for (i = 0; i < sizeof(cards) / sizeof(*cards); ++i)
2155 {
2156 if (strstr(gl_renderer, cards[i].renderer))
2157 return cards[i].id;
2158 }
2159
2160 return PCI_DEVICE_NONE;
2161 }
2162
2163 static enum wined3d_pci_device select_card_nvidia_mesa(const struct wined3d_gl_info *gl_info,
2164 const char *gl_renderer)
2165 {
2166 unsigned int i;
2167
2168 static const struct
2169 {
2170 const char *renderer;
2171 enum wined3d_pci_device id;
2172 }
2173 cards[] =
2174 {
2175 /* Maxwell */
2176 {"NV117", CARD_NVIDIA_GEFORCE_GTX750},
2177 /* Kepler */
2178 {"NVE6", CARD_NVIDIA_GEFORCE_GTX770M},
2179 {"NVE4", CARD_NVIDIA_GEFORCE_GTX680},
2180 /* Fermi */
2181 {"NVD9", CARD_NVIDIA_GEFORCE_GT520},
2182 {"NVCF", CARD_NVIDIA_GEFORCE_GTX550},
2183 {"NVCE", CARD_NVIDIA_GEFORCE_GTX560},
2184 {"NVC8", CARD_NVIDIA_GEFORCE_GTX570},
2185 {"NVC4", CARD_NVIDIA_GEFORCE_GTX460},
2186 {"NVC3", CARD_NVIDIA_GEFORCE_GT440},
2187 {"NVC1", CARD_NVIDIA_GEFORCE_GT420},
2188 {"NVC0", CARD_NVIDIA_GEFORCE_GTX480},
2189 /* Tesla */
2190 {"NVAF", CARD_NVIDIA_GEFORCE_GT320M},
2191 {"NVAC", CARD_NVIDIA_GEFORCE_8200},
2192 {"NVAA", CARD_NVIDIA_GEFORCE_8200},
2193 {"NVA8", CARD_NVIDIA_GEFORCE_210},
2194 {"NVA5", CARD_NVIDIA_GEFORCE_GT220},
2195 {"NVA3", CARD_NVIDIA_GEFORCE_GT240},
2196 {"NVA0", CARD_NVIDIA_GEFORCE_GTX280},
2197 {"NV98", CARD_NVIDIA_GEFORCE_9200},
2198 {"NV96", CARD_NVIDIA_GEFORCE_9400GT},
2199 {"NV94", CARD_NVIDIA_GEFORCE_9600GT},
2200 {"NV92", CARD_NVIDIA_GEFORCE_9800GT},
2201 {"NV86", CARD_NVIDIA_GEFORCE_8500GT},
2202 {"NV84", CARD_NVIDIA_GEFORCE_8600GT},
2203 {"NV50", CARD_NVIDIA_GEFORCE_8800GTX},
2204 /* Curie */
2205 {"NV68", CARD_NVIDIA_GEFORCE_6200}, /* 7050 */
2206 {"NV67", CARD_NVIDIA_GEFORCE_6200}, /* 7000M */
2207 {"NV63", CARD_NVIDIA_GEFORCE_6200}, /* 7100 */
2208 {"NV4E", CARD_NVIDIA_GEFORCE_6200}, /* 6100 Go / 6150 Go */
2209 {"NV4C", CARD_NVIDIA_GEFORCE_6200}, /* 6150SE */
2210 {"NV4B", CARD_NVIDIA_GEFORCE_7600},
2211 {"NV4A", CARD_NVIDIA_GEFORCE_6200},
2212 {"NV49", CARD_NVIDIA_GEFORCE_7800GT}, /* 7900 */
2213 {"NV47", CARD_NVIDIA_GEFORCE_7800GT},
2214 {"NV46", CARD_NVIDIA_GEFORCE_7400},
2215 {"NV45", CARD_NVIDIA_GEFORCE_6800},
2216 {"NV44", CARD_NVIDIA_GEFORCE_6200},
2217 {"NV43", CARD_NVIDIA_GEFORCE_6600GT},
2218 {"NV42", CARD_NVIDIA_GEFORCE_6800},
2219 {"NV41", CARD_NVIDIA_GEFORCE_6800},
2220 {"NV40", CARD_NVIDIA_GEFORCE_6800},
2221 /* Rankine */
2222 {"NV38", CARD_NVIDIA_GEFORCEFX_5800}, /* FX 5950 Ultra */
2223 {"NV36", CARD_NVIDIA_GEFORCEFX_5800}, /* FX 5700/5750 */
2224 {"NV35", CARD_NVIDIA_GEFORCEFX_5800}, /* FX 5900 */
2225 {"NV34", CARD_NVIDIA_GEFORCEFX_5200},
2226 {"NV31", CARD_NVIDIA_GEFORCEFX_5600},
2227 {"NV30", CARD_NVIDIA_GEFORCEFX_5800},
2228 /* Kelvin */
2229 {"nv28", CARD_NVIDIA_GEFORCE4_TI4200},
2230 {"nv25", CARD_NVIDIA_GEFORCE4_TI4200},
2231 {"nv20", CARD_NVIDIA_GEFORCE3},
2232 /* Celsius */
2233 {"nv1F", CARD_NVIDIA_GEFORCE4_MX}, /* GF4 MX IGP */
2234 {"nv1A", CARD_NVIDIA_GEFORCE2}, /* GF2 IGP */
2235 {"nv18", CARD_NVIDIA_GEFORCE4_MX},
2236 {"nv17", CARD_NVIDIA_GEFORCE4_MX},
2237 {"nv16", CARD_NVIDIA_GEFORCE2},
2238 {"nv15", CARD_NVIDIA_GEFORCE2},
2239 {"nv11", CARD_NVIDIA_GEFORCE2_MX},
2240 {"nv10", CARD_NVIDIA_GEFORCE},
2241 /* Fahrenheit */
2242 {"nv05", CARD_NVIDIA_RIVA_TNT2},
2243 {"nv04", CARD_NVIDIA_RIVA_TNT},
2244 {"nv03", CARD_NVIDIA_RIVA_128},
2245 };
2246
2247 for (i = 0; i < sizeof(cards) / sizeof(*cards); ++i)
2248 {
2249 if (strstr(gl_renderer, cards[i].renderer))
2250 return cards[i].id;
2251 }
2252 return PCI_DEVICE_NONE;
2253 }
2254
2255 static enum wined3d_pci_device select_card_vmware(const struct wined3d_gl_info *gl_info, const char *gl_renderer)
2256 {
2257 if (strstr(gl_renderer, "SVGA3D"))
2258 return CARD_VMWARE_SVGA3D;
2259
2260 return PCI_DEVICE_NONE;
2261 }
2262
2263 static const struct gl_vendor_selection
2264 {
2265 enum wined3d_gl_vendor gl_vendor;
2266 const char *description; /* Description of the card selector i.e. Apple OS/X Intel */
2267 enum wined3d_pci_device (*select_card)(const struct wined3d_gl_info *gl_info, const char *gl_renderer);
2268 }
2269 amd_gl_vendor_table[] =
2270 {
2271 {GL_VENDOR_APPLE, "Apple OSX AMD/ATI binary driver", select_card_amd_binary},
2272 {GL_VENDOR_FGLRX, "AMD/ATI binary driver", select_card_amd_binary},
2273 {GL_VENDOR_MESA, "Mesa AMD/ATI driver", select_card_amd_mesa},
2274 },
2275 nvidia_gl_vendor_table[] =
2276 {
2277 {GL_VENDOR_APPLE, "Apple OSX NVidia binary driver", select_card_nvidia_binary},
2278 {GL_VENDOR_MESA, "Mesa Nouveau driver", select_card_nvidia_mesa},
2279 {GL_VENDOR_NVIDIA, "Nvidia binary driver", select_card_nvidia_binary},
2280 },
2281 vmware_gl_vendor_table[] =
2282 {
2283 {GL_VENDOR_MESA, "VMware driver", select_card_vmware},
2284 },
2285 intel_gl_vendor_table[] =
2286 {
2287 {GL_VENDOR_APPLE, "Apple OSX Intel binary driver", select_card_intel},
2288 {GL_VENDOR_MESA, "Mesa Intel driver", select_card_intel},
2289 };
2290
2291 static enum wined3d_pci_device select_card_fallback_nvidia(const struct wined3d_gl_info *gl_info)
2292 {
2293 UINT d3d_level = d3d_level_from_gl_info(gl_info);
2294 if (d3d_level >= 10)
2295 return CARD_NVIDIA_GEFORCE_8800GTX;
2296 if (d3d_level >= 9 && gl_info->supported[NV_VERTEX_PROGRAM3])
2297 return CARD_NVIDIA_GEFORCE_6800;
2298 if (d3d_level >= 9)
2299 return CARD_NVIDIA_GEFORCEFX_5800;
2300 if (d3d_level >= 8)
2301 return CARD_NVIDIA_GEFORCE3;
2302 if (d3d_level >= 7)
2303 return CARD_NVIDIA_GEFORCE;
2304 if (d3d_level >= 6)
2305 return CARD_NVIDIA_RIVA_TNT;
2306 return CARD_NVIDIA_RIVA_128;
2307 }
2308
2309 static enum wined3d_pci_device select_card_fallback_amd(const struct wined3d_gl_info *gl_info)
2310 {
2311 UINT d3d_level = d3d_level_from_gl_info(gl_info);
2312 if (d3d_level >= 10)
2313 return CARD_AMD_RADEON_HD2900;
2314 if (d3d_level >= 9)
2315 return CARD_AMD_RADEON_9500;
2316 if (d3d_level >= 8)
2317 return CARD_AMD_RADEON_8500;
2318 if (d3d_level >= 7)
2319 return CARD_AMD_RADEON_7200;
2320 return CARD_AMD_RAGE_128PRO;
2321 }
2322
2323 static enum wined3d_pci_device select_card_fallback_intel(const struct wined3d_gl_info *gl_info)
2324 {
2325 UINT d3d_level = d3d_level_from_gl_info(gl_info);
2326 if (d3d_level >= 10)
2327 return CARD_INTEL_G45;
2328 return CARD_INTEL_915G;
2329 }
2330
2331 static enum wined3d_pci_device select_card_handler(const struct gl_vendor_selection *table,
2332 unsigned int table_size, enum wined3d_gl_vendor gl_vendor,
2333 const struct wined3d_gl_info *gl_info, const char *gl_renderer)
2334 {
2335 unsigned int i;
2336
2337 for (i = 0; i < table_size; ++i)
2338 {
2339 if (table[i].gl_vendor != gl_vendor)
2340 continue;
2341
2342 TRACE("Applying card selector \"%s\".\n", table[i].description);
2343 return table[i].select_card(gl_info, gl_renderer);
2344 }
2345 FIXME("Couldn't find a suitable card selector for GL vendor %04x (using GL_RENDERER %s)\n",
2346 gl_vendor, debugstr_a(gl_renderer));
2347
2348 return PCI_DEVICE_NONE;
2349 }
2350
2351 static const struct
2352 {
2353 enum wined3d_pci_vendor card_vendor;
2354 const char *description; /* Description of the card selector i.e. Apple OS/X Intel */
2355 const struct gl_vendor_selection *gl_vendor_selection;
2356 unsigned int gl_vendor_count;
2357 enum wined3d_pci_device (*select_card_fallback)(const struct wined3d_gl_info *gl_info);
2358 }
2359 card_vendor_table[] =
2360 {
2361 {HW_VENDOR_AMD, "AMD", amd_gl_vendor_table,
2362 sizeof(amd_gl_vendor_table) / sizeof(*amd_gl_vendor_table),
2363 select_card_fallback_amd},
2364 {HW_VENDOR_NVIDIA, "Nvidia", nvidia_gl_vendor_table,
2365 sizeof(nvidia_gl_vendor_table) / sizeof(*nvidia_gl_vendor_table),
2366 select_card_fallback_nvidia},
2367 {HW_VENDOR_VMWARE, "VMware", vmware_gl_vendor_table,
2368 sizeof(vmware_gl_vendor_table) / sizeof(*vmware_gl_vendor_table),
2369 select_card_fallback_amd},
2370 {HW_VENDOR_INTEL, "Intel", intel_gl_vendor_table,
2371 sizeof(intel_gl_vendor_table) / sizeof(*intel_gl_vendor_table),
2372 select_card_fallback_intel},
2373 };
2374
2375
2376 static enum wined3d_pci_device wined3d_guess_card(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
2377 enum wined3d_gl_vendor *gl_vendor, enum wined3d_pci_vendor *card_vendor)
2378 {
2379 /* A Direct3D device object contains the PCI id (vendor + device) of the
2380 * videocard which is used for rendering. Various applications use this
2381 * information to get a rough estimation of the features of the card and
2382 * some might use it for enabling 3d effects only on certain types of
2383 * videocards. In some cases games might even use it to work around bugs
2384 * which happen on certain videocards/driver combinations. The problem is
2385 * that OpenGL only exposes a rendering string containing the name of the
2386 * videocard and not the PCI id.
2387 *
2388 * Various games depend on the PCI id, so somehow we need to provide one.
2389 * A simple option is to parse the renderer string and translate this to
2390 * the right PCI id. This is a lot of work because there are more than 200
2391 * GPUs just for Nvidia. Various cards share the same renderer string, so
2392 * the amount of code might be 'small' but there are quite a number of
2393 * exceptions which would make this a pain to maintain. Another way would
2394 * be to query the PCI id from the operating system (assuming this is the
2395 * videocard which is used for rendering which is not always the case).
2396 * This would work but it is not very portable. Second it would not work
2397 * well in, let's say, a remote X situation in which the amount of 3d
2398 * features which can be used is limited.
2399 *
2400 * As said most games only use the PCI id to get an indication of the
2401 * capabilities of the card. It doesn't really matter if the given id is
2402 * the correct one if we return the id of a card with similar 3d features.
2403 *
2404 * The code below checks the OpenGL capabilities of a videocard and matches
2405 * that to a certain level of Direct3D functionality. Once a card passes
2406 * the Direct3D9 check, we know that the card (in case of Nvidia) is at
2407 * least a GeforceFX. To give a better estimate we do a basic check on the
2408 * renderer string but if that won't pass we return a default card. This
2409 * way is better than maintaining a full card database as even without a
2410 * full database we can return a card with similar features. Second the
2411 * size of the database can be made quite small because when you know what
2412 * type of 3d functionality a card has, you know to which GPU family the
2413 * GPU must belong. Because of this you only have to check a small part of
2414 * the renderer string to distinguish between different models from that
2415 * family.
2416 *
2417 * The code also selects a default amount of video memory which we will
2418 * use for an estimation of the amount of free texture memory. In case of
2419 * real D3D the amount of texture memory includes video memory and system
2420 * memory (to be specific AGP memory or in case of PCIE TurboCache /
2421 * HyperMemory). We don't know how much system memory can be addressed by
2422 * the system but we can make a reasonable estimation about the amount of
2423 * video memory. If the value is slightly wrong it doesn't matter as we
2424 * didn't include AGP-like memory which makes the amount of addressable
2425 * memory higher and second OpenGL isn't that critical it moves to system
2426 * memory behind our backs if really needed. Note that the amount of video
2427 * memory can be overruled using a registry setting. */
2428
2429 unsigned int i;
2430 enum wined3d_pci_device device;
2431
2432 for (i = 0; i < (sizeof(card_vendor_table) / sizeof(*card_vendor_table)); ++i)
2433 {
2434 if (card_vendor_table[i].card_vendor != *card_vendor)
2435 continue;
2436
2437 TRACE("Applying card selector \"%s\".\n", card_vendor_table[i].description);
2438 device = select_card_handler(card_vendor_table[i].gl_vendor_selection,
2439 card_vendor_table[i].gl_vendor_count, *gl_vendor, gl_info, gl_renderer);
2440 if (device != PCI_DEVICE_NONE)
2441 return device;
2442
2443 TRACE("Unrecognized renderer %s, falling back to default.\n", debugstr_a(gl_renderer));
2444 return card_vendor_table[i].select_card_fallback(gl_info);
2445 }
2446
2447 FIXME("No card selector available for card vendor %04x (using GL_RENDERER %s).\n",
2448 *card_vendor, debugstr_a(gl_renderer));
2449
2450 /* Default to generic Nvidia hardware based on the supported OpenGL extensions. */
2451 *card_vendor = HW_VENDOR_NVIDIA;
2452 return select_card_fallback_nvidia(gl_info);
2453 }
2454
2455 static const struct wined3d_vertex_pipe_ops *select_vertex_implementation(const struct wined3d_gl_info *gl_info,
2456 const struct wined3d_shader_backend_ops *shader_backend_ops)
2457 {
2458 if (shader_backend_ops == &glsl_shader_backend)
2459 return &glsl_vertex_pipe;
2460 return &ffp_vertex_pipe;
2461 }
2462
2463 static const struct fragment_pipeline *select_fragment_implementation(const struct wined3d_gl_info *gl_info,
2464 const struct wined3d_shader_backend_ops *shader_backend_ops)
2465 {
2466 if (shader_backend_ops == &glsl_shader_backend)
2467 return &glsl_fragment_pipe;
2468 if (shader_backend_ops == &arb_program_shader_backend && gl_info->supported[ARB_FRAGMENT_PROGRAM])
2469 return &arbfp_fragment_pipeline;
2470 if (gl_info->supported[ATI_FRAGMENT_SHADER])
2471 return &atifs_fragment_pipeline;
2472 if (gl_info->supported[NV_REGISTER_COMBINERS] && gl_info->supported[NV_TEXTURE_SHADER2])
2473 return &nvts_fragment_pipeline;
2474 if (gl_info->supported[NV_REGISTER_COMBINERS])
2475 return &nvrc_fragment_pipeline;
2476 return &ffp_fragment_pipeline;
2477 }
2478
2479 static const struct wined3d_shader_backend_ops *select_shader_backend(const struct wined3d_gl_info *gl_info)
2480 {
2481 BOOL glsl = wined3d_settings.glslRequested && gl_info->glsl_version >= MAKEDWORD_VERSION(1, 20);
2482
2483 if (glsl && gl_info->supported[ARB_FRAGMENT_SHADER])
2484 return &glsl_shader_backend;
2485 if (glsl && gl_info->supported[ARB_VERTEX_SHADER])
2486 {
2487 /* Geforce4 cards support GLSL but for vertex shaders only. Further
2488 * its reported GLSL caps are wrong. This combined with the fact that
2489 * GLSL won't offer more features or performance, use ARB shaders only
2490 * on this card. */
2491 if (gl_info->supported[NV_VERTEX_PROGRAM] && !gl_info->supported[NV_VERTEX_PROGRAM2])
2492 return &arb_program_shader_backend;
2493 return &glsl_shader_backend;
2494 }
2495 if (gl_info->supported[ARB_VERTEX_PROGRAM] || gl_info->supported[ARB_FRAGMENT_PROGRAM])
2496 return &arb_program_shader_backend;
2497 return &none_shader_backend;
2498 }
2499
2500 static const struct blit_shader *select_blit_implementation(const struct wined3d_gl_info *gl_info,
2501 const struct wined3d_shader_backend_ops *shader_backend_ops)
2502 {
2503 if ((shader_backend_ops == &glsl_shader_backend
2504 || shader_backend_ops == &arb_program_shader_backend)
2505 && gl_info->supported[ARB_FRAGMENT_PROGRAM])
2506 return &arbfp_blit;
2507 return &ffp_blit;
2508 }
2509
2510 static void parse_extension_string(struct wined3d_gl_info *gl_info, const char *extensions,
2511 const struct wined3d_extension_map *map, UINT entry_count)
2512 {
2513 while (*extensions)
2514 {
2515 const char *start;
2516 size_t len;
2517 UINT i;
2518
2519 while (isspace(*extensions))
2520 ++extensions;
2521 start = extensions;
2522 while (!isspace(*extensions) && *extensions)
2523 ++extensions;
2524
2525 len = extensions - start;
2526 if (!len)
2527 continue;
2528
2529 TRACE("- %s.\n", debugstr_an(start, len));
2530
2531 for (i = 0; i < entry_count; ++i)
2532 {
2533 if (len == strlen(map[i].extension_string)
2534 && !memcmp(start, map[i].extension_string, len))
2535 {
2536 TRACE(" FOUND: %s support.\n", map[i].extension_string);
2537 gl_info->supported[map[i].extension] = TRUE;
2538 break;
2539 }
2540 }
2541 }
2542 }
2543
2544 static void load_gl_funcs(struct wined3d_gl_info *gl_info)
2545 {
2546 #define USE_GL_FUNC(pfn) gl_info->gl_ops.ext.p_##pfn = (void *)wglGetProcAddress(#pfn);
2547 GL_EXT_FUNCS_GEN;
2548 #undef USE_GL_FUNC
2549
2550 #ifndef USE_WIN32_OPENGL
2551 /* hack: use the functions directly from the TEB table to bypass the thunks */
2552 /* note that we still need the above wglGetProcAddress calls to initialize the table */
2553 gl_info->gl_ops.ext = ((struct opengl_funcs *)NtCurrentTeb()->glTable)->ext;
2554 #endif
2555 }
2556
2557 static void wined3d_adapter_init_limits(struct wined3d_gl_info *gl_info)
2558 {
2559 GLfloat gl_floatv[2];
2560 GLint gl_max;
2561
2562 gl_info->limits.blends = 1;
2563 gl_info->limits.buffers = 1;
2564 gl_info->limits.textures = 1;
2565 gl_info->limits.texture_coords = 1;
2566 gl_info->limits.fragment_samplers = 1;
2567 gl_info->limits.vertex_samplers = 0;
2568 gl_info->limits.combined_samplers = gl_info->limits.fragment_samplers + gl_info->limits.vertex_samplers;
2569 gl_info->limits.vertex_attribs = 16;
2570 gl_info->limits.glsl_vs_float_constants = 0;
2571 gl_info->limits.glsl_ps_float_constants = 0;
2572 gl_info->limits.arb_vs_float_constants = 0;
2573 gl_info->limits.arb_vs_native_constants = 0;
2574 gl_info->limits.arb_vs_instructions = 0;
2575 gl_info->limits.arb_vs_temps = 0;
2576 gl_info->limits.arb_ps_float_constants = 0;
2577 gl_info->limits.arb_ps_local_constants = 0;
2578 gl_info->limits.arb_ps_instructions = 0;
2579 gl_info->limits.arb_ps_temps = 0;
2580
2581 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_CLIP_PLANES, &gl_max);
2582 gl_info->limits.clipplanes = min(WINED3DMAXUSERCLIPPLANES, gl_max);
2583 TRACE("Clip plane support - max planes %d.\n", gl_max);
2584
2585 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_LIGHTS, &gl_max);
2586 gl_info->limits.lights = gl_max;
2587 TRACE("Light support - max lights %d.\n", gl_max);
2588
2589 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_TEXTURE_SIZE, &gl_max);
2590 gl_info->limits.texture_size = gl_max;
2591 TRACE("Maximum texture size support - max texture size %d.\n", gl_max);
2592
2593 gl_info->gl_ops.gl.p_glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, gl_floatv);
2594 gl_info->limits.pointsize_min = gl_floatv[0];
2595 gl_info->limits.pointsize_max = gl_floatv[1];
2596 TRACE("Maximum point size support - max point size %f.\n", gl_floatv[1]);
2597
2598 if (gl_info->supported[ARB_MAP_BUFFER_ALIGNMENT])
2599 {
2600 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MIN_MAP_BUFFER_ALIGNMENT, &gl_max);
2601 TRACE("Minimum buffer map alignment: %d.\n", gl_max);
2602 }
2603 else
2604 {
2605 WARN_(d3d_perf)("Driver doesn't guarantee a minimum buffer map alignment.\n");
2606 }
2607 if (gl_info->supported[NV_REGISTER_COMBINERS])
2608 {
2609 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_GENERAL_COMBINERS_NV, &gl_max);
2610 gl_info->limits.general_combiners = gl_max;
2611 TRACE("Max general combiners: %d.\n", gl_max);
2612 }
2613 if (gl_info->supported[ARB_DRAW_BUFFERS] && wined3d_settings.offscreen_rendering_mode == ORM_FBO)
2614 {
2615 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_DRAW_BUFFERS_ARB, &gl_max);
2616 gl_info->limits.buffers = gl_max;
2617 TRACE("Max draw buffers: %u.\n", gl_max);
2618 }
2619 if (gl_info->supported[ARB_MULTITEXTURE])
2620 {
2621 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &gl_max);
2622 gl_info->limits.textures = min(MAX_TEXTURES, gl_max);
2623 TRACE("Max textures: %d.\n", gl_info->limits.textures);
2624
2625 if (gl_info->supported[ARB_FRAGMENT_PROGRAM])
2626 {
2627 GLint tmp;
2628 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_TEXTURE_COORDS_ARB, &gl_max);
2629 gl_info->limits.texture_coords = min(MAX_TEXTURES, gl_max);
2630 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS_ARB, &tmp);
2631 gl_info->limits.fragment_samplers = min(MAX_FRAGMENT_SAMPLERS, tmp);
2632 }
2633 else
2634 {
2635 gl_info->limits.texture_coords = max(gl_info->limits.texture_coords, gl_max);
2636 gl_info->limits.fragment_samplers = max(gl_info->limits.fragment_samplers, gl_max);
2637 }
2638 TRACE("Max texture coords: %d.\n", gl_info->limits.texture_coords);
2639 TRACE("Max fragment samplers: %d.\n", gl_info->limits.fragment_samplers);
2640
2641 if (gl_info->supported[ARB_VERTEX_SHADER])
2642 {
2643 GLint tmp;
2644 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB, &tmp);
2645 gl_info->limits.vertex_samplers = tmp;
2646 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB, &tmp);
2647 gl_info->limits.combined_samplers = tmp;
2648 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_VERTEX_ATTRIBS_ARB, &tmp);
2649 gl_info->limits.vertex_attribs = tmp;
2650
2651 /* Loading GLSL sampler uniforms is much simpler if we can assume that the sampler setup
2652 * is known at shader link time. In a vertex shader + pixel shader combination this isn't
2653 * an issue because then the sampler setup only depends on the two shaders. If a pixel
2654 * shader is used with fixed function vertex processing we're fine too because fixed function
2655 * vertex processing doesn't use any samplers. If fixed function fragment processing is
2656 * used we have to make sure that all vertex sampler setups are valid together with all
2657 * possible fixed function fragment processing setups. This is true if vsamplers + MAX_TEXTURES
2658 * <= max_samplers. This is true on all d3d9 cards that support vtf(gf 6 and gf7 cards).
2659 * dx9 radeon cards do not support vertex texture fetch. DX10 cards have 128 samplers, and
2660 * dx9 is limited to 8 fixed function texture stages and 4 vertex samplers. DX10 does not have
2661 * a fixed function pipeline anymore.
2662 *
2663 * So this is just a check to check that our assumption holds true. If not, write a warning
2664 * and reduce the number of vertex samplers or probably disable vertex texture fetch. */
2665 if (gl_info->limits.vertex_samplers && gl_info->limits.combined_samplers < 12
2666 && MAX_TEXTURES + gl_info->limits.vertex_samplers > gl_info->limits.combined_samplers)
2667 {
2668 FIXME("OpenGL implementation supports %u vertex samplers and %u total samplers.\n",
2669 gl_info->limits.vertex_samplers, gl_info->limits.combined_samplers);
2670 FIXME("Expected vertex samplers + MAX_TEXTURES(=8) > combined_samplers.\n");
2671 if (gl_info->limits.combined_samplers > MAX_TEXTURES)
2672 gl_info->limits.vertex_samplers = gl_info->limits.combined_samplers - MAX_TEXTURES;
2673 else
2674 gl_info->limits.vertex_samplers = 0;
2675 }
2676 }
2677 else
2678 {
2679 gl_info->limits.combined_samplers = gl_info->limits.fragment_samplers;
2680 }
2681 TRACE("Max vertex samplers: %u.\n", gl_info->limits.vertex_samplers);
2682 TRACE("Max combined samplers: %u.\n", gl_info->limits.combined_samplers);
2683 }
2684 if (gl_info->supported[ARB_VERTEX_BLEND])
2685 {
2686 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_VERTEX_UNITS_ARB, &gl_max);
2687 gl_info->limits.blends = gl_max;
2688 TRACE("Max blends: %u.\n", gl_info->limits.blends);
2689 }
2690 if (gl_info->supported[EXT_TEXTURE3D])
2691 {
2692 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_3D_TEXTURE_SIZE_EXT, &gl_max);
2693 gl_info->limits.texture3d_size = gl_max;
2694 TRACE("Max texture3D size: %d.\n", gl_info->limits.texture3d_size);
2695 }
2696 if (gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC])
2697 {
2698 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &gl_max);
2699 gl_info->limits.anisotropy = gl_max;
2700 TRACE("Max anisotropy: %d.\n", gl_info->limits.anisotropy);
2701 }
2702 if (gl_info->supported[ARB_FRAGMENT_PROGRAM])
2703 {
2704 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max));
2705 gl_info->limits.arb_ps_float_constants = gl_max;
2706 TRACE("Max ARB_FRAGMENT_PROGRAM float constants: %d.\n", gl_info->limits.arb_ps_float_constants);
2707 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB, &gl_max));
2708 gl_info->limits.arb_ps_native_constants = gl_max;
2709 TRACE("Max ARB_FRAGMENT_PROGRAM native float constants: %d.\n",
2710 gl_info->limits.arb_ps_native_constants);
2711 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, &gl_max));
2712 gl_info->limits.arb_ps_temps = gl_max;
2713 TRACE("Max ARB_FRAGMENT_PROGRAM native temporaries: %d.\n", gl_info->limits.arb_ps_temps);
2714 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, &gl_max));
2715 gl_info->limits.arb_ps_instructions = gl_max;
2716 TRACE("Max ARB_FRAGMENT_PROGRAM native instructions: %d.\n", gl_info->limits.arb_ps_instructions);
2717 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB, &gl_max));
2718 gl_info->limits.arb_ps_local_constants = gl_max;
2719 TRACE("Max ARB_FRAGMENT_PROGRAM local parameters: %d.\n", gl_info->limits.arb_ps_instructions);
2720 }
2721 if (gl_info->supported[ARB_VERTEX_PROGRAM])
2722 {
2723 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max));
2724 gl_info->limits.arb_vs_float_constants = gl_max;
2725 TRACE("Max ARB_VERTEX_PROGRAM float constants: %d.\n", gl_info->limits.arb_vs_float_constants);
2726 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB, &gl_max));
2727 gl_info->limits.arb_vs_native_constants = gl_max;
2728 TRACE("Max ARB_VERTEX_PROGRAM native float constants: %d.\n",
2729 gl_info->limits.arb_vs_native_constants);
2730 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, &gl_max));
2731 gl_info->limits.arb_vs_temps = gl_max;
2732 TRACE("Max ARB_VERTEX_PROGRAM native temporaries: %d.\n", gl_info->limits.arb_vs_temps);
2733 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, &gl_max));
2734 gl_info->limits.arb_vs_instructions = gl_max;
2735 TRACE("Max ARB_VERTEX_PROGRAM native instructions: %d.\n", gl_info->limits.arb_vs_instructions);
2736 }
2737 if (gl_info->supported[ARB_VERTEX_SHADER])
2738 {
2739 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB, &gl_max);
2740 gl_info->limits.glsl_vs_float_constants = gl_max / 4;
2741 TRACE("Max ARB_VERTEX_SHADER float constants: %u.\n", gl_info->limits.glsl_vs_float_constants);
2742 }
2743 if (gl_info->supported[ARB_FRAGMENT_SHADER])
2744 {
2745 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB, &gl_max);
2746 gl_info->limits.glsl_ps_float_constants = gl_max / 4;
2747 TRACE("Max ARB_FRAGMENT_SHADER float constants: %u.\n", gl_info->limits.glsl_ps_float_constants);
2748 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_VARYING_FLOATS_ARB, &gl_max);
2749 gl_info->limits.glsl_varyings = gl_max;
2750 TRACE("Max GLSL varyings: %u (%u 4 component varyings).\n", gl_max, gl_max / 4);
2751 }
2752
2753 if (gl_info->supported[NV_LIGHT_MAX_EXPONENT])
2754 gl_info->gl_ops.gl.p_glGetFloatv(GL_MAX_SHININESS_NV, &gl_info->limits.shininess);
2755 else
2756 gl_info->limits.shininess = 128.0f;
2757
2758 if ((gl_info->supported[ARB_FRAMEBUFFER_OBJECT] || gl_info->supported[EXT_FRAMEBUFFER_MULTISAMPLE])
2759 && wined3d_settings.allow_multisampling)
2760 {
2761 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_SAMPLES, &gl_max);
2762 gl_info->limits.samples = gl_max;
2763 }
2764 }
2765
2766 /* Context activation is done by the caller. */
2767 static BOOL wined3d_adapter_init_gl_caps(struct wined3d_adapter *adapter)
2768 {
2769 struct wined3d_driver_info *driver_info = &adapter->driver_info;
2770 const char *gl_vendor_str, *gl_renderer_str, *gl_version_str;
2771 struct wined3d_gl_info *gl_info = &adapter->gl_info;
2772 struct wined3d_vertex_caps vertex_caps;
2773 enum wined3d_pci_vendor card_vendor;
2774 struct fragment_caps fragment_caps;
2775 struct shader_caps shader_caps;
2776 const char *WGL_Extensions = NULL;
2777 const char *GL_Extensions = NULL;
2778 enum wined3d_gl_vendor gl_vendor;
2779 enum wined3d_pci_device device;
2780 DWORD gl_version;
2781 HDC hdc;
2782 unsigned int i;
2783
2784 TRACE("adapter %p.\n", adapter);
2785
2786 gl_renderer_str = (const char *)gl_info->gl_ops.gl.p_glGetString(GL_RENDERER);
2787 TRACE("GL_RENDERER: %s.\n", debugstr_a(gl_renderer_str));
2788 if (!gl_renderer_str)
2789 {
2790 ERR("Received a NULL GL_RENDERER.\n");
2791 return FALSE;
2792 }
2793
2794 gl_vendor_str = (const char *)gl_info->gl_ops.gl.p_glGetString(GL_VENDOR);
2795 TRACE("GL_VENDOR: %s.\n", debugstr_a(gl_vendor_str));
2796 if (!gl_vendor_str)
2797 {
2798 ERR("Received a NULL GL_VENDOR.\n");
2799 return FALSE;
2800 }
2801
2802 /* Parse the GL_VERSION field into major and minor information */
2803 gl_version_str = (const char *)gl_info->gl_ops.gl.p_glGetString(GL_VERSION);
2804 TRACE("GL_VERSION: %s.\n", debugstr_a(gl_version_str));
2805 if (!gl_version_str)
2806 {
2807 ERR("Received a NULL GL_VERSION.\n");
2808 return FALSE;
2809 }
2810 gl_version = wined3d_parse_gl_version(gl_version_str);
2811
2812 /* Parse the gl supported features, in theory enabling parts of our code appropriately. */
2813 GL_Extensions = (const char *)gl_info->gl_ops.gl.p_glGetString(GL_EXTENSIONS);
2814 if (!GL_Extensions)
2815 {
2816 ERR("Received a NULL GL_EXTENSIONS.\n");
2817 return FALSE;
2818 }
2819
2820 memset(gl_info->supported, 0, sizeof(gl_info->supported));
2821 gl_info->supported[WINED3D_GL_EXT_NONE] = TRUE;
2822
2823 TRACE("GL extensions reported:\n");
2824 parse_extension_string(gl_info, GL_Extensions, gl_extension_map,
2825 sizeof(gl_extension_map) / sizeof(*gl_extension_map));
2826
2827 /* Now work out what GL support this card really has. */
2828 load_gl_funcs( gl_info );
2829
2830 hdc = wglGetCurrentDC();
2831 /* Not all GL drivers might offer WGL extensions e.g. VirtualBox. */
2832 if (GL_EXTCALL(wglGetExtensionsStringARB))
2833 WGL_Extensions = (const char *)GL_EXTCALL(wglGetExtensionsStringARB(hdc));
2834 if (!WGL_Extensions)
2835 WARN("WGL extensions not supported.\n");
2836 else
2837 parse_extension_string(gl_info, WGL_Extensions, wgl_extension_map,
2838 sizeof(wgl_extension_map) / sizeof(*wgl_extension_map));
2839
2840 if (!gl_info->supported[EXT_TEXTURE3D] && gl_version >= MAKEDWORD_VERSION(1, 2))
2841 {
2842 TRACE("GL CORE: GL_EXT_texture3D support.\n");
2843 gl_info->gl_ops.ext.p_glTexImage3DEXT = (void *)gl_info->gl_ops.ext.p_glTexImage3D;
2844 gl_info->gl_ops.ext.p_glTexSubImage3DEXT = gl_info->gl_ops.ext.p_glTexSubImage3D;
2845 gl_info->supported[EXT_TEXTURE3D] = TRUE;
2846 }
2847
2848 if (!gl_info->supported[NV_POINT_SPRITE] && gl_version >= MAKEDWORD_VERSION(1, 4))
2849 {
2850 TRACE("GL CORE: GL_NV_point_sprite support.\n");
2851 gl_info->gl_ops.ext.p_glPointParameterivNV = gl_info->gl_ops.ext.p_glPointParameteriv;
2852 gl_info->gl_ops.ext.p_glPointParameteriNV = gl_info->gl_ops.ext.p_glPointParameteri;
2853 gl_info->supported[NV_POINT_SPRITE] = TRUE;
2854 }
2855
2856 if (!gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] && gl_version >= MAKEDWORD_VERSION(2, 0))
2857 {
2858 TRACE("GL CORE: GL_ARB_texture_non_power_of_two support.\n");
2859 gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] = TRUE;
2860 }
2861
2862 if (gl_version >= MAKEDWORD_VERSION(2, 0)) gl_info->supported[WINED3D_GL_VERSION_2_0] = TRUE;
2863
2864 if (gl_info->supported[APPLE_FENCE])
2865 {
2866 /* GL_NV_fence and GL_APPLE_fence provide the same functionality basically.
2867 * The apple extension interacts with some other apple exts. Disable the NV
2868 * extension if the apple one is support to prevent confusion in other parts
2869 * of the code. */
2870 gl_info->supported[NV_FENCE] = FALSE;
2871 }
2872 if (gl_info->supported[APPLE_FLOAT_PIXELS])
2873 {
2874 /* GL_APPLE_float_pixels == GL_ARB_texture_float + GL_ARB_half_float_pixel
2875 *
2876 * The enums are the same:
2877 * GL_RGBA16F_ARB = GL_RGBA_FLOAT16_APPLE = 0x881a
2878 * GL_RGB16F_ARB = GL_RGB_FLOAT16_APPLE = 0x881b
2879 * GL_RGBA32F_ARB = GL_RGBA_FLOAT32_APPLE = 0x8814
2880 * GL_RGB32F_ARB = GL_RGB_FLOAT32_APPLE = 0x8815
2881 * GL_HALF_FLOAT_ARB = GL_HALF_APPLE = 0x140b
2882 */
2883 if (!gl_info->supported[ARB_TEXTURE_FLOAT])
2884 {
2885 TRACE(" IMPLIED: GL_ARB_texture_float support (by GL_APPLE_float_pixels).\n");
2886 gl_info->supported[ARB_TEXTURE_FLOAT] = TRUE;
2887 }
2888 if (!gl_info->supported[ARB_HALF_FLOAT_PIXEL])
2889 {
2890 TRACE(" IMPLIED: GL_ARB_half_float_pixel support (by GL_APPLE_float_pixels).\n");
2891 gl_info->supported[ARB_HALF_FLOAT_PIXEL] = TRUE;
2892 }
2893 }
2894 if (gl_info->supported[ARB_MAP_BUFFER_RANGE])
2895 {
2896 /* GL_ARB_map_buffer_range and GL_APPLE_flush_buffer_range provide the same
2897 * functionality. Prefer the ARB extension */
2898 gl_info->supported[APPLE_FLUSH_BUFFER_RANGE] = FALSE;
2899 }
2900 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
2901 {
2902 TRACE(" IMPLIED: NVIDIA (NV) Texture Gen Reflection support.\n");
2903 gl_info->supported[NV_TEXGEN_REFLECTION] = TRUE;
2904 }
2905 if (!gl_info->supported[ARB_DEPTH_CLAMP] && gl_info->supported[NV_DEPTH_CLAMP])
2906 {
2907 TRACE(" IMPLIED: ARB_depth_clamp support (by NV_depth_clamp).\n");
2908 gl_info->supported[ARB_DEPTH_CLAMP] = TRUE;
2909 }
2910 if (!gl_info->supported[ARB_VERTEX_ARRAY_BGRA] && gl_info->supported[EXT_VERTEX_ARRAY_BGRA])
2911 {
2912 TRACE(" IMPLIED: ARB_vertex_array_bgra support (by EXT_vertex_array_bgra).\n");
2913 gl_info->supported[ARB_VERTEX_ARRAY_BGRA] = TRUE;
2914 }
2915 if (!gl_info->supported[ARB_TEXTURE_COMPRESSION_RGTC] && gl_info->supported[EXT_TEXTURE_COMPRESSION_RGTC])
2916 {
2917 TRACE(" IMPLIED: ARB_texture_compression_rgtc support (by EXT_texture_compression_rgtc).\n");
2918 gl_info->supported[ARB_TEXTURE_COMPRESSION_RGTC] = TRUE;
2919 }
2920 if (gl_info->supported[NV_TEXTURE_SHADER2])
2921 {
2922 if (gl_info->supported[NV_REGISTER_COMBINERS])
2923 {
2924 /* Also disable ATI_FRAGMENT_SHADER if register combiners and texture_shader2
2925 * are supported. The nv extensions provide the same functionality as the
2926 * ATI one, and a bit more(signed pixelformats). */
2927 gl_info->supported[ATI_FRAGMENT_SHADER] = FALSE;
2928 }
2929 }
2930 if (gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO])
2931 {
2932 /* If we have full NP2 texture support, disable
2933 * GL_ARB_texture_rectangle because we will never use it.
2934 * This saves a few redundant glDisable calls. */
2935 gl_info->supported[ARB_TEXTURE_RECTANGLE] = FALSE;
2936 }
2937 if (gl_info->supported[ATI_FRAGMENT_SHADER])
2938 {
2939 /* Disable NV_register_combiners and fragment shader if this is supported.
2940 * generally the NV extensions are preferred over the ATI ones, and this
2941 * extension is disabled if register_combiners and texture_shader2 are both
2942 * supported. So we reach this place only if we have incomplete NV dxlevel 8
2943 * fragment processing support. */
2944 gl_info->supported[NV_REGISTER_COMBINERS] = FALSE;
2945 gl_info->supported[NV_REGISTER_COMBINERS2] = FALSE;
2946 gl_info->supported[NV_TEXTURE_SHADER] = FALSE;
2947 gl_info->supported[NV_TEXTURE_SHADER2] = FALSE;
2948 }
2949 if (gl_info->supported[NV_HALF_FLOAT])
2950 {
2951 /* GL_ARB_half_float_vertex is a subset of GL_NV_half_float. */
2952 gl_info->supported[ARB_HALF_FLOAT_VERTEX] = TRUE;
2953 }
2954 if (gl_info->supported[ARB_FRAMEBUFFER_SRGB] && !gl_info->supported[EXT_TEXTURE_SRGB_DECODE])
2955 {
2956 /* Current wined3d sRGB infrastructure requires EXT_texture_sRGB_decode
2957 * for GL_ARB_framebuffer_sRGB support (without EXT_texture_sRGB_decode
2958 * we never render to sRGB surfaces). */
2959 gl_info->supported[ARB_FRAMEBUFFER_SRGB] = FALSE;
2960 }
2961 if (gl_info->supported[ARB_OCCLUSION_QUERY])
2962 {
2963 GLint counter_bits;
2964
2965 GL_EXTCALL(glGetQueryivARB(GL_SAMPLES_PASSED_ARB, GL_QUERY_COUNTER_BITS_ARB, &counter_bits));
2966 TRACE("Occlusion query counter has %d bits.\n", counter_bits);
2967 if (!counter_bits)
2968 gl_info->supported[ARB_OCCLUSION_QUERY] = FALSE;
2969 }
2970 if (gl_info->supported[ARB_TIMER_QUERY])
2971 {
2972 GLint counter_bits;
2973
2974 GL_EXTCALL(glGetQueryivARB(GL_TIMESTAMP, GL_QUERY_COUNTER_BITS_ARB, &counter_bits));
2975 TRACE("Timestamp query counter has %d bits.\n", counter_bits);
2976 if (!counter_bits)
2977 gl_info->supported[ARB_TIMER_QUERY] = FALSE;
2978 }
2979 if (!gl_info->supported[ATI_TEXTURE_MIRROR_ONCE] && gl_info->supported[EXT_TEXTURE_MIRROR_CLAMP])
2980 {
2981 TRACE(" IMPLIED: ATI_texture_mirror_once support (by EXT_texture_mirror_clamp).\n");
2982 gl_info->supported[ATI_TEXTURE_MIRROR_ONCE] = TRUE;
2983 }
2984 if (!gl_info->supported[ARB_TEXTURE_MIRROR_CLAMP_TO_EDGE] && gl_info->supported[ATI_TEXTURE_MIRROR_ONCE])
2985 {
2986 TRACE(" IMPLIED: ARB_texture_mirror_clamp_to_edge support (by ATI_texture_mirror_once).\n");
2987 gl_info->supported[ARB_TEXTURE_MIRROR_CLAMP_TO_EDGE] = TRUE;
2988 }
2989
2990 wined3d_adapter_init_limits(gl_info);
2991
2992 if (gl_info->supported[ARB_VERTEX_PROGRAM] && test_arb_vs_offset_limit(gl_info))
2993 gl_info->quirks |= WINED3D_QUIRK_ARB_VS_OFFSET_LIMIT;
2994
2995 if (gl_info->supported[ARB_SHADING_LANGUAGE_100])
2996 {
2997 const char *str = (const char *)gl_info->gl_ops.gl.p_glGetString(GL_SHADING_LANGUAGE_VERSION_ARB);
2998 unsigned int major, minor;
2999
3000 TRACE("GLSL version string: %s.\n", debugstr_a(str));
3001
3002 /* The format of the GLSL version string is "major.minor[.release] [vendor info]". */
3003 sscanf(str, "%u.%u", &major, &minor);
3004 gl_info->glsl_version = MAKEDWORD_VERSION(major, minor);
3005 }
3006
3007 checkGLcall("extension detection");
3008
3009 adapter->shader_backend = select_shader_backend(gl_info);
3010 adapter->vertex_pipe = select_vertex_implementation(gl_info, adapter->shader_backend);
3011 adapter->fragment_pipe = select_fragment_implementation(gl_info, adapter->shader_backend);
3012 adapter->blitter = select_blit_implementation(gl_info, adapter->shader_backend);
3013
3014 adapter->shader_backend->shader_get_caps(&adapter->gl_info, &shader_caps);
3015 adapter->d3d_info.vs_clipping = shader_caps.wined3d_caps & WINED3D_SHADER_CAP_VS_CLIPPING;
3016 adapter->d3d_info.limits.vs_version = shader_caps.vs_version;
3017 adapter->d3d_info.limits.gs_version = shader_caps.gs_version;
3018 adapter->d3d_info.limits.ps_version = shader_caps.ps_version;
3019 adapter->d3d_info.limits.vs_uniform_count = shader_caps.vs_uniform_count;
3020 adapter->d3d_info.limits.ps_uniform_count = shader_caps.ps_uniform_count;
3021
3022 adapter->vertex_pipe->vp_get_caps(gl_info, &vertex_caps);
3023 adapter->d3d_info.xyzrhw = vertex_caps.xyzrhw;
3024
3025 adapter->fragment_pipe->get_caps(gl_info, &fragment_caps);
3026 adapter->d3d_info.limits.ffp_blend_stages = fragment_caps.MaxTextureBlendStages;
3027 adapter->d3d_info.limits.ffp_textures = fragment_caps.MaxSimultaneousTextures;
3028 TRACE("Max texture stages: %u.\n", adapter->d3d_info.limits.ffp_blend_stages);
3029
3030 if (gl_info->supported[ARB_FRAMEBUFFER_OBJECT])
3031 {
3032 gl_info->fbo_ops.glIsRenderbuffer = gl_info->gl_ops.ext.p_glIsRenderbuffer;
3033 gl_info->fbo_ops.glBindRenderbuffer = gl_info->gl_ops.ext.p_glBindRenderbuffer;
3034 gl_info->fbo_ops.glDeleteRenderbuffers = gl_info->gl_ops.ext.p_glDeleteRenderbuffers;
3035 gl_info->fbo_ops.glGenRenderbuffers = gl_info->gl_ops.ext.p_glGenRenderbuffers;
3036 gl_info->fbo_ops.glRenderbufferStorage = gl_info->gl_ops.ext.p_glRenderbufferStorage;
3037 gl_info->fbo_ops.glRenderbufferStorageMultisample = gl_info->gl_ops.ext.p_glRenderbufferStorageMultisample;
3038 gl_info->fbo_ops.glGetRenderbufferParameteriv = gl_info->gl_ops.ext.p_glGetRenderbufferParameteriv;
3039 gl_info->fbo_ops.glIsFramebuffer = gl_info->gl_ops.ext.p_glIsFramebuffer;
3040 gl_info->fbo_ops.glBindFramebuffer = gl_info->gl_ops.ext.p_glBindFramebuffer;
3041 gl_info->fbo_ops.glDeleteFramebuffers = gl_info->gl_ops.ext.p_glDeleteFramebuffers;
3042 gl_info->fbo_ops.glGenFramebuffers = gl_info->gl_ops.ext.p_glGenFramebuffers;
3043 gl_info->fbo_ops.glCheckFramebufferStatus = gl_info->gl_ops.ext.p_glCheckFramebufferStatus;
3044 gl_info->fbo_ops.glFramebufferTexture1D = gl_info->gl_ops.ext.p_glFramebufferTexture1D;
3045 gl_info->fbo_ops.glFramebufferTexture2D = gl_info->gl_ops.ext.p_glFramebufferTexture2D;
3046 gl_info->fbo_ops.glFramebufferTexture3D = gl_info->gl_ops.ext.p_glFramebufferTexture3D;
3047 gl_info->fbo_ops.glFramebufferRenderbuffer = gl_info->gl_ops.ext.p_glFramebufferRenderbuffer;
3048 gl_info->fbo_ops.glGetFramebufferAttachmentParameteriv
3049 = gl_info->gl_ops.ext.p_glGetFramebufferAttachmentParameteriv;
3050 gl_info->fbo_ops.glBlitFramebuffer = gl_info->gl_ops.ext.p_glBlitFramebuffer;
3051 gl_info->fbo_ops.glGenerateMipmap = gl_info->gl_ops.ext.p_glGenerateMipmap;
3052 }
3053 else
3054 {
3055 if (gl_info->supported[EXT_FRAMEBUFFER_OBJECT])
3056 {
3057 gl_info->fbo_ops.glIsRenderbuffer = gl_info->gl_ops.ext.p_glIsRenderbufferEXT;
3058 gl_info->fbo_ops.glBindRenderbuffer = gl_info->gl_ops.ext.p_glBindRenderbufferEXT;
3059 gl_info->fbo_ops.glDeleteRenderbuffers = gl_info->gl_ops.ext.p_glDeleteRenderbuffersEXT;
3060 gl_info->fbo_ops.glGenRenderbuffers = gl_info->gl_ops.ext.p_glGenRenderbuffersEXT;
3061 gl_info->fbo_ops.glRenderbufferStorage = gl_info->gl_ops.ext.p_glRenderbufferStorageEXT;
3062 gl_info->fbo_ops.glGetRenderbufferParameteriv = gl_info->gl_ops.ext.p_glGetRenderbufferParameterivEXT;
3063 gl_info->fbo_ops.glIsFramebuffer = gl_info->gl_ops.ext.p_glIsFramebufferEXT;
3064 gl_info->fbo_ops.glBindFramebuffer = gl_info->gl_ops.ext.p_glBindFramebufferEXT;
3065 gl_info->fbo_ops.glDeleteFramebuffers = gl_info->gl_ops.ext.p_glDeleteFramebuffersEXT;
3066 gl_info->fbo_ops.glGenFramebuffers = gl_info->gl_ops.ext.p_glGenFramebuffersEXT;
3067 gl_info->fbo_ops.glCheckFramebufferStatus = gl_info->gl_ops.ext.p_glCheckFramebufferStatusEXT;
3068 gl_info->fbo_ops.glFramebufferTexture1D = gl_info->gl_ops.ext.p_glFramebufferTexture1DEXT;
3069 gl_info->fbo_ops.glFramebufferTexture2D = gl_info->gl_ops.ext.p_glFramebufferTexture2DEXT;
3070 gl_info->fbo_ops.glFramebufferTexture3D = gl_info->gl_ops.ext.p_glFramebufferTexture3DEXT;
3071 gl_info->fbo_ops.glFramebufferRenderbuffer = gl_info->gl_ops.ext.p_glFramebufferRenderbufferEXT;
3072 gl_info->fbo_ops.glGetFramebufferAttachmentParameteriv
3073 = gl_info->gl_ops.ext.p_glGetFramebufferAttachmentParameterivEXT;
3074 gl_info->fbo_ops.glGenerateMipmap = gl_info->gl_ops.ext.p_glGenerateMipmapEXT;
3075 }
3076 else if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
3077 {
3078 WARN_(d3d_perf)("Framebuffer objects not supported, falling back to backbuffer offscreen rendering mode.\n");
3079 wined3d_settings.offscreen_rendering_mode = ORM_BACKBUFFER;
3080 }
3081 if (gl_info->supported[EXT_FRAMEBUFFER_BLIT])
3082 {
3083 gl_info->fbo_ops.glBlitFramebuffer = gl_info->gl_ops.ext.p_glBlitFramebufferEXT;
3084 }
3085 if (gl_info->supported[EXT_FRAMEBUFFER_MULTISAMPLE])
3086 {
3087 gl_info->fbo_ops.glRenderbufferStorageMultisample
3088 = gl_info->gl_ops.ext.p_glRenderbufferStorageMultisampleEXT;
3089 }
3090 }
3091
3092 gl_vendor = wined3d_guess_gl_vendor(gl_info, gl_vendor_str, gl_renderer_str);
3093 card_vendor = wined3d_guess_card_vendor(gl_vendor_str, gl_renderer_str);
3094 TRACE("Found GL_VENDOR (%s)->(0x%04x/0x%04x).\n", debugstr_a(gl_vendor_str), gl_vendor, card_vendor);
3095
3096 device = wined3d_guess_card(gl_info, gl_renderer_str, &gl_vendor, &card_vendor);
3097 TRACE("Found (fake) card: 0x%x (vendor id), 0x%x (device id).\n", card_vendor, device);
3098
3099 gl_info->wrap_lookup[WINED3D_TADDRESS_WRAP - WINED3D_TADDRESS_WRAP] = GL_REPEAT;
3100 gl_info->wrap_lookup[WINED3D_TADDRESS_MIRROR - WINED3D_TADDRESS_WRAP] =
3101 gl_info->supported[ARB_TEXTURE_MIRRORED_REPEAT] ? GL_MIRRORED_REPEAT_ARB : GL_REPEAT;
3102 gl_info->wrap_lookup[WINED3D_TADDRESS_CLAMP - WINED3D_TADDRESS_WRAP] = GL_CLAMP_TO_EDGE;
3103 gl_info->wrap_lookup[WINED3D_TADDRESS_BORDER - WINED3D_TADDRESS_WRAP] =
3104 gl_info->supported[ARB_TEXTURE_BORDER_CLAMP] ? GL_CLAMP_TO_BORDER_ARB : GL_REPEAT;
3105 gl_info->wrap_lookup[WINED3D_TADDRESS_MIRROR_ONCE - WINED3D_TADDRESS_WRAP] =
3106 gl_info->supported[ARB_TEXTURE_MIRROR_CLAMP_TO_EDGE] ? GL_MIRROR_CLAMP_TO_EDGE : GL_REPEAT;
3107
3108 adapter->d3d_info.valid_rt_mask = 0;
3109 for (i = 0; i < gl_info->limits.buffers; ++i)
3110 adapter->d3d_info.valid_rt_mask |= (1 << i);
3111
3112 fixup_extensions(gl_info, gl_renderer_str, gl_vendor, card_vendor, device);
3113 init_driver_info(driver_info, card_vendor, device);
3114 add_gl_compat_wrappers(gl_info);
3115
3116 return TRUE;
3117 }
3118
3119 UINT CDECL wined3d_get_adapter_count(const struct wined3d *wined3d)
3120 {
3121 TRACE("wined3d %p, reporting %u adapters.\n",
3122 wined3d, wined3d->adapter_count);
3123
3124 return wined3d->adapter_count;
3125 }
3126
3127 HRESULT CDECL wined3d_register_software_device(struct wined3d *wined3d, void *init_function)
3128 {
3129 FIXME("wined3d %p, init_function %p stub!\n", wined3d, init_function);
3130
3131 return WINED3D_OK;
3132 }
3133
3134 HMONITOR CDECL wined3d_get_adapter_monitor(const struct wined3d *wined3d, UINT adapter_idx)
3135 {
3136 TRACE("wined3d %p, adapter_idx %u.\n", wined3d, adapter_idx);
3137
3138 if (adapter_idx >= wined3d->adapter_count)
3139 return NULL;
3140
3141 return MonitorFromPoint(wined3d->adapters[adapter_idx].monitorPoint, MONITOR_DEFAULTTOPRIMARY);
3142 }
3143
3144 /* FIXME: GetAdapterModeCount and EnumAdapterModes currently only returns modes
3145 of the same bpp but different resolutions */
3146
3147 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */
3148 UINT CDECL wined3d_get_adapter_mode_count(const struct wined3d *wined3d, UINT adapter_idx,
3149 enum wined3d_format_id format_id, enum wined3d_scanline_ordering scanline_ordering)
3150 {
3151 const struct wined3d_adapter *adapter;
3152 const struct wined3d_format *format;
3153 unsigned int i = 0;
3154 unsigned int j = 0;
3155 UINT format_bits;
3156 DEVMODEW mode;
3157
3158 TRACE("wined3d %p, adapter_idx %u, format %s, scanline_ordering %#x.\n",
3159 wined3d, adapter_idx, debug_d3dformat(format_id), scanline_ordering);
3160
3161 if (adapter_idx >= wined3d->adapter_count)
3162 return 0;
3163
3164 adapter = &wined3d->adapters[adapter_idx];
3165 format = wined3d_get_format(&adapter->gl_info, format_id);
3166 format_bits = format->byte_count * CHAR_BIT;
3167
3168 memset(&mode, 0, sizeof(mode));
3169 mode.dmSize = sizeof(mode);
3170
3171 while (EnumDisplaySettingsExW(adapter->DeviceName, j++, &mode, 0))
3172 {
3173 if (mode.dmFields & DM_DISPLAYFLAGS)
3174 {
3175 if (scanline_ordering == WINED3D_SCANLINE_ORDERING_PROGRESSIVE
3176 && (mode.u2.dmDisplayFlags & DM_INTERLACED))
3177 continue;
3178
3179 if (scanline_ordering == WINED3D_SCANLINE_ORDERING_INTERLACED
3180 && !(mode.u2.dmDisplayFlags & DM_INTERLACED))
3181 continue;
3182 }
3183
3184 if (format_id == WINED3DFMT_UNKNOWN)
3185 {
3186 /* This is for d3d8, do not enumerate P8 here. */
3187 if (mode.dmBitsPerPel == 32 || mode.dmBitsPerPel == 16) ++i;
3188 }
3189 else if (mode.dmBitsPerPel == format_bits)
3190 {
3191 ++i;
3192 }
3193 }
3194
3195 TRACE("Returning %u matching modes (out of %u total) for adapter %u.\n", i, j, adapter_idx);
3196
3197 return i;
3198 }
3199
3200 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */
3201 HRESULT CDECL wined3d_enum_adapter_modes(const struct wined3d *wined3d, UINT adapter_idx,
3202 enum wined3d_format_id format_id, enum wined3d_scanline_ordering scanline_ordering,
3203 UINT mode_idx, struct wined3d_display_mode *mode)
3204 {
3205 const struct wined3d_adapter *adapter;
3206 const struct wined3d_format *format;
3207 UINT format_bits;
3208 DEVMODEW m;
3209 UINT i = 0;
3210 int j = 0;
3211
3212 TRACE("wined3d %p, adapter_idx %u, format %s, scanline_ordering %#x, mode_idx %u, mode %p.\n",
3213 wined3d, adapter_idx, debug_d3dformat(format_id), scanline_ordering, mode_idx, mode);
3214
3215 if (!mode || adapter_idx >= wined3d->adapter_count)
3216 return WINED3DERR_INVALIDCALL;
3217
3218 adapter = &wined3d->adapters[adapter_idx];
3219 format = wined3d_get_format(&adapter->gl_info, format_id);
3220 format_bits = format->byte_count * CHAR_BIT;
3221
3222 memset(&m, 0, sizeof(m));
3223 m.dmSize = sizeof(m);
3224
3225 while (i <= mode_idx)
3226 {
3227 if (!EnumDisplaySettingsExW(adapter->DeviceName, j++, &m, 0))
3228 {
3229 WARN("Invalid mode_idx %u.\n", mode_idx);
3230 return WINED3DERR_INVALIDCALL;
3231 }
3232
3233 if (m.dmFields & DM_DISPLAYFLAGS)
3234 {
3235 if (scanline_ordering == WINED3D_SCANLINE_ORDERING_PROGRESSIVE
3236 && (m.u2.dmDisplayFlags & DM_INTERLACED))
3237 continue;
3238
3239 if (scanline_ordering == WINED3D_SCANLINE_ORDERING_INTERLACED
3240 && !(m.u2.dmDisplayFlags & DM_INTERLACED))
3241 continue;
3242 }
3243
3244 if (format_id == WINED3DFMT_UNKNOWN)
3245 {
3246 /* This is for d3d8, do not enumerate P8 here. */
3247 if (m.dmBitsPerPel == 32 || m.dmBitsPerPel == 16) ++i;
3248 }
3249 else if (m.dmBitsPerPel == format_bits)
3250 {
3251 ++i;
3252 }
3253 }
3254
3255 mode->width = m.dmPelsWidth;
3256 mode->height = m.dmPelsHeight;
3257 mode->refresh_rate = DEFAULT_REFRESH_RATE;
3258 if (m.dmFields & DM_DISPLAYFREQUENCY)
3259 mode->refresh_rate = m.dmDisplayFrequency;
3260
3261 if (format_id == WINED3DFMT_UNKNOWN)
3262 mode->format_id = pixelformat_for_depth(m.dmBitsPerPel);
3263 else
3264 mode->format_id = format_id;
3265
3266 if (!(m.dmFields & DM_DISPLAYFLAGS))
3267 mode->scanline_ordering = WINED3D_SCANLINE_ORDERING_UNKNOWN;
3268 else if (m.u2.dmDisplayFlags & DM_INTERLACED)
3269 mode->scanline_ordering = WINED3D_SCANLINE_ORDERING_INTERLACED;
3270 else
3271 mode->scanline_ordering = WINED3D_SCANLINE_ORDERING_PROGRESSIVE;
3272
3273 TRACE("%ux%u@%u %u bpp, %s %#x.\n", mode->width, mode->height, mode->refresh_rate,
3274 m.dmBitsPerPel, debug_d3dformat(mode->format_id), mode->scanline_ordering);
3275
3276 return WINED3D_OK;
3277 }
3278
3279 HRESULT CDECL wined3d_get_adapter_display_mode(const struct wined3d *wined3d, UINT adapter_idx,
3280 struct wined3d_display_mode *mode, enum wined3d_display_rotation *rotation)
3281 {
3282 const struct wined3d_adapter *adapter;
3283 DEVMODEW m;
3284
3285 TRACE("wined3d %p, adapter_idx %u, display_mode %p, rotation %p.\n",
3286 wined3d, adapter_idx, mode, rotation);
3287
3288 if (!mode || adapter_idx >= wined3d->adapter_count)
3289 return WINED3DERR_INVALIDCALL;
3290
3291 adapter = &wined3d->adapters[adapter_idx];
3292
3293 memset(&m, 0, sizeof(m));
3294 m.dmSize = sizeof(m);
3295
3296 EnumDisplaySettingsExW(adapter->DeviceName, ENUM_CURRENT_SETTINGS, &m, 0);
3297 mode->width = m.dmPelsWidth;
3298 mode->height = m.dmPelsHeight;
3299 mode->refresh_rate = DEFAULT_REFRESH_RATE;
3300 if (m.dmFields & DM_DISPLAYFREQUENCY)
3301 mode->refresh_rate = m.dmDisplayFrequency;
3302 mode->format_id = pixelformat_for_depth(m.dmBitsPerPel);
3303
3304 /* Lie about the format. X11 can't change the color depth, and some apps
3305 * are pretty angry if they SetDisplayMode from 24 to 16 bpp and find out
3306 * that GetDisplayMode still returns 24 bpp. This should probably be
3307 * handled in winex11 instead. */
3308 if (adapter->screen_format && adapter->screen_format != mode->format_id)
3309 {
3310 WARN("Overriding format %s with stored format %s.\n",
3311 debug_d3dformat(mode->format_id),
3312 debug_d3dformat(adapter->screen_format));
3313 mode->format_id = adapter->screen_format;
3314 }
3315
3316 if (!(m.dmFields & DM_DISPLAYFLAGS))
3317 mode->scanline_ordering = WINED3D_SCANLINE_ORDERING_UNKNOWN;
3318 else if (m.u2.dmDisplayFlags & DM_INTERLACED)
3319 mode->scanline_ordering = WINED3D_SCANLINE_ORDERING_INTERLACED;
3320 else
3321 mode->scanline_ordering = WINED3D_SCANLINE_ORDERING_PROGRESSIVE;
3322
3323 if (rotation)
3324 {
3325 switch (m.u1.s2.dmDisplayOrientation)
3326 {
3327 case DMDO_DEFAULT:
3328 *rotation = WINED3D_DISPLAY_ROTATION_0;
3329 break;
3330 case DMDO_90:
3331 *rotation = WINED3D_DISPLAY_ROTATION_90;
3332 break;
3333 case DMDO_180:
3334 *rotation = WINED3D_DISPLAY_ROTATION_180;
3335 break;
3336 case DMDO_270:
3337 *rotation = WINED3D_DISPLAY_ROTATION_270;
3338 break;
3339 default:
3340 FIXME("Unhandled display rotation %#x.\n", m.u1.s2.dmDisplayOrientation);
3341 *rotation = WINED3D_DISPLAY_ROTATION_UNSPECIFIED;
3342 break;
3343 }
3344 }
3345
3346 TRACE("Returning %ux%u@%u %s %#x.\n", mode->width, mode->height,
3347 mode->refresh_rate, debug_d3dformat(mode->format_id),
3348 mode->scanline_ordering);
3349 return WINED3D_OK;
3350 }
3351
3352 HRESULT CDECL wined3d_set_adapter_display_mode(struct wined3d *wined3d,
3353 UINT adapter_idx, const struct wined3d_display_mode *mode)
3354 {
3355 struct wined3d_display_mode current_mode;
3356 const struct wined3d_format *format;
3357 struct wined3d_adapter *adapter;
3358 DEVMODEW devmode;
3359 RECT clip_rc;
3360 HRESULT hr;
3361 LONG ret;
3362
3363 TRACE("wined3d %p, adapter_idx %u, mode %p (%ux%u@%u %s %#x).\n", wined3d, adapter_idx, mode,
3364 mode->width, mode->height, mode->refresh_rate, debug_d3dformat(mode->format_id),
3365 mode->scanline_ordering);
3366
3367 if (adapter_idx >= wined3d->adapter_count)
3368 return WINED3DERR_INVALIDCALL;
3369
3370 adapter = &wined3d->adapters[adapter_idx];
3371 format = wined3d_get_format(&adapter->gl_info, mode->format_id);
3372
3373 memset(&devmode, 0, sizeof(devmode));
3374 devmode.dmSize = sizeof(devmode);
3375 devmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
3376 devmode.dmBitsPerPel = format->byte_count * CHAR_BIT;
3377 devmode.dmPelsWidth = mode->width;
3378 devmode.dmPelsHeight = mode->height;
3379
3380 devmode.dmDisplayFrequency = mode->refresh_rate;
3381 if (mode->refresh_rate)
3382 devmode.dmFields |= DM_DISPLAYFREQUENCY;
3383
3384 if (mode->scanline_ordering != WINED3D_SCANLINE_ORDERING_UNKNOWN)
3385 {
3386 devmode.dmFields |= DM_DISPLAYFLAGS;
3387 if (mode->scanline_ordering == WINED3D_SCANLINE_ORDERING_INTERLACED)
3388 devmode.u2.dmDisplayFlags |= DM_INTERLACED;
3389 }
3390
3391 /* Only change the mode if necessary. */
3392 if (FAILED(hr = wined3d_get_adapter_display_mode(wined3d, adapter_idx, &current_mode, NULL)))
3393 {
3394 ERR("Failed to get current display mode, hr %#x.\n", hr);
3395 }
3396 else if (current_mode.width == mode->width
3397 && current_mode.height == mode->height
3398 && current_mode.format_id == mode->format_id
3399 && (current_mode.refresh_rate == mode->refresh_rate
3400 || !mode->refresh_rate)
3401 && (current_mode.scanline_ordering == mode->scanline_ordering
3402 || mode->scanline_ordering == WINED3D_SCANLINE_ORDERING_UNKNOWN))
3403 {
3404 TRACE("Skipping redundant mode setting call.\n");
3405 return WINED3D_OK;
3406 }
3407
3408 ret = ChangeDisplaySettingsExW(adapter->DeviceName, &devmode, NULL, CDS_FULLSCREEN, NULL);
3409 if (ret != DISP_CHANGE_SUCCESSFUL)
3410 {
3411 if (devmode.dmDisplayFrequency)
3412 {
3413 WARN("ChangeDisplaySettingsExW failed, trying without the refresh rate.\n");
3414 devmode.dmFields &= ~DM_DISPLAYFREQUENCY;
3415 devmode.dmDisplayFrequency = 0;
3416 ret = ChangeDisplaySettingsExW(adapter->DeviceName, &devmode, NULL, CDS_FULLSCREEN, NULL);
3417 }
3418 if (ret != DISP_CHANGE_SUCCESSFUL)
3419 return WINED3DERR_NOTAVAILABLE;
3420 }
3421
3422 /* Store the new values. */
3423 adapter->screen_format = mode->format_id;
3424
3425 /* And finally clip mouse to our screen. */
3426 SetRect(&clip_rc, 0, 0, mode->width, mode->height);
3427 ClipCursor(&clip_rc);
3428
3429 return WINED3D_OK;
3430 }
3431
3432 /* NOTE: due to structure differences between dx8 and dx9 D3DADAPTER_IDENTIFIER,
3433 and fields being inserted in the middle, a new structure is used in place */
3434 HRESULT CDECL wined3d_get_adapter_identifier(const struct wined3d *wined3d,
3435 UINT adapter_idx, DWORD flags, struct wined3d_adapter_identifier *identifier)
3436 {
3437 const struct wined3d_adapter *adapter;
3438 size_t len;
3439
3440 TRACE("wined3d %p, adapter_idx %u, flags %#x, identifier %p.\n",
3441 wined3d, adapter_idx, flags, identifier);
3442
3443 if (adapter_idx >= wined3d->adapter_count)
3444 return WINED3DERR_INVALIDCALL;
3445
3446 adapter = &wined3d->adapters[adapter_idx];
3447
3448 if (identifier->driver_size)
3449 {
3450 const char *name = adapter->driver_info.name;
3451 len = min(strlen(name), identifier->driver_size - 1);
3452 memcpy(identifier->driver, name, len);
3453 memset(&identifier->driver[len], 0, identifier->driver_size - len);
3454 }
3455
3456 if (identifier->description_size)
3457 {
3458 const char *description = adapter->driver_info.description;
3459 len = min(strlen(description), identifier->description_size - 1);
3460 memcpy(identifier->description, description, len);
3461 memset(&identifier->description[len], 0, identifier->description_size - len);
3462 }
3463
3464 /* Note that d3d8 doesn't supply a device name. */
3465 if (identifier->device_name_size)
3466 {
3467 if (!WideCharToMultiByte(CP_ACP, 0, adapter->DeviceName, -1, identifier->device_name,
3468 identifier->device_name_size, NULL, NULL))
3469 {
3470 ERR("Failed to convert device name, last error %#x.\n", GetLastError());
3471 return WINED3DERR_INVALIDCALL;
3472 }
3473 }
3474
3475 identifier->driver_version.u.HighPart = adapter->driver_info.version_high;
3476 identifier->driver_version.u.LowPart = adapter->driver_info.version_low;
3477 identifier->vendor_id = adapter->driver_info.vendor;
3478 identifier->device_id = adapter->driver_info.device;
3479 identifier->subsystem_id = 0;
3480 identifier->revision = 0;
3481 memcpy(&identifier->device_identifier, &IID_D3DDEVICE_D3DUID, sizeof(identifier->device_identifier));
3482 identifier->whql_level = (flags & WINED3DENUM_NO_WHQL_LEVEL) ? 0 : 1;
3483 memcpy(&identifier->adapter_luid, &adapter->luid, sizeof(identifier->adapter_luid));
3484 identifier->video_memory = adapter->TextureRam;
3485
3486 return WINED3D_OK;
3487 }
3488
3489 HRESULT CDECL wined3d_get_adapter_raster_status(const struct wined3d *wined3d, UINT adapter_idx,
3490 struct wined3d_raster_status *raster_status)
3491 {
3492 LONGLONG freq_per_frame, freq_per_line;
3493 LARGE_INTEGER counter, freq_per_sec;
3494 struct wined3d_display_mode mode;
3495 static UINT once;
3496
3497 if (!once++)
3498 FIXME("wined3d %p, adapter_idx %u, raster_status %p semi-stub!\n",
3499 wined3d, adapter_idx, raster_status);
3500 else
3501 WARN("wined3d %p, adapter_idx %u, raster_status %p semi-stub!\n",
3502 wined3d, adapter_idx, raster_status);
3503
3504 /* Obtaining the raster status is a widely implemented but optional
3505 * feature. When this method returns OK StarCraft 2 expects the
3506 * raster_status->InVBlank value to actually change over time.
3507 * And Endless Alice Crysis doesn't care even if this method fails.
3508 * Thus this method returns OK and fakes raster_status by
3509 * QueryPerformanceCounter. */
3510
3511 if (!QueryPerformanceCounter(&counter) || !QueryPerformanceFrequency(&freq_per_sec))
3512 return WINED3DERR_INVALIDCALL;
3513 if (FAILED(wined3d_get_adapter_display_mode(wined3d, adapter_idx, &mode, NULL)))
3514 return WINED3DERR_INVALIDCALL;
3515 if (mode.refresh_rate == DEFAULT_REFRESH_RATE)
3516 mode.refresh_rate = 60;
3517
3518 freq_per_frame = freq_per_sec.QuadPart / mode.refresh_rate;
3519 /* Assume 20 scan lines in the vertical blank. */
3520 freq_per_line = freq_per_frame / (mode.height + 20);
3521 raster_status->scan_line = (counter.QuadPart % freq_per_frame) / freq_per_line;
3522 if (raster_status->scan_line < mode.height)
3523 raster_status->in_vblank = FALSE;
3524 else
3525 {
3526 raster_status->scan_line = 0;
3527 raster_status->in_vblank = TRUE;
3528 }
3529
3530 TRACE("Returning fake value, in_vblank %u, scan_line %u.\n",
3531 raster_status->in_vblank, raster_status->scan_line);
3532
3533 return WINED3D_OK;
3534 }
3535
3536 static BOOL wined3d_check_pixel_format_color(const struct wined3d_gl_info *gl_info,
3537 const struct wined3d_pixel_format *cfg, const struct wined3d_format *format)
3538 {
3539 BYTE redSize, greenSize, blueSize, alphaSize, colorBits;
3540
3541 /* Float formats need FBOs. If FBOs are used this function isn't called */
3542 if (format->flags & WINED3DFMT_FLAG_FLOAT) return FALSE;
3543
3544 if(cfg->iPixelType == WGL_TYPE_RGBA_ARB) { /* Integer RGBA formats */
3545 if (!getColorBits(format, &redSize, &greenSize, &blueSize, &alphaSize, &colorBits))
3546 {
3547 ERR("Unable to check compatibility for format %s.\n", debug_d3dformat(format->id));
3548 return FALSE;
3549 }
3550
3551 if(cfg->redSize < redSize)
3552 return FALSE;
3553
3554 if(cfg->greenSize < greenSize)
3555 return FALSE;
3556
3557 if(cfg->blueSize < blueSize)
3558 return FALSE;
3559
3560 if(cfg->alphaSize < alphaSize)
3561 return FALSE;
3562
3563 return TRUE;
3564 }
3565
3566 /* Probably a RGBA_float or color index mode */
3567 return FALSE;
3568 }
3569
3570 static BOOL wined3d_check_pixel_format_depth(const struct wined3d_gl_info *gl_info,
3571 const struct wined3d_pixel_format *cfg, const struct wined3d_format *format)
3572 {
3573 BYTE depthSize, stencilSize;
3574 BOOL lockable = FALSE;
3575
3576 if (!getDepthStencilBits(format, &depthSize, &stencilSize))
3577 {
3578 ERR("Unable to check compatibility for format %s.\n", debug_d3dformat(format->id));
3579 return FALSE;
3580 }
3581
3582 /* Float formats need FBOs. If FBOs are used this function isn't called */
3583 if (format->flags & WINED3DFMT_FLAG_FLOAT) return FALSE;
3584
3585 if ((format->id == WINED3DFMT_D16_LOCKABLE) || (format->id == WINED3DFMT_D32_FLOAT))
3586 lockable = TRUE;
3587
3588 /* On some modern cards like the Geforce8/9 GLX doesn't offer some dephthstencil formats which D3D9 reports.
3589 * We can safely report 'compatible' formats (e.g. D24 can be used for D16) as long as we aren't dealing with
3590 * a lockable format. This also helps D3D <= 7 as they expect D16 which isn't offered without this on Geforce8 cards. */
3591 if(!(cfg->depthSize == depthSize || (!lockable && cfg->depthSize > depthSize)))
3592 return FALSE;
3593
3594 /* Some cards like Intel i915 ones only offer D24S8 but lots of games also need a format without stencil, so
3595 * allow more stencil bits than requested. */
3596 if(cfg->stencilSize < stencilSize)
3597 return FALSE;
3598
3599 return TRUE;
3600 }
3601
3602 HRESULT CDECL wined3d_check_depth_stencil_match(const struct wined3d *wined3d,
3603 UINT adapter_idx, enum wined3d_device_type device_type, enum wined3d_format_id adapter_format_id,
3604 enum wined3d_format_id render_target_format_id, enum wined3d_format_id depth_stencil_format_id)
3605 {
3606 const struct wined3d_format *rt_format;
3607 const struct wined3d_format *ds_format;
3608 const struct wined3d_adapter *adapter;
3609
3610 TRACE("wined3d %p, adapter_idx %u, device_type %s,\n"
3611 "adapter_format %s, render_target_format %s, depth_stencil_format %s.\n",
3612 wined3d, adapter_idx, debug_d3ddevicetype(device_type), debug_d3dformat(adapter_format_id),
3613 debug_d3dformat(render_target_format_id), debug_d3dformat(depth_stencil_format_id));
3614
3615 if (adapter_idx >= wined3d->adapter_count)
3616 return WINED3DERR_INVALIDCALL;
3617
3618 adapter = &wined3d->adapters[adapter_idx];
3619 rt_format = wined3d_get_format(&adapter->gl_info, render_target_format_id);
3620 ds_format = wined3d_get_format(&adapter->gl_info, depth_stencil_format_id);
3621 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
3622 {
3623 if ((rt_format->flags & WINED3DFMT_FLAG_RENDERTARGET)
3624 && (ds_format->flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL)))
3625 {
3626 TRACE("Formats match.\n");
3627 return WINED3D_OK;
3628 }
3629 }
3630 else
3631 {
3632 const struct wined3d_pixel_format *cfgs;
3633 unsigned int cfg_count;
3634 unsigned int i;
3635
3636 cfgs = adapter->cfgs;
3637 cfg_count = adapter->cfg_count;
3638 for (i = 0; i < cfg_count; ++i)
3639 {
3640 if (wined3d_check_pixel_format_color(&adapter->gl_info, &cfgs[i], rt_format)
3641 && wined3d_check_pixel_format_depth(&adapter->gl_info, &cfgs[i], ds_format))
3642 {
3643 TRACE("Formats match.\n");
3644 return WINED3D_OK;
3645 }
3646 }
3647 }
3648
3649 TRACE("Unsupported format pair: %s and %s.\n",
3650 debug_d3dformat(render_target_format_id),
3651 debug_d3dformat(depth_stencil_format_id));
3652
3653 return WINED3DERR_NOTAVAILABLE;
3654 }
3655
3656 HRESULT CDECL wined3d_check_device_multisample_type(const struct wined3d *wined3d, UINT adapter_idx,
3657 enum wined3d_device_type device_type, enum wined3d_format_id surface_format_id, BOOL windowed,
3658 enum wined3d_multisample_type multisample_type, DWORD *quality_levels)
3659 {
3660 const struct wined3d_gl_info *gl_info;
3661
3662 TRACE("wined3d %p, adapter_idx %u, device_type %s, surface_format %s,\n"
3663 "windowed %#x, multisample_type %#x, quality_levels %p.\n",
3664 wined3d, adapter_idx, debug_d3ddevicetype(device_type), debug_d3dformat(surface_format_id),
3665 windowed, multisample_type, quality_levels);
3666
3667 if (adapter_idx >= wined3d->adapter_count)
3668 return WINED3DERR_INVALIDCALL;
3669
3670 gl_info = &wined3d->adapters[adapter_idx].gl_info;
3671
3672 if (multisample_type > gl_info->limits.samples)
3673 {
3674 TRACE("Returning not supported.\n");
3675 if (quality_levels)
3676 *quality_levels = 0;
3677
3678 return WINED3DERR_NOTAVAILABLE;
3679 }
3680
3681 if (quality_levels)
3682 {
3683 if (multisample_type == WINED3D_MULTISAMPLE_NON_MASKABLE)
3684 /* FIXME: This is probably wrong. */
3685 *quality_levels = gl_info->limits.samples;
3686 else
3687 *quality_levels = 1;
3688 }
3689
3690 return WINED3D_OK;
3691 }
3692
3693 /* Check if the given DisplayFormat + DepthStencilFormat combination is valid for the Adapter */
3694 static BOOL CheckDepthStencilCapability(const struct wined3d_adapter *adapter,
3695 const struct wined3d_format *display_format, const struct wined3d_format *ds_format)
3696 {
3697 /* Only allow depth/stencil formats */
3698 if (!(ds_format->depth_size || ds_format->stencil_size)) return FALSE;
3699
3700 /* Blacklist formats not supported on Windows */
3701 switch (ds_format->id)
3702 {
3703 case WINED3DFMT_S1_UINT_D15_UNORM: /* Breaks the shadowvol2 dx7 sdk sample */
3704 case WINED3DFMT_S4X4_UINT_D24_UNORM:
3705 TRACE("[FAILED] - not supported on windows.\n");
3706 return FALSE;
3707
3708 default:
3709 break;
3710 }
3711
3712 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
3713 {
3714 /* With FBOs WGL limitations do not apply, but the format needs to be FBO attachable */
3715 if (ds_format->flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL)) return TRUE;
3716 }
3717 else
3718 {
3719 unsigned int i;
3720
3721 /* Walk through all WGL pixel formats to find a match */
3722 for (i = 0; i < adapter->cfg_count; ++i)
3723 {
3724 const struct wined3d_pixel_format *cfg = &adapter->cfgs[i];
3725 if (wined3d_check_pixel_format_color(&adapter->gl_info, cfg, display_format)
3726 && wined3d_check_pixel_format_depth(&adapter->gl_info, cfg, ds_format))
3727 return TRUE;
3728 }
3729 }
3730
3731 return FALSE;
3732 }
3733
3734 /* Check the render target capabilities of a format */
3735 static BOOL CheckRenderTargetCapability(const struct wined3d_adapter *adapter,
3736 const struct wined3d_format *adapter_format, const struct wined3d_format *check_format)
3737 {
3738 /* Filter out non-RT formats */
3739 if (!(check_format->flags & WINED3DFMT_FLAG_RENDERTARGET)) return FALSE;
3740 if (wined3d_settings.offscreen_rendering_mode == ORM_BACKBUFFER)
3741 {
3742 BYTE AdapterRed, AdapterGreen, AdapterBlue, AdapterAlpha, AdapterTotalSize;
3743 BYTE CheckRed, CheckGreen, CheckBlue, CheckAlpha, CheckTotalSize;
3744 const struct wined3d_pixel_format *cfgs = adapter->cfgs;
3745 unsigned int i;
3746
3747 getColorBits(adapter_format, &AdapterRed, &AdapterGreen, &AdapterBlue, &AdapterAlpha, &AdapterTotalSize);
3748 getColorBits(check_format, &CheckRed, &CheckGreen, &CheckBlue, &CheckAlpha, &CheckTotalSize);
3749
3750 /* In backbuffer mode the front and backbuffer share the same WGL pixelformat.
3751 * The format must match in RGB, alpha is allowed to be different. (Only the backbuffer can have alpha) */
3752 if (!((AdapterRed == CheckRed) && (AdapterGreen == CheckGreen) && (AdapterBlue == CheckBlue)))
3753 {
3754 TRACE("[FAILED]\n");
3755 return FALSE;
3756 }
3757
3758 /* Check if there is a WGL pixel format matching the requirements, the format should also be window
3759 * drawable (not offscreen; e.g. Nvidia offers R5G6B5 for pbuffers even when X is running at 24bit) */
3760 for (i = 0; i < adapter->cfg_count; ++i)
3761 {
3762 if (cfgs[i].windowDrawable
3763 && wined3d_check_pixel_format_color(&adapter->gl_info, &cfgs[i], check_format))
3764 {
3765 TRACE("Pixel format %d is compatible with format %s.\n",
3766 cfgs[i].iPixelFormat, debug_d3dformat(check_format->id));
3767 return TRUE;
3768 }
3769 }
3770 }
3771 else if(wined3d_settings.offscreen_rendering_mode == ORM_FBO)
3772 {
3773 /* For now return TRUE for FBOs until we have some proper checks.
3774 * Note that this function will only be called when the format is around for texturing. */
3775 return TRUE;
3776 }
3777 return FALSE;
3778 }
3779
3780 static BOOL CheckSurfaceCapability(const struct wined3d_adapter *adapter,
3781 const struct wined3d_format *adapter_format,
3782 const struct wined3d_format *check_format, BOOL no3d)
3783 {
3784 if (no3d)
3785 {
3786 switch (check_format->id)
3787 {
3788 case WINED3DFMT_B8G8R8_UNORM:
3789 TRACE("[FAILED] - Not enumerated on Windows.\n");
3790 return FALSE;
3791 case WINED3DFMT_B8G8R8A8_UNORM:
3792 case WINED3DFMT_B8G8R8X8_UNORM:
3793 case WINED3DFMT_B5G6R5_UNORM:
3794 case WINED3DFMT_B5G5R5X1_UNORM:
3795 case WINED3DFMT_B5G5R5A1_UNORM:
3796 case WINED3DFMT_B4G4R4A4_UNORM:
3797 case WINED3DFMT_B2G3R3_UNORM:
3798 case WINED3DFMT_A8_UNORM:
3799 case WINED3DFMT_B2G3R3A8_UNORM:
3800 case WINED3DFMT_B4G4R4X4_UNORM:
3801 case WINED3DFMT_R10G10B10A2_UNORM:
3802 case WINED3DFMT_R8G8B8A8_UNORM:
3803 case WINED3DFMT_R8G8B8X8_UNORM:
3804 case WINED3DFMT_R16G16_UNORM:
3805 case WINED3DFMT_B10G10R10A2_UNORM:
3806 case WINED3DFMT_R16G16B16A16_UNORM:
3807 case WINED3DFMT_P8_UINT:
3808 TRACE("[OK]\n");
3809 return TRUE;
3810 default:
3811 TRACE("[FAILED] - Not available on GDI surfaces.\n");
3812 return FALSE;
3813 }
3814 }
3815
3816 /* All formats that are supported for textures are supported for surfaces
3817 * as well. */
3818 if (check_format->flags & WINED3DFMT_FLAG_TEXTURE)
3819 return TRUE;
3820 /* All depth stencil formats are supported on surfaces */
3821 if (CheckDepthStencilCapability(adapter, adapter_format, check_format)) return TRUE;
3822
3823 /* If opengl can't process the format natively, the blitter may be able to convert it */
3824 if (adapter->blitter->blit_supported(&adapter->gl_info, WINED3D_BLIT_OP_COLOR_BLIT,
3825 NULL, WINED3D_POOL_DEFAULT, 0, check_format,
3826 NULL, WINED3D_POOL_DEFAULT, 0, adapter_format))
3827 {
3828 TRACE("[OK]\n");
3829 return TRUE;
3830 }
3831
3832 /* Reject other formats */
3833 TRACE("[FAILED]\n");
3834 return FALSE;
3835 }
3836
3837 /* OpenGL supports mipmapping on all formats. Wrapping is unsupported, but we
3838 * have to report mipmapping so we cannot reject WRAPANDMIP. Tests show that
3839 * Windows reports WRAPANDMIP on unfilterable surfaces as well, apparently to
3840 * show that wrapping is supported. The lack of filtering will sort out the
3841 * mipmapping capability anyway.
3842 *
3843 * For now lets report this on all formats, but in the future we may want to
3844 * restrict it to some should applications need that. */
3845 HRESULT CDECL wined3d_check_device_format(const struct wined3d *wined3d, UINT adapter_idx,
3846 enum wined3d_device_type device_type, enum wined3d_format_id adapter_format_id, DWORD usage,
3847 enum wined3d_resource_type resource_type, enum wined3d_format_id check_format_id)
3848 {
3849 const struct wined3d_adapter *adapter = &wined3d->adapters[adapter_idx];
3850 const struct wined3d_gl_info *gl_info = &adapter->gl_info;
3851 const struct wined3d_format *adapter_format = wined3d_get_format(gl_info, adapter_format_id);
3852 const struct wined3d_format *format = wined3d_get_format(gl_info, check_format_id);
3853 DWORD format_flags = 0;
3854 DWORD allowed_usage;
3855
3856 TRACE("wined3d %p, adapter_idx %u, device_type %s, adapter_format %s, usage %s, %s,\n"
3857 "resource_type %s, check_format %s.\n",
3858 wined3d, adapter_idx, debug_d3ddevicetype(device_type), debug_d3dformat(adapter_format_id),
3859 debug_d3dusage(usage), debug_d3dusagequery(usage), debug_d3dresourcetype(resource_type),
3860 debug_d3dformat(check_format_id));
3861
3862 if (adapter_idx >= wined3d->adapter_count)
3863 return WINED3DERR_INVALIDCALL;
3864
3865 switch (resource_type)
3866 {
3867 case WINED3D_RTYPE_CUBE_TEXTURE:
3868 if (!gl_info->supported[ARB_TEXTURE_CUBE_MAP])
3869 {
3870 TRACE("[FAILED] - No cube texture support.\n");
3871 return WINED3DERR_NOTAVAILABLE;
3872 }
3873
3874 format_flags |= WINED3DFMT_FLAG_TEXTURE;
3875 allowed_usage = WINED3DUSAGE_AUTOGENMIPMAP
3876 | WINED3DUSAGE_DYNAMIC
3877 | WINED3DUSAGE_RENDERTARGET
3878 | WINED3DUSAGE_SOFTWAREPROCESSING
3879 | WINED3DUSAGE_QUERY_FILTER
3880 | WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING
3881 | WINED3DUSAGE_QUERY_SRGBREAD
3882 | WINED3DUSAGE_QUERY_SRGBWRITE
3883 | WINED3DUSAGE_QUERY_VERTEXTEXTURE
3884 | WINED3DUSAGE_QUERY_WRAPANDMIP;
3885 break;
3886
3887 case WINED3D_RTYPE_SURFACE:
3888 if (!CheckSurfaceCapability(adapter, adapter_format, format, wined3d->flags & WINED3D_NO3D))
3889 {
3890 TRACE("[FAILED] - Not supported for plain surfaces.\n");
3891 return WINED3DERR_NOTAVAILABLE;
3892 }
3893
3894 allowed_usage = WINED3DUSAGE_DEPTHSTENCIL
3895 | WINED3DUSAGE_RENDERTARGET
3896 | WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
3897 break;
3898
3899 case WINED3D_RTYPE_TEXTURE:
3900 if ((usage & WINED3DUSAGE_DEPTHSTENCIL) && (format->flags & WINED3DFMT_FLAG_SHADOW)
3901 && !gl_info->supported[ARB_SHADOW])
3902 {
3903 TRACE("[FAILED] - No shadow sampler support.\n");
3904 return WINED3DERR_NOTAVAILABLE;
3905 }
3906
3907 format_flags |= WINED3DFMT_FLAG_TEXTURE;
3908 allowed_usage = WINED3DUSAGE_AUTOGENMIPMAP
3909 | WINED3DUSAGE_DEPTHSTENCIL
3910 | WINED3DUSAGE_DYNAMIC
3911 | WINED3DUSAGE_RENDERTARGET
3912 | WINED3DUSAGE_SOFTWAREPROCESSING
3913 | WINED3DUSAGE_QUERY_FILTER
3914 | WINED3DUSAGE_QUERY_LEGACYBUMPMAP
3915 | WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING
3916 | WINED3DUSAGE_QUERY_SRGBREAD
3917 | WINED3DUSAGE_QUERY_SRGBWRITE
3918 | WINED3DUSAGE_QUERY_VERTEXTEXTURE
3919 | WINED3DUSAGE_QUERY_WRAPANDMIP;
3920 break;
3921
3922 case WINED3D_RTYPE_VOLUME_TEXTURE:
3923 case WINED3D_RTYPE_VOLUME:
3924 /* Volume is to VolumeTexture what Surface is to Texture, but its
3925 * usage caps are not documented. Most driver seem to offer
3926 * (nearly) the same on Volume and VolumeTexture, so do that too. */
3927 if (!gl_info->supported[EXT_TEXTURE3D])
3928 {
3929 TRACE("[FAILED] - No volume texture support.\n");
3930 return WINED3DERR_NOTAVAILABLE;
3931 }
3932
3933 /* The GL_EXT_texture_compression_s3tc spec requires that loading
3934 * an s3tc compressed texture results in an error. While the D3D
3935 * refrast does support s3tc volumes, at least the nvidia Windows
3936 * driver does not, so we're free not to support this format. */
3937 switch (check_format_id)
3938 {
3939 case WINED3DFMT_DXT1:
3940 case WINED3DFMT_DXT2:
3941 case WINED3DFMT_DXT3:
3942 case WINED3DFMT_DXT4:
3943 case WINED3DFMT_DXT5:
3944 TRACE("[FAILED] - DXTn does not support 3D textures.\n");
3945 return WINED3DERR_NOTAVAILABLE;
3946
3947 default:
3948 /* Do nothing, continue with checking the format below */
3949 break;
3950 }
3951
3952 format_flags |= WINED3DFMT_FLAG_TEXTURE;
3953 allowed_usage = WINED3DUSAGE_DYNAMIC
3954 | WINED3DUSAGE_SOFTWAREPROCESSING
3955 | WINED3DUSAGE_QUERY_FILTER
3956 | WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING
3957 | WINED3DUSAGE_QUERY_SRGBREAD
3958 | WINED3DUSAGE_QUERY_SRGBWRITE
3959 | WINED3DUSAGE_QUERY_VERTEXTEXTURE
3960 | WINED3DUSAGE_QUERY_WRAPANDMIP;
3961 break;
3962
3963 default:
3964 FIXME("Unhandled resource type %s.\n", debug_d3dresourcetype(resource_type));
3965 return WINED3DERR_NOTAVAILABLE;
3966 }
3967
3968 if ((usage & allowed_usage) != usage)
3969 {
3970 TRACE("Requested usage %#x, but resource type %s only allows %#x.\n",
3971 usage, debug_d3dresourcetype(resource_type), allowed_usage);
3972 return WINED3DERR_NOTAVAILABLE;
3973 }
3974
3975 if (usage & WINED3DUSAGE_QUERY_FILTER)
3976 format_flags |= WINED3DFMT_FLAG_FILTERING;
3977 if (usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING)
3978 format_flags |= WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING;
3979 if (usage & WINED3DUSAGE_QUERY_SRGBREAD)
3980 format_flags |= WINED3DFMT_FLAG_SRGB_READ;
3981 if (usage & WINED3DUSAGE_QUERY_SRGBWRITE)
3982 format_flags |= WINED3DFMT_FLAG_SRGB_WRITE;
3983 if (usage & WINED3DUSAGE_QUERY_VERTEXTEXTURE)
3984 format_flags |= WINED3DFMT_FLAG_VTF;
3985 if (usage & WINED3DUSAGE_QUERY_LEGACYBUMPMAP)
3986 format_flags |= WINED3DFMT_FLAG_BUMPMAP;
3987
3988 if ((format->flags & format_flags) != format_flags)
3989 {
3990 TRACE("Requested format flags %#x, but format %s only has %#x.\n",
3991 format_flags, debug_d3dformat(check_format_id), format->flags);
3992 return WINED3DERR_NOTAVAILABLE;
3993 }
3994
3995 if ((format_flags & WINED3DFMT_FLAG_TEXTURE) && (wined3d->flags & WINED3D_NO3D))
3996 {
3997 TRACE("Requested texturing support, but wined3d was created with WINED3D_NO3D.\n");
3998 return WINED3DERR_NOTAVAILABLE;
3999 }
4000
4001 if ((usage & WINED3DUSAGE_DEPTHSTENCIL)
4002 && !CheckDepthStencilCapability(adapter, adapter_format, format))
4003 {
4004 TRACE("Requested WINED3DUSAGE_DEPTHSTENCIL, but format %s is not supported for depth / stencil buffers.\n",
4005 debug_d3dformat(check_format_id));
4006 return WINED3DERR_NOTAVAILABLE;
4007 }
4008
4009 if ((usage & WINED3DUSAGE_RENDERTARGET)
4010 && !CheckRenderTargetCapability(adapter, adapter_format, format))
4011 {
4012 TRACE("Requested WINED3DUSAGE_RENDERTARGET, but format %s is not supported for render targets.\n",
4013 debug_d3dformat(check_format_id));
4014 return WINED3DERR_NOTAVAILABLE;
4015 }
4016
4017 if ((usage & WINED3DUSAGE_AUTOGENMIPMAP) && !gl_info->supported[SGIS_GENERATE_MIPMAP])
4018 {
4019 TRACE("No WINED3DUSAGE_AUTOGENMIPMAP support, returning WINED3DOK_NOAUTOGEN.\n");
4020 return WINED3DOK_NOAUTOGEN;
4021 }
4022
4023 return WINED3D_OK;
4024 }
4025
4026 HRESULT CDECL wined3d_check_device_format_conversion(const struct wined3d *wined3d, UINT adapter_idx,
4027 enum wined3d_device_type device_type, enum wined3d_format_id src_format, enum wined3d_format_id dst_format)
4028 {
4029 FIXME("wined3d %p, adapter_idx %u, device_type %s, src_format %s, dst_format %s stub!\n",
4030 wined3d, adapter_idx, debug_d3ddevicetype(device_type), debug_d3dformat(src_format),
4031 debug_d3dformat(dst_format));
4032
4033 return WINED3D_OK;
4034 }
4035
4036 HRESULT CDECL wined3d_check_device_type(const struct wined3d *wined3d, UINT adapter_idx,
4037 enum wined3d_device_type device_type, enum wined3d_format_id display_format,
4038 enum wined3d_format_id backbuffer_format, BOOL windowed)
4039 {
4040 BOOL present_conversion = wined3d->flags & WINED3D_PRESENT_CONVERSION;
4041
4042 TRACE("wined3d %p, adapter_idx %u, device_type %s, display_format %s, backbuffer_format %s, windowed %#x.\n",
4043 wined3d, adapter_idx, debug_d3ddevicetype(device_type), debug_d3dformat(display_format),
4044 debug_d3dformat(backbuffer_format), windowed);
4045
4046 if (adapter_idx >= wined3d->adapter_count)
4047 return WINED3DERR_INVALIDCALL;
4048
4049 /* The task of this function is to check whether a certain display / backbuffer format
4050 * combination is available on the given adapter. In fullscreen mode microsoft specified
4051 * that the display format shouldn't provide alpha and that ignoring alpha the backbuffer
4052 * and display format should match exactly.
4053 * In windowed mode format conversion can occur and this depends on the driver. */
4054
4055 /* There are only 4 display formats. */
4056 if (!(display_format == WINED3DFMT_B5G6R5_UNORM
4057 || display_format == WINED3DFMT_B5G5R5X1_UNORM
4058 || display_format == WINED3DFMT_B8G8R8X8_UNORM
4059 || display_format == WINED3DFMT_B10G10R10A2_UNORM))
4060 {
4061 TRACE("Format %s is not supported as display format.\n", debug_d3dformat(display_format));
4062 return WINED3DERR_NOTAVAILABLE;
4063 }
4064
4065 if (!windowed)
4066 {
4067 /* If the requested display format is not available, don't continue. */
4068 if (!wined3d_get_adapter_mode_count(wined3d, adapter_idx,
4069 display_format, WINED3D_SCANLINE_ORDERING_UNKNOWN))
4070 {
4071 TRACE("No available modes for display format %s.\n", debug_d3dformat(display_format));
4072 return WINED3DERR_NOTAVAILABLE;
4073 }
4074
4075 present_conversion = FALSE;
4076 }
4077 else if (display_format == WINED3DFMT_B10G10R10A2_UNORM)
4078 {
4079 /* WINED3DFMT_B10G10R10A2_UNORM is only allowed in fullscreen mode. */
4080 TRACE("Unsupported format combination %s / %s in windowed mode.\n",
4081 debug_d3dformat(display_format), debug_d3dformat(backbuffer_format));
4082 return WINED3DERR_NOTAVAILABLE;
4083 }
4084
4085 if (present_conversion)
4086 {
4087 /* Use the display format as back buffer format if the latter is
4088 * WINED3DFMT_UNKNOWN. */
4089 if (backbuffer_format == WINED3DFMT_UNKNOWN)
4090 backbuffer_format = display_format;
4091
4092 if (FAILED(wined3d_check_device_format_conversion(wined3d, adapter_idx,
4093 device_type, backbuffer_format, display_format)))
4094 {
4095 TRACE("Format conversion from %s to %s not supported.\n",
4096 debug_d3dformat(backbuffer_format), debug_d3dformat(display_format));
4097 return WINED3DERR_NOTAVAILABLE;
4098 }
4099 }
4100 else
4101 {
4102 /* When format conversion from the back buffer format to the display
4103 * format is not allowed, only a limited number of combinations are
4104 * valid. */
4105
4106 if (display_format == WINED3DFMT_B5G6R5_UNORM && backbuffer_format != WINED3DFMT_B5G6R5_UNORM)
4107 {
4108 TRACE("Unsupported format combination %s / %s.\n",
4109 debug_d3dformat(display_format), debug_d3dformat(backbuffer_format));
4110 return WINED3DERR_NOTAVAILABLE;
4111 }
4112
4113 if (display_format == WINED3DFMT_B5G5R5X1_UNORM
4114 && !(backbuffer_format == WINED3DFMT_B5G5R5X1_UNORM || backbuffer_format == WINED3DFMT_B5G5R5A1_UNORM))
4115 {
4116 TRACE("Unsupported format combination %s / %s.\n",
4117 debug_d3dformat(display_format), debug_d3dformat(backbuffer_format));
4118 return WINED3DERR_NOTAVAILABLE;
4119 }
4120
4121 if (display_format == WINED3DFMT_B8G8R8X8_UNORM
4122 && !(backbuffer_format == WINED3DFMT_B8G8R8X8_UNORM || backbuffer_format == WINED3DFMT_B8G8R8A8_UNORM))
4123 {
4124 TRACE("Unsupported format combination %s / %s.\n",
4125 debug_d3dformat(display_format), debug_d3dformat(backbuffer_format));
4126 return WINED3DERR_NOTAVAILABLE;
4127 }
4128
4129 if (display_format == WINED3DFMT_B10G10R10A2_UNORM
4130 && backbuffer_format != WINED3DFMT_B10G10R10A2_UNORM)
4131 {
4132 TRACE("Unsupported format combination %s / %s.\n",
4133 debug_d3dformat(display_format), debug_d3dformat(backbuffer_format));
4134 return WINED3DERR_NOTAVAILABLE;
4135 }
4136 }
4137
4138 /* Validate that the back buffer format is usable for render targets. */
4139 if (FAILED(wined3d_check_device_format(wined3d, adapter_idx, device_type, display_format,
4140 WINED3DUSAGE_RENDERTARGET, WINED3D_RTYPE_SURFACE, backbuffer_format)))
4141 {
4142 TRACE("Format %s not allowed for render targets.\n", debug_d3dformat(backbuffer_format));
4143 return WINED3DERR_NOTAVAILABLE;
4144 }
4145
4146 return WINED3D_OK;
4147 }
4148
4149 HRESULT CDECL wined3d_get_device_caps(const struct wined3d *wined3d, UINT adapter_idx,
4150 enum wined3d_device_type device_type, WINED3DCAPS *caps)
4151 {
4152 const struct wined3d_adapter *adapter = &wined3d->adapters[adapter_idx];
4153 const struct wined3d_gl_info *gl_info = &adapter->gl_info;
4154 struct shader_caps shader_caps;
4155 struct fragment_caps fragment_caps;
4156 struct wined3d_vertex_caps vertex_caps;
4157 DWORD ckey_caps, blit_caps, fx_caps;
4158
4159 TRACE("wined3d %p, adapter_idx %u, device_type %s, caps %p.\n",
4160 wined3d, adapter_idx, debug_d3ddevicetype(device_type), caps);
4161
4162 if (adapter_idx >= wined3d->adapter_count)
4163 return WINED3DERR_INVALIDCALL;
4164
4165 caps->DeviceType = (device_type == WINED3D_DEVICE_TYPE_HAL) ? WINED3D_DEVICE_TYPE_HAL : WINED3D_DEVICE_TYPE_REF;
4166 caps->AdapterOrdinal = adapter_idx;
4167
4168 caps->Caps = 0;
4169 caps->Caps2 = WINED3DCAPS2_CANRENDERWINDOWED |
4170 WINED3DCAPS2_FULLSCREENGAMMA |
4171 WINED3DCAPS2_DYNAMICTEXTURES;
4172 if (gl_info->supported[SGIS_GENERATE_MIPMAP])
4173 caps->Caps2 |= WINED3DCAPS2_CANAUTOGENMIPMAP;
4174
4175 caps->Caps3 = WINED3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD |
4176 WINED3DCAPS3_COPY_TO_VIDMEM |
4177 WINED3DCAPS3_COPY_TO_SYSTEMMEM;
4178
4179 caps->PresentationIntervals = WINED3DPRESENT_INTERVAL_IMMEDIATE |
4180 WINED3DPRESENT_INTERVAL_ONE;
4181
4182 caps->CursorCaps = WINED3DCURSORCAPS_COLOR |
4183 WINED3DCURSORCAPS_LOWRES;
4184
4185 caps->DevCaps = WINED3DDEVCAPS_FLOATTLVERTEX |
4186 WINED3DDEVCAPS_EXECUTESYSTEMMEMORY |
4187 WINED3DDEVCAPS_TLVERTEXSYSTEMMEMORY|
4188 WINED3DDEVCAPS_TLVERTEXVIDEOMEMORY |
4189 WINED3DDEVCAPS_DRAWPRIMTLVERTEX |
4190 WINED3DDEVCAPS_HWTRANSFORMANDLIGHT |
4191 WINED3DDEVCAPS_EXECUTEVIDEOMEMORY |
4192 WINED3DDEVCAPS_PUREDEVICE |
4193 WINED3DDEVCAPS_HWRASTERIZATION |
4194 WINED3DDEVCAPS_TEXTUREVIDEOMEMORY |
4195 WINED3DDEVCAPS_TEXTURESYSTEMMEMORY |
4196 WINED3DDEVCAPS_CANRENDERAFTERFLIP |
4197 WINED3DDEVCAPS_DRAWPRIMITIVES2 |
4198 WINED3DDEVCAPS_DRAWPRIMITIVES2EX;
4199
4200 caps->PrimitiveMiscCaps = WINED3DPMISCCAPS_CULLNONE |
4201 WINED3DPMISCCAPS_CULLCCW |
4202 WINED3DPMISCCAPS_CULLCW |
4203 WINED3DPMISCCAPS_COLORWRITEENABLE |
4204 WINED3DPMISCCAPS_CLIPTLVERTS |
4205 WINED3DPMISCCAPS_CLIPPLANESCALEDPOINTS |
4206 WINED3DPMISCCAPS_MASKZ |
4207 WINED3DPMISCCAPS_BLENDOP |
4208 WINED3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING;
4209 /* TODO:
4210 WINED3DPMISCCAPS_NULLREFERENCE
4211 WINED3DPMISCCAPS_FOGANDSPECULARALPHA
4212 WINED3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS
4213 WINED3DPMISCCAPS_FOGVERTEXCLAMPED */
4214
4215 if (gl_info->supported[EXT_BLEND_EQUATION_SEPARATE] && gl_info->supported[EXT_BLEND_FUNC_SEPARATE])
4216 caps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_SEPARATEALPHABLEND;
4217 if (gl_info->supported[EXT_DRAW_BUFFERS2])
4218 caps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_INDEPENDENTWRITEMASKS;
4219 if (gl_info->supported[ARB_FRAMEBUFFER_SRGB])
4220 caps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_POSTBLENDSRGBCONVERT;
4221
4222 caps->RasterCaps = WINED3DPRASTERCAPS_DITHER |
4223 WINED3DPRASTERCAPS_PAT |
4224 WINED3DPRASTERCAPS_WFOG |
4225 WINED3DPRASTERCAPS_ZFOG |
4226 WINED3DPRASTERCAPS_FOGVERTEX |
4227 WINED3DPRASTERCAPS_FOGTABLE |
4228 WINED3DPRASTERCAPS_STIPPLE |
4229 WINED3DPRASTERCAPS_SUBPIXEL |
4230 WINED3DPRASTERCAPS_ZTEST |
4231 WINED3DPRASTERCAPS_SCISSORTEST |
4232 WINED3DPRASTERCAPS_SLOPESCALEDEPTHBIAS |
4233 WINED3DPRASTERCAPS_DEPTHBIAS;
4234
4235 if (gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC])
4236 {
4237 caps->RasterCaps |= WINED3DPRASTERCAPS_ANISOTROPY |
4238 WINED3DPRASTERCAPS_ZBIAS |
4239 WINED3DPRASTERCAPS_MIPMAPLODBIAS;
4240 }
4241
4242 caps->ZCmpCaps = WINED3DPCMPCAPS_ALWAYS |
4243 WINED3DPCMPCAPS_EQUAL |
4244 WINED3DPCMPCAPS_GREATER |
4245 WINED3DPCMPCAPS_GREATEREQUAL |
4246 WINED3DPCMPCAPS_LESS |
4247 WINED3DPCMPCAPS_LESSEQUAL |
4248 WINED3DPCMPCAPS_NEVER |
4249 WINED3DPCMPCAPS_NOTEQUAL;
4250
4251 /* WINED3DPBLENDCAPS_BOTHINVSRCALPHA and WINED3DPBLENDCAPS_BOTHSRCALPHA
4252 * are legacy settings for srcblend only. */
4253 caps->SrcBlendCaps = WINED3DPBLENDCAPS_BOTHINVSRCALPHA |
4254 WINED3DPBLENDCAPS_BOTHSRCALPHA |
4255 WINED3DPBLENDCAPS_DESTALPHA |
4256 WINED3DPBLENDCAPS_DESTCOLOR |
4257 WINED3DPBLENDCAPS_INVDESTALPHA |
4258 WINED3DPBLENDCAPS_INVDESTCOLOR |
4259 WINED3DPBLENDCAPS_INVSRCALPHA |
4260 WINED3DPBLENDCAPS_INVSRCCOLOR |
4261 WINED3DPBLENDCAPS_ONE |
4262 WINED3DPBLENDCAPS_SRCALPHA |
4263 WINED3DPBLENDCAPS_SRCALPHASAT |
4264 WINED3DPBLENDCAPS_SRCCOLOR |
4265 WINED3DPBLENDCAPS_ZERO;
4266
4267 caps->DestBlendCaps = WINED3DPBLENDCAPS_DESTALPHA |
4268 WINED3DPBLENDCAPS_DESTCOLOR |
4269 WINED3DPBLENDCAPS_INVDESTALPHA |
4270 WINED3DPBLENDCAPS_INVDESTCOLOR |
4271 WINED3DPBLENDCAPS_INVSRCALPHA |
4272 WINED3DPBLENDCAPS_INVSRCCOLOR |
4273 WINED3DPBLENDCAPS_ONE |
4274 WINED3DPBLENDCAPS_SRCALPHA |
4275 WINED3DPBLENDCAPS_SRCCOLOR |
4276 WINED3DPBLENDCAPS_ZERO;
4277
4278 if (gl_info->supported[ARB_BLEND_FUNC_EXTENDED])
4279 caps->DestBlendCaps |= WINED3DPBLENDCAPS_SRCALPHASAT;
4280
4281 if (gl_info->supported[EXT_BLEND_COLOR])
4282 {
4283 caps->SrcBlendCaps |= WINED3DPBLENDCAPS_BLENDFACTOR;
4284 caps->DestBlendCaps |= WINED3DPBLENDCAPS_BLENDFACTOR;
4285 }
4286
4287
4288 caps->AlphaCmpCaps = WINED3DPCMPCAPS_ALWAYS |
4289 WINED3DPCMPCAPS_EQUAL |
4290 WINED3DPCMPCAPS_GREATER |
4291 WINED3DPCMPCAPS_GREATEREQUAL |
4292 WINED3DPCMPCAPS_LESS |
4293 WINED3DPCMPCAPS_LESSEQUAL |
4294 WINED3DPCMPCAPS_NEVER |
4295 WINED3DPCMPCAPS_NOTEQUAL;
4296
4297 caps->ShadeCaps = WINED3DPSHADECAPS_SPECULARGOURAUDRGB |
4298 WINED3DPSHADECAPS_COLORGOURAUDRGB |
4299 WINED3DPSHADECAPS_ALPHAFLATBLEND |
4300 WINED3DPSHADECAPS_ALPHAGOURAUDBLEND |
4301 WINED3DPSHADECAPS_COLORFLATRGB |
4302 WINED3DPSHADECAPS_FOGFLAT |
4303 WINED3DPSHADECAPS_FOGGOURAUD |
4304 WINED3DPSHADECAPS_SPECULARFLATRGB;
4305
4306 caps->TextureCaps = WINED3DPTEXTURECAPS_ALPHA |
4307 WINED3DPTEXTURECAPS_ALPHAPALETTE |
4308 WINED3DPTEXTURECAPS_TRANSPARENCY |
4309 WINED3DPTEXTURECAPS_BORDER |
4310 WINED3DPTEXTURECAPS_MIPMAP |
4311 WINED3DPTEXTURECAPS_PROJECTED |
4312 WINED3DPTEXTURECAPS_PERSPECTIVE;
4313
4314 if (!gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO])
4315 {
4316 caps->TextureCaps |= WINED3DPTEXTURECAPS_POW2 |
4317 WINED3DPTEXTURECAPS_NONPOW2CONDITIONAL;
4318 }
4319
4320 if (gl_info->supported[EXT_TEXTURE3D])
4321 {
4322 caps->TextureCaps |= WINED3DPTEXTURECAPS_VOLUMEMAP |
4323 WINED3DPTEXTURECAPS_MIPVOLUMEMAP;
4324 if (!gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO])
4325 {
4326 caps->TextureCaps |= WINED3DPTEXTURECAPS_VOLUMEMAP_POW2;
4327 }
4328 }
4329
4330 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
4331 {
4332 caps->TextureCaps |= WINED3DPTEXTURECAPS_CUBEMAP |
4333 WINED3DPTEXTURECAPS_MIPCUBEMAP;
4334 if (!gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO])
4335 {
4336 caps->TextureCaps |= WINED3DPTEXTURECAPS_CUBEMAP_POW2;
4337 }
4338 }
4339
4340 caps->TextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR |
4341 WINED3DPTFILTERCAPS_MAGFPOINT |
4342 WINED3DPTFILTERCAPS_MINFLINEAR |
4343 WINED3DPTFILTERCAPS_MINFPOINT |
4344 WINED3DPTFILTERCAPS_MIPFLINEAR |
4345 WINED3DPTFILTERCAPS_MIPFPOINT |
4346 WINED3DPTFILTERCAPS_LINEAR |
4347 WINED3DPTFILTERCAPS_LINEARMIPLINEAR |
4348 WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
4349 WINED3DPTFILTERCAPS_MIPLINEAR |
4350 WINED3DPTFILTERCAPS_MIPNEAREST |
4351 WINED3DPTFILTERCAPS_NEAREST;
4352
4353 if (gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC])
4354 {
4355 caps->TextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC |
4356 WINED3DPTFILTERCAPS_MINFANISOTROPIC;
4357 }
4358
4359 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
4360 {
4361 caps->CubeTextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR |
4362 WINED3DPTFILTERCAPS_MAGFPOINT |
4363 WINED3DPTFILTERCAPS_MINFLINEAR |
4364 WINED3DPTFILTERCAPS_MINFPOINT |
4365 WINED3DPTFILTERCAPS_MIPFLINEAR |
4366 WINED3DPTFILTERCAPS_MIPFPOINT |
4367 WINED3DPTFILTERCAPS_LINEAR |
4368 WINED3DPTFILTERCAPS_LINEARMIPLINEAR |
4369 WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
4370 WINED3DPTFILTERCAPS_MIPLINEAR |
4371 WINED3DPTFILTERCAPS_MIPNEAREST |
4372 WINED3DPTFILTERCAPS_NEAREST;
4373
4374 if (gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC])
4375 {
4376 caps->CubeTextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC |
4377 WINED3DPTFILTERCAPS_MINFANISOTROPIC;
4378 }
4379 }
4380 else
4381 {
4382 caps->CubeTextureFilterCaps = 0;
4383 }
4384
4385 if (gl_info->supported[EXT_TEXTURE3D])
4386 {
4387 caps->VolumeTextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR |
4388 WINED3DPTFILTERCAPS_MAGFPOINT |
4389 WINED3DPTFILTERCAPS_MINFLINEAR |
4390 WINED3DPTFILTERCAPS_MINFPOINT |
4391 WINED3DPTFILTERCAPS_MIPFLINEAR |
4392 WINED3DPTFILTERCAPS_MIPFPOINT |
4393 WINED3DPTFILTERCAPS_LINEAR |
4394 WINED3DPTFILTERCAPS_LINEARMIPLINEAR |
4395 WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
4396 WINED3DPTFILTERCAPS_MIPLINEAR |
4397 WINED3DPTFILTERCAPS_MIPNEAREST |
4398 WINED3DPTFILTERCAPS_NEAREST;
4399 }
4400 else
4401 {
4402 caps->VolumeTextureFilterCaps = 0;
4403 }
4404
4405 caps->TextureAddressCaps = WINED3DPTADDRESSCAPS_INDEPENDENTUV |
4406 WINED3DPTADDRESSCAPS_CLAMP |
4407 WINED3DPTADDRESSCAPS_WRAP;
4408
4409 if (gl_info->supported[ARB_TEXTURE_BORDER_CLAMP])
4410 {
4411 caps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_BORDER;
4412 }
4413 if (gl_info->supported[ARB_TEXTURE_MIRRORED_REPEAT])
4414 {
4415 caps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRROR;
4416 }
4417 if (gl_info->supported[ARB_TEXTURE_MIRROR_CLAMP_TO_EDGE])
4418 {
4419 caps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRRORONCE;
4420 }
4421
4422 if (gl_info->supported[EXT_TEXTURE3D])
4423 {
4424 caps->VolumeTextureAddressCaps = WINED3DPTADDRESSCAPS_INDEPENDENTUV |
4425 WINED3DPTADDRESSCAPS_CLAMP |
4426 WINED3DPTADDRESSCAPS_WRAP;
4427 if (gl_info->supported[ARB_TEXTURE_BORDER_CLAMP])
4428 {
4429 caps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_BORDER;
4430 }
4431 if (gl_info->supported[ARB_TEXTURE_MIRRORED_REPEAT])
4432 {
4433 caps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRROR;
4434 }
4435 if (gl_info->supported[ARB_TEXTURE_MIRROR_CLAMP_TO_EDGE])
4436 {
4437 caps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRRORONCE;
4438 }
4439 }
4440 else
4441 {
4442 caps->VolumeTextureAddressCaps = 0;
4443 }
4444
4445 caps->LineCaps = WINED3DLINECAPS_TEXTURE |
4446 WINED3DLINECAPS_ZTEST |
4447 WINED3DLINECAPS_BLEND |
4448 WINED3DLINECAPS_ALPHACMP |
4449 WINED3DLINECAPS_FOG;
4450 /* WINED3DLINECAPS_ANTIALIAS is not supported on Windows, and dx and gl seem to have a different
4451 * idea how generating the smoothing alpha values works; the result is different
4452 */
4453
4454 caps->MaxTextureWidth = gl_info->limits.texture_size;
4455 caps->MaxTextureHeight = gl_info->limits.texture_size;
4456
4457 if (gl_info->supported[EXT_TEXTURE3D])
4458 caps->MaxVolumeExtent = gl_info->limits.texture3d_size;
4459 else
4460 caps->MaxVolumeExtent = 0;
4461
4462 caps->MaxTextureRepeat = 32768;
4463 caps->MaxTextureAspectRatio = gl_info->limits.texture_size;
4464 caps->MaxVertexW = 1.0f;
4465
4466 caps->GuardBandLeft = 0.0f;
4467 caps->GuardBandTop = 0.0f;
4468 caps->GuardBandRight = 0.0f;
4469 caps->GuardBandBottom = 0.0f;
4470
4471 caps->ExtentsAdjust = 0.0f;
4472
4473 caps->StencilCaps = WINED3DSTENCILCAPS_DECRSAT |
4474 WINED3DSTENCILCAPS_INCRSAT |
4475 WINED3DSTENCILCAPS_INVERT |
4476 WINED3DSTENCILCAPS_KEEP |
4477 WINED3DSTENCILCAPS_REPLACE |
4478 WINED3DSTENCILCAPS_ZERO;
4479 if (gl_info->supported[EXT_STENCIL_WRAP])
4480 {
4481 caps->StencilCaps |= WINED3DSTENCILCAPS_DECR |
4482 WINED3DSTENCILCAPS_INCR;
4483 }
4484 if (gl_info->supported[EXT_STENCIL_TWO_SIDE] || gl_info->supported[ATI_SEPARATE_STENCIL])
4485 {
4486 caps->StencilCaps |= WINED3DSTENCILCAPS_TWOSIDED;
4487 }
4488
4489 caps->MaxAnisotropy = gl_info->limits.anisotropy;
4490 caps->MaxPointSize = gl_info->limits.pointsize_max;
4491
4492 caps->MaxPrimitiveCount = 0x555555; /* Taken from an AMD Radeon HD 5700 (Evergreen) GPU. */
4493 caps->MaxVertexIndex = 0xffffff; /* Taken from an AMD Radeon HD 5700 (Evergreen) GPU. */
4494 caps->MaxStreams = MAX_STREAMS;
4495 caps->MaxStreamStride = 1024;
4496
4497 /* d3d9.dll sets D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES here because StretchRects is implemented in d3d9 */
4498 caps->DevCaps2 = WINED3DDEVCAPS2_STREAMOFFSET |
4499 WINED3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET;
4500 caps->MaxNpatchTessellationLevel = 0;
4501 caps->MasterAdapterOrdinal = 0;
4502 caps->AdapterOrdinalInGroup = 0;
4503 caps->NumberOfAdaptersInGroup = 1;
4504
4505 caps->NumSimultaneousRTs = gl_info->limits.buffers;
4506
4507 caps->StretchRectFilterCaps = WINED3DPTFILTERCAPS_MINFPOINT |
4508 WINED3DPTFILTERCAPS_MAGFPOINT |
4509 WINED3DPTFILTERCAPS_MINFLINEAR |
4510 WINED3DPTFILTERCAPS_MAGFLINEAR;
4511 caps->VertexTextureFilterCaps = 0;
4512
4513 adapter->shader_backend->shader_get_caps(&adapter->gl_info, &shader_caps);
4514 adapter->fragment_pipe->get_caps(&adapter->gl_info, &fragment_caps);
4515 adapter->vertex_pipe->vp_get_caps(&adapter->gl_info, &vertex_caps);
4516
4517 /* Add shader misc caps. Only some of them belong to the shader parts of the pipeline */
4518 caps->PrimitiveMiscCaps |= fragment_caps.PrimitiveMiscCaps;
4519
4520 caps->VertexShaderVersion = shader_caps.vs_version;
4521 caps->MaxVertexShaderConst = shader_caps.vs_uniform_count;
4522
4523 caps->PixelShaderVersion = shader_caps.ps_version;
4524 caps->PixelShader1xMaxValue = shader_caps.ps_1x_max_value;
4525
4526 caps->TextureOpCaps = fragment_caps.TextureOpCaps;
4527 caps->MaxTextureBlendStages = fragment_caps.MaxTextureBlendStages;
4528 caps->MaxSimultaneousTextures = fragment_caps.MaxSimultaneousTextures;
4529
4530 caps->MaxUserClipPlanes = vertex_caps.max_user_clip_planes;
4531 caps->MaxActiveLights = vertex_caps.max_active_lights;
4532 caps->MaxVertexBlendMatrices = vertex_caps.max_vertex_blend_matrices;
4533 caps->MaxVertexBlendMatrixIndex = vertex_caps.max_vertex_blend_matrix_index;
4534 caps->VertexProcessingCaps = vertex_caps.vertex_processing_caps;
4535 caps->FVFCaps = vertex_caps.fvf_caps;
4536 caps->RasterCaps |= vertex_caps.raster_caps;
4537
4538 /* The following caps are shader specific, but they are things we cannot detect, or which
4539 * are the same among all shader models. So to avoid code duplication set the shader version
4540 * specific, but otherwise constant caps here
4541 */
4542 if (caps->VertexShaderVersion >= 3)
4543 {
4544 /* Where possible set the caps based on OpenGL extensions and if they
4545 * aren't set (in case of software rendering) use the VS 3.0 from
4546 * MSDN or else if there's OpenGL spec use a hardcoded value minimum
4547 * VS3.0 value. */
4548 caps->VS20Caps.caps = WINED3DVS20CAPS_PREDICATION;
4549 /* VS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
4550 caps->VS20Caps.dynamic_flow_control_depth = WINED3DVS20_MAX_DYNAMICFLOWCONTROLDEPTH;
4551 caps->VS20Caps.temp_count = max(32, adapter->gl_info.limits.arb_vs_temps);
4552 /* level of nesting in loops / if-statements; VS 3.0 requires MAX (4) */
4553 caps->VS20Caps.static_flow_control_depth = WINED3DVS20_MAX_STATICFLOWCONTROLDEPTH;
4554
4555 caps->MaxVShaderInstructionsExecuted = 65535; /* VS 3.0 needs at least 65535, some cards even use 2^32-1 */
4556 caps->MaxVertexShader30InstructionSlots = max(512, adapter->gl_info.limits.arb_vs_instructions);
4557 caps->VertexTextureFilterCaps = WINED3DPTFILTERCAPS_MINFPOINT | WINED3DPTFILTERCAPS_MAGFPOINT;
4558 }
4559 else if (caps->VertexShaderVersion == 2)
4560 {
4561 caps->VS20Caps.caps = 0;
4562 caps->VS20Caps.dynamic_flow_control_depth = WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH;
4563 caps->VS20Caps.temp_count = max(12, adapter->gl_info.limits.arb_vs_temps);
4564 caps->VS20Caps.static_flow_control_depth = 1;
4565
4566 caps->MaxVShaderInstructionsExecuted = 65535;
4567 caps->MaxVertexShader30InstructionSlots = 0;
4568 }
4569 else
4570 { /* VS 1.x */
4571 caps->VS20Caps.caps = 0;
4572 caps->VS20Caps.dynamic_flow_control_depth = 0;
4573 caps->VS20Caps.temp_count = 0;
4574 caps->VS20Caps.static_flow_control_depth = 0;
4575
4576 caps->MaxVShaderInstructionsExecuted = 0;
4577 caps->MaxVertexShader30InstructionSlots = 0;
4578 }
4579
4580 if (caps->PixelShaderVersion >= 3)
4581 {
4582 /* Where possible set the caps based on OpenGL extensions and if they
4583 * aren't set (in case of software rendering) use the PS 3.0 from
4584 * MSDN or else if there's OpenGL spec use a hardcoded value minimum
4585 * PS 3.0 value. */
4586
4587 /* Caps is more or less undocumented on MSDN but it appears to be
4588 * used for PS20Caps based on results from R9600/FX5900/Geforce6800
4589 * cards from Windows */
4590 caps->PS20Caps.caps = WINED3DPS20CAPS_ARBITRARYSWIZZLE |
4591 WINED3DPS20CAPS_GRADIENTINSTRUCTIONS |
4592 WINED3DPS20CAPS_PREDICATION |
4593 WINED3DPS20CAPS_NODEPENDENTREADLIMIT |
4594 WINED3DPS20CAPS_NOTEXINSTRUCTIONLIMIT;
4595 /* PS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
4596 caps->PS20Caps.dynamic_flow_control_depth = WINED3DPS20_MAX_DYNAMICFLOWCONTROLDEPTH;
4597 caps->PS20Caps.temp_count = max(32, adapter->gl_info.limits.arb_ps_temps);
4598 /* PS 3.0 requires MAX_STATICFLOWCONTROLDEPTH (4) */
4599 caps->PS20Caps.static_flow_control_depth = WINED3DPS20_MAX_STATICFLOWCONTROLDEPTH;
4600 /* PS 3.0 requires MAX_NUMINSTRUCTIONSLOTS (512) */
4601 caps->PS20Caps.instruction_slot_count = WINED3DPS20_MAX_NUMINSTRUCTIONSLOTS;
4602
4603 caps->MaxPShaderInstructionsExecuted = 65535;
4604 caps->MaxPixelShader30InstructionSlots = max(WINED3DMIN30SHADERINSTRUCTIONS,
4605 adapter->gl_info.limits.arb_ps_instructions);
4606 }
4607 else if(caps->PixelShaderVersion == 2)
4608 {
4609 /* Below we assume PS2.0 specs, not extended 2.0a(GeforceFX)/2.0b(Radeon R3xx) ones */
4610 caps->PS20Caps.caps = 0;
4611 caps->PS20Caps.dynamic_flow_control_depth = 0; /* WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH = 0 */
4612 caps->PS20Caps.temp_count = max(12, adapter->gl_info.limits.arb_ps_temps);
4613 caps->PS20Caps.static_flow_control_depth = WINED3DPS20_MIN_STATICFLOWCONTROLDEPTH; /* Minimum: 1 */
4614 /* Minimum number (64 ALU + 32 Texture), a GeforceFX uses 512 */
4615 caps->PS20Caps.instruction_slot_count = WINED3DPS20_MIN_NUMINSTRUCTIONSLOTS;
4616
4617 caps->MaxPShaderInstructionsExecuted = 512; /* Minimum value, a GeforceFX uses 1024 */
4618 caps->MaxPixelShader30InstructionSlots = 0;
4619 }
4620 else /* PS 1.x */
4621 {
4622 caps->PS20Caps.caps = 0;
4623 caps->PS20Caps.dynamic_flow_control_depth = 0;
4624 caps->PS20Caps.temp_count = 0;
4625 caps->PS20Caps.static_flow_control_depth = 0;
4626 caps->PS20Caps.instruction_slot_count = 0;
4627
4628 caps->MaxPShaderInstructionsExecuted = 0;
4629 caps->MaxPixelShader30InstructionSlots = 0;
4630 }
4631
4632 if (caps->VertexShaderVersion >= 2)
4633 {
4634 /* OpenGL supports all the formats below, perhaps not always
4635 * without conversion, but it supports them.
4636 * Further GLSL doesn't seem to have an official unsigned type so
4637 * don't advertise it yet as I'm not sure how we handle it.
4638 * We might need to add some clamping in the shader engine to
4639 * support it.
4640 * TODO: WINED3DDTCAPS_USHORT2N, WINED3DDTCAPS_USHORT4N, WINED3DDTCAPS_UDEC3, WINED3DDTCAPS_DEC3N */
4641 caps->DeclTypes = WINED3DDTCAPS_UBYTE4 |
4642 WINED3DDTCAPS_UBYTE4N |
4643 WINED3DDTCAPS_SHORT2N |
4644 WINED3DDTCAPS_SHORT4N;
4645 if (gl_info->supported[ARB_HALF_FLOAT_VERTEX])
4646 {
4647 caps->DeclTypes |= WINED3DDTCAPS_FLOAT16_2 |
4648 WINED3DDTCAPS_FLOAT16_4;
4649 }
4650 }
4651 else
4652 {
4653 caps->DeclTypes = 0;
4654 }
4655
4656 /* Set DirectDraw helper Caps */
4657 ckey_caps = WINEDDCKEYCAPS_DESTBLT |
4658 WINEDDCKEYCAPS_SRCBLT;
4659 fx_caps = WINEDDFXCAPS_BLTALPHA |
4660 WINEDDFXCAPS_BLTMIRRORLEFTRIGHT |
4661 WINEDDFXCAPS_BLTMIRRORUPDOWN |
4662 WINEDDFXCAPS_BLTROTATION90 |
4663 WINEDDFXCAPS_BLTSHRINKX |
4664 WINEDDFXCAPS_BLTSHRINKXN |
4665 WINEDDFXCAPS_BLTSHRINKY |
4666 WINEDDFXCAPS_BLTSHRINKXN |
4667 WINEDDFXCAPS_BLTSTRETCHX |
4668 WINEDDFXCAPS_BLTSTRETCHXN |
4669 WINEDDFXCAPS_BLTSTRETCHY |
4670 WINEDDFXCAPS_BLTSTRETCHYN;
4671 blit_caps = WINEDDCAPS_BLT |
4672 WINEDDCAPS_BLTCOLORFILL |
4673 WINEDDCAPS_BLTDEPTHFILL |
4674 WINEDDCAPS_BLTSTRETCH |
4675 WINEDDCAPS_CANBLTSYSMEM |
4676 WINEDDCAPS_CANCLIP |
4677 WINEDDCAPS_CANCLIPSTRETCHED |
4678 WINEDDCAPS_COLORKEY |
4679 WINEDDCAPS_COLORKEYHWASSIST |
4680 WINEDDCAPS_ALIGNBOUNDARYSRC;
4681
4682 /* Fill the ddraw caps structure */
4683 caps->ddraw_caps.caps = WINEDDCAPS_GDI |
4684 WINEDDCAPS_PALETTE |
4685 blit_caps;
4686 caps->ddraw_caps.caps2 = WINEDDCAPS2_CERTIFIED |
4687 WINEDDCAPS2_NOPAGELOCKREQUIRED |
4688 WINEDDCAPS2_PRIMARYGAMMA |
4689 WINEDDCAPS2_WIDESURFACES |
4690 WINEDDCAPS2_CANRENDERWINDOWED;
4691 caps->ddraw_caps.color_key_caps = ckey_caps;
4692 caps->ddraw_caps.fx_caps = fx_caps;
4693 caps->ddraw_caps.svb_caps = blit_caps;
4694 caps->ddraw_caps.svb_color_key_caps = ckey_caps;
4695 caps->ddraw_caps.svb_fx_caps = fx_caps;
4696 caps->ddraw_caps.vsb_caps = blit_caps;
4697 caps->ddraw_caps.vsb_color_key_caps = ckey_caps;
4698 caps->ddraw_caps.vsb_fx_caps = fx_caps;
4699 caps->ddraw_caps.ssb_caps = blit_caps;
4700 caps->ddraw_caps.ssb_color_key_caps = ckey_caps;
4701 caps->ddraw_caps.ssb_fx_caps = fx_caps;
4702
4703 caps->ddraw_caps.dds_caps = WINEDDSCAPS_ALPHA |
4704 WINEDDSCAPS_BACKBUFFER |
4705 WINEDDSCAPS_FLIP |
4706 WINEDDSCAPS_FRONTBUFFER |
4707 WINEDDSCAPS_OFFSCREENPLAIN |
4708 WINEDDSCAPS_PALETTE |
4709 WINEDDSCAPS_PRIMARYSURFACE |
4710 WINEDDSCAPS_SYSTEMMEMORY |
4711 WINEDDSCAPS_VIDEOMEMORY |
4712 WINEDDSCAPS_VISIBLE;
4713
4714 if (!(wined3d->flags & WINED3D_NO3D))
4715 {
4716 caps->ddraw_caps.dds_caps |= WINEDDSCAPS_3DDEVICE |
4717 WINEDDSCAPS_MIPMAP |
4718 WINEDDSCAPS_TEXTURE |
4719 WINEDDSCAPS_ZBUFFER;
4720 caps->ddraw_caps.caps |= WINEDDCAPS_3D;
4721 }
4722
4723 return WINED3D_OK;
4724 }
4725
4726 HRESULT CDECL wined3d_device_create(struct wined3d *wined3d, UINT adapter_idx, enum wined3d_device_type device_type,
4727 HWND focus_window, DWORD flags, BYTE surface_alignment, struct wined3d_device_parent *device_parent,
4728 struct wined3d_device **device)
4729 {
4730 struct wined3d_device *object;
4731 HRESULT hr;
4732
4733 TRACE("wined3d %p, adapter_idx %u, device_type %#x, focus_window %p, flags %#x, device_parent %p, device %p.\n",
4734 wined3d, adapter_idx, device_type, focus_window, flags, device_parent, device);
4735
4736 /* Validate the adapter number. If no adapters are available(no GL), ignore the adapter
4737 * number and create a device without a 3D adapter for 2D only operation. */
4738 if (wined3d->adapter_count && adapter_idx >= wined3d->adapter_count)
4739 return WINED3DERR_INVALIDCALL;
4740
4741 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
4742 if (!object)
4743 return E_OUTOFMEMORY;
4744
4745 hr = device_init(object, wined3d, adapter_idx, device_type,
4746 focus_window, flags, surface_alignment, device_parent);
4747 if (FAILED(hr))
4748 {
4749 WARN("Failed to initialize device, hr %#x.\n", hr);
4750 HeapFree(GetProcessHeap(), 0, object);
4751 return hr;
4752 }
4753
4754 TRACE("Created device %p.\n", object);
4755 *device = object;
4756
4757 device_parent->ops->wined3d_device_created(device_parent, *device);
4758
4759 return WINED3D_OK;
4760 }
4761
4762 static void WINE_GLAPI invalid_func(const void *data)
4763 {
4764 ERR("Invalid vertex attribute function called\n");
4765 DebugBreak();
4766 }
4767
4768 static void WINE_GLAPI invalid_texcoord_func(GLenum unit, const void *data)
4769 {
4770 ERR("Invalid texcoord function called\n");
4771 DebugBreak();
4772 }
4773
4774 /* Helper functions for providing vertex data to opengl. The arrays are initialized based on
4775 * the extension detection and are used in drawStridedSlow
4776 */
4777 static void WINE_GLAPI position_d3dcolor(const void *data)
4778 {
4779 DWORD pos = *((const DWORD *)data);
4780
4781 FIXME("Add a test for fixed function position from d3dcolor type\n");
4782 context_get_current()->gl_info->gl_ops.gl.p_glVertex4s(D3DCOLOR_B_R(pos),
4783 D3DCOLOR_B_G(pos),
4784 D3DCOLOR_B_B(pos),
4785 D3DCOLOR_B_A(pos));
4786 }
4787
4788 static void WINE_GLAPI position_float4(const void *data)
4789 {
4790 const GLfloat *pos = data;
4791
4792 if (pos[3] != 0.0f && pos[3] != 1.0f)
4793 {
4794 float w = 1.0f / pos[3];
4795
4796 context_get_current()->gl_info->gl_ops.gl.p_glVertex4f(pos[0] * w, pos[1] * w, pos[2] * w, w);
4797 }
4798 else
4799 {
4800 context_get_current()->gl_info->gl_ops.gl.p_glVertex3fv(pos);
4801 }
4802 }
4803
4804 static void WINE_GLAPI diffuse_d3dcolor(const void *data)
4805 {
4806 DWORD diffuseColor = *((const DWORD *)data);
4807
4808 context_get_current()->gl_info->gl_ops.gl.p_glColor4ub(D3DCOLOR_B_R(diffuseColor),
4809 D3DCOLOR_B_G(diffuseColor),
4810 D3DCOLOR_B_B(diffuseColor),
4811 D3DCOLOR_B_A(diffuseColor));
4812 }
4813
4814 static void WINE_GLAPI specular_d3dcolor(const void *data)
4815 {
4816 DWORD specularColor = *((const DWORD *)data);
4817 GLubyte d[] =
4818 {
4819 D3DCOLOR_B_R(specularColor),
4820 D3DCOLOR_B_G(specularColor),
4821 D3DCOLOR_B_B(specularColor)
4822 };
4823
4824 context_get_current()->gl_info->gl_ops.ext.p_glSecondaryColor3ubvEXT(d);
4825 }
4826
4827 static void WINE_GLAPI warn_no_specular_func(const void *data)
4828 {
4829 WARN("GL_EXT_secondary_color not supported\n");
4830 }
4831
4832 static void wined3d_adapter_init_ffp_attrib_ops(struct wined3d_adapter *adapter)
4833 {
4834 const struct wined3d_gl_info *gl_info = &adapter->gl_info;
4835 struct wined3d_d3d_info *d3d_info = &adapter->d3d_info;
4836 struct wined3d_ffp_attrib_ops *ops = &d3d_info->ffp_attrib_ops;
4837
4838 ops->position[WINED3D_FFP_EMIT_FLOAT1] = invalid_func;
4839 ops->position[WINED3D_FFP_EMIT_FLOAT2] = invalid_func;
4840 ops->position[WINED3D_FFP_EMIT_FLOAT3] = (wined3d_ffp_attrib_func)gl_info->gl_ops.gl.p_glVertex3fv;
4841 if (!d3d_info->xyzrhw)
4842 ops->position[WINED3D_FFP_EMIT_FLOAT4] = position_float4;
4843 else
4844 ops->position[WINED3D_FFP_EMIT_FLOAT4] = (wined3d_ffp_attrib_func)gl_info->gl_ops.gl.p_glVertex4fv;
4845 ops->position[WINED3D_FFP_EMIT_D3DCOLOR] = position_d3dcolor;
4846 ops->position[WINED3D_FFP_EMIT_UBYTE4] = invalid_func;
4847 ops->position[WINED3D_FFP_EMIT_SHORT2] = invalid_func;
4848 ops->position[WINED3D_FFP_EMIT_SHORT4] = (wined3d_ffp_attrib_func)gl_info->gl_ops.gl.p_glVertex2sv;
4849 ops->position[WINED3D_FFP_EMIT_UBYTE4N] = invalid_func;
4850 ops->position[WINED3D_FFP_EMIT_SHORT2N] = invalid_func;
4851 ops->position[WINED3D_FFP_EMIT_SHORT4N] = invalid_func;
4852 ops->position[WINED3D_FFP_EMIT_USHORT2N] = invalid_func;
4853 ops->position[WINED3D_FFP_EMIT_USHORT4N] = invalid_func;
4854 ops->position[WINED3D_FFP_EMIT_UDEC3] = invalid_func;
4855 ops->position[WINED3D_FFP_EMIT_DEC3N] = invalid_func;
4856 ops->position[WINED3D_FFP_EMIT_FLOAT16_2] = invalid_func;
4857 ops->position[WINED3D_FFP_EMIT_FLOAT16_4] = invalid_func;
4858 ops->position[WINED3D_FFP_EMIT_INVALID] = invalid_func;
4859
4860 ops->diffuse[WINED3D_FFP_EMIT_FLOAT1] = invalid_func;
4861 ops->diffuse[WINED3D_FFP_EMIT_FLOAT2] = invalid_func;
4862 ops->diffuse[WINED3D_FFP_EMIT_FLOAT3] = (wined3d_ffp_attrib_func)gl_info->gl_ops.gl.p_glColor3fv;
4863 ops->diffuse[WINED3D_FFP_EMIT_FLOAT4] = (wined3d_ffp_attrib_func)gl_info->gl_ops.gl.p_glColor4fv;
4864 ops->diffuse[WINED3D_FFP_EMIT_D3DCOLOR] = diffuse_d3dcolor;
4865 ops->diffuse[WINED3D_FFP_EMIT_UBYTE4] = invalid_func;
4866 ops->diffuse[WINED3D_FFP_EMIT_SHORT2] = invalid_func;
4867 ops->diffuse[WINED3D_FFP_EMIT_SHORT4] = invalid_func;
4868 ops->diffuse[WINED3D_FFP_EMIT_UBYTE4N] = (wined3d_ffp_attrib_func)gl_info->gl_ops.gl.p_glColor4ubv;
4869 ops->diffuse[WINED3D_FFP_EMIT_SHORT2N] = invalid_func;
4870 ops->diffuse[WINED3D_FFP_EMIT_SHORT4N] = (wined3d_ffp_attrib_func)gl_info->gl_ops.gl.p_glColor4sv;
4871 ops->diffuse[WINED3D_FFP_EMIT_USHORT2N] = invalid_func;
4872 ops->diffuse[WINED3D_FFP_EMIT_USHORT4N] = (wined3d_ffp_attrib_func)gl_info->gl_ops.gl.p_glColor4usv;
4873 ops->diffuse[WINED3D_FFP_EMIT_UDEC3] = invalid_func;
4874 ops->diffuse[WINED3D_FFP_EMIT_DEC3N] = invalid_func;
4875 ops->diffuse[WINED3D_FFP_EMIT_FLOAT16_2] = invalid_func;
4876 ops->diffuse[WINED3D_FFP_EMIT_FLOAT16_4] = invalid_func;
4877 ops->diffuse[WINED3D_FFP_EMIT_INVALID] = invalid_func;
4878
4879 /* No 4 component entry points here. */
4880 ops->specular[WINED3D_FFP_EMIT_FLOAT1] = invalid_func;
4881 ops->specular[WINED3D_FFP_EMIT_FLOAT2] = invalid_func;
4882 if (gl_info->supported[EXT_SECONDARY_COLOR])
4883 ops->specular[WINED3D_FFP_EMIT_FLOAT3] = (wined3d_ffp_attrib_func)GL_EXTCALL(glSecondaryColor3fvEXT);
4884 else
4885 ops->specular[WINED3D_FFP_EMIT_FLOAT3] = warn_no_specular_func;
4886 ops->specular[WINED3D_FFP_EMIT_FLOAT4] = invalid_func;
4887 if (gl_info->supported[EXT_SECONDARY_COLOR])
4888 ops->specular[WINED3D_FFP_EMIT_D3DCOLOR] = specular_d3dcolor;
4889 else
4890 ops->specular[WINED3D_FFP_EMIT_D3DCOLOR] = warn_no_specular_func;
4891 ops->specular[WINED3D_FFP_EMIT_UBYTE4] = invalid_func;
4892 ops->specular[WINED3D_FFP_EMIT_SHORT2] = invalid_func;
4893 ops->specular[WINED3D_FFP_EMIT_SHORT4] = invalid_func;
4894 ops->specular[WINED3D_FFP_EMIT_UBYTE4N] = invalid_func;
4895 ops->specular[WINED3D_FFP_EMIT_SHORT2N] = invalid_func;
4896 ops->specular[WINED3D_FFP_EMIT_SHORT4N] = invalid_func;
4897 ops->specular[WINED3D_FFP_EMIT_USHORT2N] = invalid_func;
4898 ops->specular[WINED3D_FFP_EMIT_USHORT4N] = invalid_func;
4899 ops->specular[WINED3D_FFP_EMIT_UDEC3] = invalid_func;
4900 ops->specular[WINED3D_FFP_EMIT_DEC3N] = invalid_func;
4901 ops->specular[WINED3D_FFP_EMIT_FLOAT16_2] = invalid_func;
4902 ops->specular[WINED3D_FFP_EMIT_FLOAT16_4] = invalid_func;
4903 ops->specular[WINED3D_FFP_EMIT_INVALID] = invalid_func;
4904
4905 /* Only 3 component entry points here. Test how others behave. Float4
4906 * normals are used by one of our tests, trying to pass it to the pixel
4907 * shader, which fails on Windows. */
4908 ops->normal[WINED3D_FFP_EMIT_FLOAT1] = invalid_func;
4909 ops->normal[WINED3D_FFP_EMIT_FLOAT2] = invalid_func;
4910 ops->normal[WINED3D_FFP_EMIT_FLOAT3] = (wined3d_ffp_attrib_func)gl_info->gl_ops.gl.p_glNormal3fv;
4911 /* Just ignore the 4th value. */
4912 ops->normal[WINED3D_FFP_EMIT_FLOAT4] = (wined3d_ffp_attrib_func)gl_info->gl_ops.gl.p_glNormal3fv;
4913 ops->normal[WINED3D_FFP_EMIT_D3DCOLOR] = invalid_func;
4914 ops->normal[WINED3D_FFP_EMIT_UBYTE4] = invalid_func;
4915 ops->normal[WINED3D_FFP_EMIT_SHORT2] = invalid_func;
4916 ops->normal[WINED3D_FFP_EMIT_SHORT4] = invalid_func;
4917 ops->normal[WINED3D_FFP_EMIT_UBYTE4N] = invalid_func;
4918 ops->normal[WINED3D_FFP_EMIT_SHORT2N] = invalid_func;
4919 ops->normal[WINED3D_FFP_EMIT_SHORT4N] = invalid_func;
4920 ops->normal[WINED3D_FFP_EMIT_USHORT2N] = invalid_func;
4921 ops->normal[WINED3D_FFP_EMIT_USHORT4N] = invalid_func;
4922 ops->normal[WINED3D_FFP_EMIT_UDEC3] = invalid_func;
4923 ops->normal[WINED3D_FFP_EMIT_DEC3N] = invalid_func;
4924 ops->normal[WINED3D_FFP_EMIT_FLOAT16_2] = invalid_func;
4925 ops->normal[WINED3D_FFP_EMIT_FLOAT16_4] = invalid_func;
4926 ops->normal[WINED3D_FFP_EMIT_INVALID] = invalid_func;
4927
4928 ops->texcoord[WINED3D_FFP_EMIT_FLOAT1] = (wined3d_ffp_texcoord_func)gl_info->gl_ops.ext.p_glMultiTexCoord1fvARB;
4929 ops->texcoord[WINED3D_FFP_EMIT_FLOAT2] = (wined3d_ffp_texcoord_func)gl_info->gl_ops.ext.p_glMultiTexCoord2fvARB;
4930 ops->texcoord[WINED3D_FFP_EMIT_FLOAT3] = (wined3d_ffp_texcoord_func)gl_info->gl_ops.ext.p_glMultiTexCoord3fvARB;
4931 ops->texcoord[WINED3D_FFP_EMIT_FLOAT4] = (wined3d_ffp_texcoord_func)gl_info->gl_ops.ext.p_glMultiTexCoord4fvARB;
4932 ops->texcoord[WINED3D_FFP_EMIT_D3DCOLOR] = invalid_texcoord_func;
4933 ops->texcoord[WINED3D_FFP_EMIT_UBYTE4] = invalid_texcoord_func;
4934 ops->texcoord[WINED3D_FFP_EMIT_SHORT2] = (wined3d_ffp_texcoord_func)gl_info->gl_ops.ext.p_glMultiTexCoord2svARB;
4935 ops->texcoord[WINED3D_FFP_EMIT_SHORT4] = (wined3d_ffp_texcoord_func)gl_info->gl_ops.ext.p_glMultiTexCoord4svARB;
4936 ops->texcoord[WINED3D_FFP_EMIT_UBYTE4N] = invalid_texcoord_func;
4937 ops->texcoord[WINED3D_FFP_EMIT_SHORT2N] = invalid_texcoord_func;
4938 ops->texcoord[WINED3D_FFP_EMIT_SHORT4N] = invalid_texcoord_func;
4939 ops->texcoord[WINED3D_FFP_EMIT_USHORT2N] = invalid_texcoord_func;
4940 ops->texcoord[WINED3D_FFP_EMIT_USHORT4N] = invalid_texcoord_func;
4941 ops->texcoord[WINED3D_FFP_EMIT_UDEC3] = invalid_texcoord_func;
4942 ops->texcoord[WINED3D_FFP_EMIT_DEC3N] = invalid_texcoord_func;
4943 if (gl_info->supported[NV_HALF_FLOAT])
4944 {
4945 /* Not supported by ARB_HALF_FLOAT_VERTEX, so check for NV_HALF_FLOAT. */
4946 ops->texcoord[WINED3D_FFP_EMIT_FLOAT16_2] =
4947 (wined3d_ffp_texcoord_func)gl_info->gl_ops.ext.p_glMultiTexCoord2hvNV;
4948 ops->texcoord[WINED3D_FFP_EMIT_FLOAT16_4] =
4949 (wined3d_ffp_texcoord_func)gl_info->gl_ops.ext.p_glMultiTexCoord4hvNV;
4950 }
4951 else
4952 {
4953 ops->texcoord[WINED3D_FFP_EMIT_FLOAT16_2] = invalid_texcoord_func;
4954 ops->texcoord[WINED3D_FFP_EMIT_FLOAT16_4] = invalid_texcoord_func;
4955 }
4956 ops->texcoord[WINED3D_FFP_EMIT_INVALID] = invalid_texcoord_func;
4957 }
4958
4959 static void wined3d_adapter_init_fb_cfgs(struct wined3d_adapter *adapter, HDC dc)
4960 {
4961 const struct wined3d_gl_info *gl_info = &adapter->gl_info;
4962 int i;
4963
4964 if (gl_info->supported[WGL_ARB_PIXEL_FORMAT])
4965 {
4966 UINT attrib_count = 0;
4967 GLint cfg_count;
4968 int attribs[11];
4969 int values[11];
4970 int attribute;
4971
4972 attribute = WGL_NUMBER_PIXEL_FORMATS_ARB;
4973 GL_EXTCALL(wglGetPixelFormatAttribivARB(dc, 0, 0, 1, &attribute, &cfg_count));
4974
4975 adapter->cfgs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, cfg_count * sizeof(*adapter->cfgs));
4976 attribs[attrib_count++] = WGL_RED_BITS_ARB;
4977 attribs[attrib_count++] = WGL_GREEN_BITS_ARB;
4978 attribs[attrib_count++] = WGL_BLUE_BITS_ARB;
4979 attribs[attrib_count++] = WGL_ALPHA_BITS_ARB;
4980 attribs[attrib_count++] = WGL_COLOR_BITS_ARB;
4981 attribs[attrib_count++] = WGL_DEPTH_BITS_ARB;
4982 attribs[attrib_count++] = WGL_STENCIL_BITS_ARB;
4983 attribs[attrib_count++] = WGL_DRAW_TO_WINDOW_ARB;
4984 attribs[attrib_count++] = WGL_PIXEL_TYPE_ARB;
4985 attribs[attrib_count++] = WGL_DOUBLE_BUFFER_ARB;
4986 attribs[attrib_count++] = WGL_AUX_BUFFERS_ARB;
4987
4988 for (i = 0, adapter->cfg_count = 0; i < cfg_count; ++i)
4989 {
4990 struct wined3d_pixel_format *cfg = &adapter->cfgs[adapter->cfg_count];
4991 int format_id = i + 1;
4992
4993 if (!GL_EXTCALL(wglGetPixelFormatAttribivARB(dc, format_id, 0, attrib_count, attribs, values)))
4994 continue;
4995
4996 cfg->iPixelFormat = format_id;
4997 cfg->redSize = values[0];
4998 cfg->greenSize = values[1];
4999 cfg->blueSize = values[2];
5000 cfg->alphaSize = values[3];
5001 cfg->colorSize = values[4];
5002 cfg->depthSize = values[5];
5003 cfg->stencilSize = values[6];
5004 cfg->windowDrawable = values[7];
5005 cfg->iPixelType = values[8];
5006 cfg->doubleBuffer = values[9];
5007 cfg->auxBuffers = values[10];
5008
5009 cfg->numSamples = 0;
5010 /* Check multisample support. */
5011 if (gl_info->supported[ARB_MULTISAMPLE])
5012 {
5013 int attribs[2] = {WGL_SAMPLE_BUFFERS_ARB, WGL_SAMPLES_ARB};
5014 int values[2];
5015
5016 if (GL_EXTCALL(wglGetPixelFormatAttribivARB(dc, format_id, 0, 2, attribs, values)))
5017 {
5018 /* values[0] = WGL_SAMPLE_BUFFERS_ARB which tells whether
5019 * multisampling is supported. values[1] = number of
5020 * multisample buffers. */
5021 if (values[0])
5022 cfg->numSamples = values[1];
5023 }
5024 }
5025
5026 TRACE("iPixelFormat=%d, iPixelType=%#x, doubleBuffer=%d, RGBA=%d/%d/%d/%d, "
5027 "depth=%d, stencil=%d, samples=%d, windowDrawable=%d\n",
5028 cfg->iPixelFormat, cfg->iPixelType, cfg->doubleBuffer,
5029 cfg->redSize, cfg->greenSize, cfg->blueSize, cfg->alphaSize,
5030 cfg->depthSize, cfg->stencilSize, cfg->numSamples, cfg->windowDrawable);
5031
5032 ++adapter->cfg_count;
5033 }
5034 }
5035 else
5036 {
5037 int cfg_count;
5038
5039 cfg_count = DescribePixelFormat(dc, 0, 0, 0);
5040 adapter->cfgs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, cfg_count * sizeof(*adapter->cfgs));
5041
5042 for (i = 0, adapter->cfg_count = 0; i < cfg_count; ++i)
5043 {
5044 struct wined3d_pixel_format *cfg = &adapter->cfgs[adapter->cfg_count];
5045 PIXELFORMATDESCRIPTOR pfd;
5046 int format_id = i + 1;
5047
5048 if (!DescribePixelFormat(dc, format_id, sizeof(pfd), &pfd))
5049 continue;
5050
5051 /* We only want HW acceleration using an OpenGL ICD driver.
5052 * PFD_GENERIC_FORMAT = slow opengl 1.1 gdi software rendering.
5053 * PFD_GENERIC_ACCELERATED = partial hw acceleration using a MCD
5054 * driver (e.g. 3dfx minigl). */
5055 if (pfd.dwFlags & (PFD_GENERIC_FORMAT | PFD_GENERIC_ACCELERATED))
5056 {
5057 TRACE("Skipping format %d because it isn't ICD accelerated.\n", format_id);
5058 continue;
5059 }
5060
5061 cfg->iPixelFormat = format_id;
5062 cfg->redSize = pfd.cRedBits;
5063 cfg->greenSize = pfd.cGreenBits;
5064 cfg->blueSize = pfd.cBlueBits;
5065 cfg->alphaSize = pfd.cAlphaBits;
5066 cfg->colorSize = pfd.cColorBits;
5067 cfg->depthSize = pfd.cDepthBits;
5068 cfg->stencilSize = pfd.cStencilBits;
5069 cfg->windowDrawable = (pfd.dwFlags & PFD_DRAW_TO_WINDOW) ? 1 : 0;
5070 cfg->iPixelType = (pfd.iPixelType == PFD_TYPE_RGBA) ? WGL_TYPE_RGBA_ARB : WGL_TYPE_COLORINDEX_ARB;
5071 cfg->doubleBuffer = (pfd.dwFlags & PFD_DOUBLEBUFFER) ? 1 : 0;
5072 cfg->auxBuffers = pfd.cAuxBuffers;
5073 cfg->numSamples = 0;
5074
5075 TRACE("iPixelFormat=%d, iPixelType=%#x, doubleBuffer=%d, RGBA=%d/%d/%d/%d, "
5076 "depth=%d, stencil=%d, windowDrawable=%d\n",
5077 cfg->iPixelFormat, cfg->iPixelType, cfg->doubleBuffer,
5078 cfg->redSize, cfg->greenSize, cfg->blueSize, cfg->alphaSize,
5079 cfg->depthSize, cfg->stencilSize, cfg->windowDrawable);
5080
5081 ++adapter->cfg_count;
5082 }
5083 }
5084 }
5085
5086 static BOOL wined3d_adapter_init(struct wined3d_adapter *adapter, UINT ordinal)
5087 {
5088 struct wined3d_gl_info *gl_info = &adapter->gl_info;
5089 struct wined3d_caps_gl_ctx caps_gl_ctx = {0};
5090 unsigned int ctx_attrib_idx = 0;
5091 DISPLAY_DEVICEW display_device;
5092 GLint ctx_attribs[3];
5093
5094 TRACE("adapter %p, ordinal %u.\n", adapter, ordinal);
5095
5096 adapter->ordinal = ordinal;
5097 adapter->monitorPoint.x = -1;
5098 adapter->monitorPoint.y = -1;
5099
5100 /* Dynamically load all GL core functions */
5101 #ifdef USE_WIN32_OPENGL
5102 {
5103 HMODULE mod_gl = GetModuleHandleA("opengl32.dll");
5104 #define USE_GL_FUNC(f) gl_info->gl_ops.gl.p_##f = (void *)GetProcAddress(mod_gl, #f);
5105 ALL_WGL_FUNCS
5106 #undef USE_GL_FUNC
5107 gl_info->gl_ops.wgl.p_wglSwapBuffers = (void *)GetProcAddress(mod_gl, "wglSwapBuffers");
5108 }
5109 #else
5110 /* To bypass the opengl32 thunks retrieve functions from the WGL driver instead of opengl32 */
5111 {
5112 HDC hdc = GetDC( 0 );
5113 const struct opengl_funcs *wgl_driver = __wine_get_wgl_driver( hdc, WINE_WGL_DRIVER_VERSION );
5114 ReleaseDC( 0, hdc );
5115 if (!wgl_driver || wgl_driver == (void *)-1) return FALSE;
5116 gl_info->gl_ops.wgl = wgl_driver->wgl;
5117 gl_info->gl_ops.gl = wgl_driver->gl;
5118 }
5119 #endif
5120
5121 glEnableWINE = gl_info->gl_ops.gl.p_glEnable;
5122 glDisableWINE = gl_info->gl_ops.gl.p_glDisable;
5123
5124 if (!AllocateLocallyUniqueId(&adapter->luid))
5125 {
5126 ERR("Failed to set adapter LUID (%#x).\n", GetLastError());
5127 return FALSE;
5128 }
5129 TRACE("Allocated LUID %08x:%08x for adapter %p.\n",
5130 adapter->luid.HighPart, adapter->luid.LowPart, adapter);
5131
5132 if (!wined3d_caps_gl_ctx_create(&caps_gl_ctx))
5133 {
5134 ERR("Failed to get a GL context for adapter %p.\n", adapter);
5135 return FALSE;
5136 }
5137
5138 if (context_debug_output_enabled(gl_info))
5139 {
5140 ctx_attribs[ctx_attrib_idx++] = WGL_CONTEXT_FLAGS_ARB;
5141 ctx_attribs[ctx_attrib_idx++] = WGL_CONTEXT_DEBUG_BIT_ARB;
5142 }
5143 ctx_attribs[ctx_attrib_idx] = 0;
5144 wined3d_caps_gl_ctx_create_attribs(&caps_gl_ctx, gl_info, ctx_attribs);
5145
5146 if (!wined3d_adapter_init_gl_caps(adapter))
5147 {
5148 ERR("Failed to initialize GL caps for adapter %p.\n", adapter);
5149 wined3d_caps_gl_ctx_destroy(&caps_gl_ctx);
5150 return FALSE;
5151 }
5152
5153 wined3d_adapter_init_fb_cfgs(adapter, caps_gl_ctx.dc);
5154 /* We haven't found any suitable formats. This should only happen in
5155 * case of GDI software rendering, which is pretty useless anyway. */
5156 if (!adapter->cfg_count)
5157 {
5158 WARN("No suitable pixel formats found.\n");
5159 wined3d_caps_gl_ctx_destroy(&caps_gl_ctx);
5160 HeapFree(GetProcessHeap(), 0, adapter->cfgs);
5161 return FALSE;
5162 }
5163
5164 if (!wined3d_adapter_init_format_info(adapter))
5165 {
5166 ERR("Failed to initialize GL format info.\n");
5167 wined3d_caps_gl_ctx_destroy(&caps_gl_ctx);
5168 HeapFree(GetProcessHeap(), 0, adapter->cfgs);
5169 return FALSE;
5170 }
5171
5172 adapter->TextureRam = adapter->driver_info.vidmem;
5173 adapter->UsedTextureRam = 0;
5174 TRACE("Emulating %u MB of texture ram.\n", adapter->TextureRam / (1024 * 1024));
5175
5176 display_device.cb = sizeof(display_device);
5177 EnumDisplayDevicesW(NULL, ordinal, &display_device, 0);
5178 TRACE("DeviceName: %s\n", debugstr_w(display_device.DeviceName));
5179 strcpyW(adapter->DeviceName, display_device.DeviceName);
5180
5181 wined3d_caps_gl_ctx_destroy(&caps_gl_ctx);
5182
5183 wined3d_adapter_init_ffp_attrib_ops(adapter);
5184
5185 return TRUE;
5186 }
5187
5188 static void wined3d_adapter_init_nogl(struct wined3d_adapter *adapter, UINT ordinal)
5189 {
5190 DISPLAY_DEVICEW display_device;
5191
5192 memset(adapter, 0, sizeof(*adapter));
5193 adapter->ordinal = ordinal;
5194 adapter->monitorPoint.x = -1;
5195 adapter->monitorPoint.y = -1;
5196
5197 adapter->driver_info.name = "Display";
5198 adapter->driver_info.description = "WineD3D DirectDraw Emulation";
5199 if (wined3d_settings.emulated_textureram)
5200 adapter->TextureRam = wined3d_settings.emulated_textureram;
5201 else
5202 adapter->TextureRam = 128 * 1024 * 1024;
5203
5204 initPixelFormatsNoGL(&adapter->gl_info);
5205
5206 adapter->vertex_pipe = &none_vertex_pipe;
5207 adapter->fragment_pipe = &none_fragment_pipe;
5208 adapter->shader_backend = &none_shader_backend;
5209 adapter->blitter = &cpu_blit;
5210
5211 display_device.cb = sizeof(display_device);
5212 EnumDisplayDevicesW(NULL, ordinal, &display_device, 0);
5213 TRACE("DeviceName: %s\n", debugstr_w(display_device.DeviceName));
5214 strcpyW(adapter->DeviceName, display_device.DeviceName);
5215 }
5216
5217 static void STDMETHODCALLTYPE wined3d_null_wined3d_object_destroyed(void *parent) {}
5218
5219 const struct wined3d_parent_ops wined3d_null_parent_ops =
5220 {
5221 wined3d_null_wined3d_object_destroyed,
5222 };
5223
5224 HRESULT wined3d_init(struct wined3d *wined3d, DWORD flags)
5225 {
5226 wined3d->ref = 1;
5227 wined3d->flags = flags;
5228
5229 TRACE("Initializing adapters.\n");
5230
5231 if (flags & WINED3D_NO3D)
5232 {
5233 wined3d_adapter_init_nogl(&wined3d->adapters[0], 0);
5234 wined3d->adapter_count = 1;
5235 return WINED3D_OK;
5236 }
5237
5238 if (!wined3d_adapter_init(&wined3d->adapters[0], 0))
5239 {
5240 WARN("Failed to initialize adapter.\n");
5241 return E_FAIL;
5242 }
5243 wined3d->adapter_count = 1;
5244
5245 return WINED3D_OK;
5246 }
A free Windows-compatible Operating System