2 * IWineD3D implementation
4 * Copyright 2002-2004 Jason Edmeades
5 * Copyright 2003-2004 Raphael Junqueira
6 * Copyright 2004 Christian Costa
7 * Copyright 2005 Oliver Stieber
8 * Copyright 2007-2008 Stefan Dösinger for CodeWeavers
9 * Copyright 2009 Henri Verbeet for CodeWeavers
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
14 * version 2.1 of the License, or (at your option) any later version.
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with this library; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
28 #include "wined3d_private.h"
30 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
31 WINE_DECLARE_DEBUG_CHANNEL(d3d_caps);
33 #define WINE_DEFAULT_VIDMEM (64 * 1024 * 1024)
35 /* The d3d device ID */
36 static const GUID IID_D3DDEVICE_D3DUID = { 0xaeb2cdd4, 0x6e41, 0x43ea, { 0x94,0x1c,0x83,0x61,0xcc,0x76,0x07,0x81 } };
38 /* Extension detection */
40 const char *extension_string;
41 GL_SupportedExt extension;
45 {"GL_APPLE_client_storage", APPLE_CLIENT_STORAGE, 0 },
46 {"GL_APPLE_fence", APPLE_FENCE, 0 },
47 {"GL_APPLE_float_pixels", APPLE_FLOAT_PIXELS, 0 },
48 {"GL_APPLE_flush_buffer_range", APPLE_FLUSH_BUFFER_RANGE, 0 },
49 {"GL_APPLE_flush_render", APPLE_FLUSH_RENDER, 0 },
50 {"GL_APPLE_ycbcr_422", APPLE_YCBCR_422, 0 },
53 {"GL_ARB_color_buffer_float", ARB_COLOR_BUFFER_FLOAT, 0 },
54 {"GL_ARB_depth_buffer_float", ARB_DEPTH_BUFFER_FLOAT, 0 },
55 {"GL_ARB_depth_clamp", ARB_DEPTH_CLAMP, 0 },
56 {"GL_ARB_depth_texture", ARB_DEPTH_TEXTURE, 0 },
57 {"GL_ARB_draw_buffers", ARB_DRAW_BUFFERS, 0 },
58 {"GL_ARB_fragment_program", ARB_FRAGMENT_PROGRAM, 0 },
59 {"GL_ARB_fragment_shader", ARB_FRAGMENT_SHADER, 0 },
60 {"GL_ARB_framebuffer_object", ARB_FRAMEBUFFER_OBJECT, 0 },
61 {"GL_ARB_geometry_shader4", ARB_GEOMETRY_SHADER4, 0 },
62 {"GL_ARB_half_float_pixel", ARB_HALF_FLOAT_PIXEL, 0 },
63 {"GL_ARB_half_float_vertex", ARB_HALF_FLOAT_VERTEX, 0 },
64 {"GL_ARB_imaging", ARB_IMAGING, 0 },
65 {"GL_ARB_map_buffer_range", ARB_MAP_BUFFER_RANGE, 0 },
66 {"GL_ARB_multisample", ARB_MULTISAMPLE, 0 }, /* needs GLX_ARB_MULTISAMPLE as well */
67 {"GL_ARB_multitexture", ARB_MULTITEXTURE, 0 },
68 {"GL_ARB_occlusion_query", ARB_OCCLUSION_QUERY, 0 },
69 {"GL_ARB_pixel_buffer_object", ARB_PIXEL_BUFFER_OBJECT, 0 },
70 {"GL_ARB_point_parameters", ARB_POINT_PARAMETERS, 0 },
71 {"GL_ARB_point_sprite", ARB_POINT_SPRITE, 0 },
72 {"GL_ARB_provoking_vertex", ARB_PROVOKING_VERTEX, 0 },
73 {"GL_ARB_shader_objects", ARB_SHADER_OBJECTS, 0 },
74 {"GL_ARB_shader_texture_lod", ARB_SHADER_TEXTURE_LOD, 0 },
75 {"GL_ARB_shading_language_100", ARB_SHADING_LANGUAGE_100, 0 },
76 {"GL_ARB_shadow", ARB_SHADOW, 0 },
77 {"GL_ARB_sync", ARB_SYNC, 0 },
78 {"GL_ARB_texture_border_clamp", ARB_TEXTURE_BORDER_CLAMP, 0 },
79 {"GL_ARB_texture_compression", ARB_TEXTURE_COMPRESSION, 0 },
80 {"GL_ARB_texture_compression_rgtc", ARB_TEXTURE_COMPRESSION_RGTC, 0 },
81 {"GL_ARB_texture_cube_map", ARB_TEXTURE_CUBE_MAP, 0 },
82 {"GL_ARB_texture_env_add", ARB_TEXTURE_ENV_ADD, 0 },
83 {"GL_ARB_texture_env_combine", ARB_TEXTURE_ENV_COMBINE, 0 },
84 {"GL_ARB_texture_env_dot3", ARB_TEXTURE_ENV_DOT3, 0 },
85 {"GL_ARB_texture_float", ARB_TEXTURE_FLOAT, 0 },
86 {"GL_ARB_texture_mirrored_repeat", ARB_TEXTURE_MIRRORED_REPEAT, 0 },
87 {"GL_ARB_texture_non_power_of_two", ARB_TEXTURE_NON_POWER_OF_TWO, MAKEDWORD_VERSION(2, 0) },
88 {"GL_ARB_texture_rectangle", ARB_TEXTURE_RECTANGLE, 0 },
89 {"GL_ARB_texture_rg", ARB_TEXTURE_RG, 0 },
90 {"GL_ARB_vertex_array_bgra", ARB_VERTEX_ARRAY_BGRA, 0 },
91 {"GL_ARB_vertex_blend", ARB_VERTEX_BLEND, 0 },
92 {"GL_ARB_vertex_buffer_object", ARB_VERTEX_BUFFER_OBJECT, 0 },
93 {"GL_ARB_vertex_program", ARB_VERTEX_PROGRAM, 0 },
94 {"GL_ARB_vertex_shader", ARB_VERTEX_SHADER, 0 },
97 {"GL_ATI_fragment_shader", ATI_FRAGMENT_SHADER, 0 },
98 {"GL_ATI_separate_stencil", ATI_SEPARATE_STENCIL, 0 },
99 {"GL_ATI_texture_compression_3dc", ATI_TEXTURE_COMPRESSION_3DC, 0 },
100 {"GL_ATI_texture_env_combine3", ATI_TEXTURE_ENV_COMBINE3, 0 },
101 {"GL_ATI_texture_mirror_once", ATI_TEXTURE_MIRROR_ONCE, 0 },
104 {"GL_EXT_blend_color", EXT_BLEND_COLOR, 0 },
105 {"GL_EXT_blend_equation_separate", EXT_BLEND_EQUATION_SEPARATE, 0 },
106 {"GL_EXT_blend_func_separate", EXT_BLEND_FUNC_SEPARATE, 0 },
107 {"GL_EXT_blend_minmax", EXT_BLEND_MINMAX, 0 },
108 {"GL_EXT_depth_bounds_test", EXT_DEPTH_BOUNDS_TEST, 0 },
109 {"GL_EXT_draw_buffers2", EXT_DRAW_BUFFERS2, 0 },
110 {"GL_EXT_fog_coord", EXT_FOG_COORD, 0 },
111 {"GL_EXT_framebuffer_blit", EXT_FRAMEBUFFER_BLIT, 0 },
112 {"GL_EXT_framebuffer_multisample", EXT_FRAMEBUFFER_MULTISAMPLE, 0 },
113 {"GL_EXT_framebuffer_object", EXT_FRAMEBUFFER_OBJECT, 0 },
114 {"GL_EXT_gpu_program_parameters", EXT_GPU_PROGRAM_PARAMETERS, 0 },
115 {"GL_EXT_gpu_shader4", EXT_GPU_SHADER4, 0 },
116 {"GL_EXT_packed_depth_stencil", EXT_PACKED_DEPTH_STENCIL, 0 },
117 {"GL_EXT_paletted_texture", EXT_PALETTED_TEXTURE, 0 },
118 {"GL_EXT_point_parameters", EXT_POINT_PARAMETERS, 0 },
119 {"GL_EXT_provoking_vertex", EXT_PROVOKING_VERTEX, 0 },
120 {"GL_EXT_secondary_color", EXT_SECONDARY_COLOR, 0 },
121 {"GL_EXT_stencil_two_side", EXT_STENCIL_TWO_SIDE, 0 },
122 {"GL_EXT_stencil_wrap", EXT_STENCIL_WRAP, 0 },
123 {"GL_EXT_texture3D", EXT_TEXTURE3D, MAKEDWORD_VERSION(1, 2) },
124 {"GL_EXT_texture_compression_rgtc", EXT_TEXTURE_COMPRESSION_RGTC, 0 },
125 {"GL_EXT_texture_compression_s3tc", EXT_TEXTURE_COMPRESSION_S3TC, 0 },
126 {"GL_EXT_texture_env_add", EXT_TEXTURE_ENV_ADD, 0 },
127 {"GL_EXT_texture_env_combine", EXT_TEXTURE_ENV_COMBINE, 0 },
128 {"GL_EXT_texture_env_dot3", EXT_TEXTURE_ENV_DOT3, 0 },
129 {"GL_EXT_texture_filter_anisotropic", EXT_TEXTURE_FILTER_ANISOTROPIC, 0 },
130 {"GL_EXT_texture_lod_bias", EXT_TEXTURE_LOD_BIAS, 0 },
131 {"GL_EXT_texture_sRGB", EXT_TEXTURE_SRGB, 0 },
132 {"GL_EXT_vertex_array_bgra", EXT_VERTEX_ARRAY_BGRA, 0 },
135 {"GL_NV_depth_clamp", NV_DEPTH_CLAMP, 0 },
136 {"GL_NV_fence", NV_FENCE, 0 },
137 {"GL_NV_fog_distance", NV_FOG_DISTANCE, 0 },
138 {"GL_NV_fragment_program", NV_FRAGMENT_PROGRAM, 0 },
139 {"GL_NV_fragment_program2", NV_FRAGMENT_PROGRAM2, 0 },
140 {"GL_NV_fragment_program_option", NV_FRAGMENT_PROGRAM_OPTION, 0 },
141 {"GL_NV_half_float", NV_HALF_FLOAT, 0 },
142 {"GL_NV_light_max_exponent", NV_LIGHT_MAX_EXPONENT, 0 },
143 {"GL_NV_point_sprite", NV_POINT_SPRITE, 0 },
144 {"GL_NV_register_combiners", NV_REGISTER_COMBINERS, 0 },
145 {"GL_NV_register_combiners2", NV_REGISTER_COMBINERS2, 0 },
146 {"GL_NV_texgen_reflection", NV_TEXGEN_REFLECTION, 0 },
147 {"GL_NV_texture_env_combine4", NV_TEXTURE_ENV_COMBINE4, 0 },
148 {"GL_NV_texture_shader", NV_TEXTURE_SHADER, 0 },
149 {"GL_NV_texture_shader2", NV_TEXTURE_SHADER2, 0 },
150 {"GL_NV_vertex_program", NV_VERTEX_PROGRAM, 0 },
151 {"GL_NV_vertex_program1_1", NV_VERTEX_PROGRAM1_1, 0 },
152 {"GL_NV_vertex_program2", NV_VERTEX_PROGRAM2, 0 },
153 {"GL_NV_vertex_program2_option", NV_VERTEX_PROGRAM2_OPTION, 0 },
154 {"GL_NV_vertex_program3", NV_VERTEX_PROGRAM3, 0 },
157 {"GL_SGIS_generate_mipmap", SGIS_GENERATE_MIPMAP, 0 },
160 /**********************************************************
161 * Utility functions follow
162 **********************************************************/
164 const struct min_lookup minMipLookup[] =
166 /* NONE POINT LINEAR */
167 {{GL_NEAREST, GL_NEAREST, GL_NEAREST}}, /* NONE */
168 {{GL_NEAREST, GL_NEAREST_MIPMAP_NEAREST, GL_NEAREST_MIPMAP_LINEAR}}, /* POINT*/
169 {{GL_LINEAR, GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR_MIPMAP_LINEAR}}, /* LINEAR */
172 const struct min_lookup minMipLookup_noFilter[] =
174 /* NONE POINT LINEAR */
175 {{GL_NEAREST, GL_NEAREST, GL_NEAREST}}, /* NONE */
176 {{GL_NEAREST, GL_NEAREST, GL_NEAREST}}, /* POINT */
177 {{GL_NEAREST, GL_NEAREST, GL_NEAREST}}, /* LINEAR */
180 const struct min_lookup minMipLookup_noMip[] =
182 /* NONE POINT LINEAR */
183 {{GL_NEAREST, GL_NEAREST, GL_NEAREST}}, /* NONE */
184 {{GL_NEAREST, GL_NEAREST, GL_NEAREST}}, /* POINT */
185 {{GL_LINEAR, GL_LINEAR, GL_LINEAR }}, /* LINEAR */
188 const GLenum magLookup[] =
190 /* NONE POINT LINEAR */
191 GL_NEAREST, GL_NEAREST, GL_LINEAR,
194 const GLenum magLookup_noFilter[] =
196 /* NONE POINT LINEAR */
197 GL_NEAREST, GL_NEAREST, GL_NEAREST,
200 /* drawStridedSlow attributes */
201 glAttribFunc position_funcs[WINED3D_FFP_EMIT_COUNT];
202 glAttribFunc diffuse_funcs[WINED3D_FFP_EMIT_COUNT];
203 glAttribFunc specular_func_3ubv;
204 glAttribFunc specular_funcs[WINED3D_FFP_EMIT_COUNT];
205 glAttribFunc normal_funcs[WINED3D_FFP_EMIT_COUNT];
206 glMultiTexCoordFunc multi_texcoord_funcs[WINED3D_FFP_EMIT_COUNT];
209 * Note: GL seems to trap if GetDeviceCaps is called before any HWND's created,
210 * i.e., there is no GL Context - Get a default rendering context to enable the
211 * function query some info from GL.
214 struct wined3d_fake_gl_ctx
220 HGLRC restore_gl_ctx;
223 static void WineD3D_ReleaseFakeGLContext(struct wined3d_fake_gl_ctx *ctx)
225 TRACE_(d3d_caps)("Destroying fake GL context.\n");
227 if (!pwglMakeCurrent(NULL, NULL))
229 ERR_(d3d_caps)("Failed to disable fake GL context.\n");
232 if (!pwglDeleteContext(ctx->gl_ctx))
234 DWORD err = GetLastError();
235 ERR("wglDeleteContext(%p) failed, last error %#x.\n", ctx->gl_ctx, err);
238 ReleaseDC(ctx->wnd, ctx->dc);
239 DestroyWindow(ctx->wnd);
241 if (ctx->restore_gl_ctx && !pwglMakeCurrent(ctx->restore_dc, ctx->restore_gl_ctx))
243 ERR_(d3d_caps)("Failed to restore previous GL context.\n");
247 /* Do not call while under the GL lock. */
248 static BOOL WineD3D_CreateFakeGLContext(struct wined3d_fake_gl_ctx *ctx)
250 PIXELFORMATDESCRIPTOR pfd;
253 TRACE("getting context...\n");
255 ctx->restore_dc = pwglGetCurrentDC();
256 ctx->restore_gl_ctx = pwglGetCurrentContext();
258 /* We need a fake window as a hdc retrieved using GetDC(0) can't be used for much GL purposes. */
259 ctx->wnd = CreateWindowA(WINED3D_OPENGL_WINDOW_CLASS_NAME, "WineD3D fake window",
260 WS_OVERLAPPEDWINDOW, 10, 10, 10, 10, NULL, NULL, NULL, NULL);
263 ERR_(d3d_caps)("Failed to create a window.\n");
267 ctx->dc = GetDC(ctx->wnd);
270 ERR_(d3d_caps)("Failed to get a DC.\n");
274 /* PixelFormat selection */
275 ZeroMemory(&pfd, sizeof(pfd));
276 pfd.nSize = sizeof(pfd);
278 pfd.dwFlags = PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER | PFD_DRAW_TO_WINDOW; /* PFD_GENERIC_ACCELERATED */
279 pfd.iPixelType = PFD_TYPE_RGBA;
281 pfd.iLayerType = PFD_MAIN_PLANE;
283 iPixelFormat = ChoosePixelFormat(ctx->dc, &pfd);
286 /* If this happens something is very wrong as ChoosePixelFormat barely fails. */
287 ERR_(d3d_caps)("Can't find a suitable iPixelFormat.\n");
290 DescribePixelFormat(ctx->dc, iPixelFormat, sizeof(pfd), &pfd);
291 SetPixelFormat(ctx->dc, iPixelFormat, &pfd);
293 /* Create a GL context. */
294 ctx->gl_ctx = pwglCreateContext(ctx->dc);
297 WARN_(d3d_caps)("Error creating default context for capabilities initialization.\n");
301 /* Make it the current GL context. */
302 if (!context_set_current(NULL))
304 ERR_(d3d_caps)("Failed to clear current D3D context.\n");
307 if (!pwglMakeCurrent(ctx->dc, ctx->gl_ctx))
309 ERR_(d3d_caps)("Failed to make fake GL context current.\n");
316 if (ctx->gl_ctx) pwglDeleteContext(ctx->gl_ctx);
318 if (ctx->dc) ReleaseDC(ctx->wnd, ctx->dc);
320 if (ctx->wnd) DestroyWindow(ctx->wnd);
322 if (ctx->restore_gl_ctx && !pwglMakeCurrent(ctx->restore_dc, ctx->restore_gl_ctx))
324 ERR_(d3d_caps)("Failed to restore previous GL context.\n");
330 /* Adjust the amount of used texture memory */
331 unsigned int WineD3DAdapterChangeGLRam(IWineD3DDeviceImpl *device, unsigned int glram)
333 struct wined3d_adapter *adapter = device->adapter;
335 adapter->UsedTextureRam += glram;
336 TRACE("Adjusted gl ram by %d to %d\n", glram, adapter->UsedTextureRam);
337 return adapter->UsedTextureRam;
340 static void wined3d_adapter_cleanup(struct wined3d_adapter *adapter)
342 HeapFree(GetProcessHeap(), 0, adapter->gl_info.formats);
343 HeapFree(GetProcessHeap(), 0, adapter->cfgs);
346 /**********************************************************
347 * IUnknown parts follows
348 **********************************************************/
350 static HRESULT WINAPI IWineD3DImpl_QueryInterface(IWineD3D *iface,REFIID riid,LPVOID *ppobj)
352 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
354 TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppobj);
355 if (IsEqualGUID(riid, &IID_IUnknown)
356 || IsEqualGUID(riid, &IID_IWineD3DBase)
357 || IsEqualGUID(riid, &IID_IWineD3DDevice)) {
358 IUnknown_AddRef(iface);
363 return E_NOINTERFACE;
366 static ULONG WINAPI IWineD3DImpl_AddRef(IWineD3D *iface) {
367 IWineD3DImpl *This = (IWineD3DImpl *)iface;
368 ULONG refCount = InterlockedIncrement(&This->ref);
370 TRACE("(%p) : AddRef increasing from %d\n", This, refCount - 1);
374 static ULONG WINAPI IWineD3DImpl_Release(IWineD3D *iface) {
375 IWineD3DImpl *This = (IWineD3DImpl *)iface;
377 TRACE("(%p) : Releasing from %d\n", This, This->ref);
378 ref = InterlockedDecrement(&This->ref);
384 for (i = 0; i < This->adapter_count; ++i)
386 wined3d_adapter_cleanup(&This->adapters[i]);
388 HeapFree(GetProcessHeap(), 0, This);
394 /**********************************************************
395 * IWineD3D parts follows
396 **********************************************************/
398 /* GL locking is done by the caller */
399 static inline BOOL test_arb_vs_offset_limit(const struct wined3d_gl_info *gl_info)
403 const char *testcode =
405 "PARAM C[66] = { program.env[0..65] };\n"
407 "PARAM zero = {0.0, 0.0, 0.0, 0.0};\n"
408 "ARL A0.x, zero.x;\n"
409 "MOV result.position, C[A0.x + 65];\n"
413 GL_EXTCALL(glGenProgramsARB(1, &prog));
415 ERR("Failed to create an ARB offset limit test program\n");
417 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, prog));
418 GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
419 strlen(testcode), testcode));
422 TRACE("OpenGL implementation does not allow indirect addressing offsets > 63\n");
423 TRACE("error: %s\n", debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
425 } else TRACE("OpenGL implementation allows offsets > 63\n");
427 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, 0));
428 GL_EXTCALL(glDeleteProgramsARB(1, &prog));
429 checkGLcall("ARB vp offset limit test cleanup");
434 static DWORD ver_for_ext(GL_SupportedExt ext)
437 for (i = 0; i < (sizeof(EXTENSION_MAP) / sizeof(*EXTENSION_MAP)); ++i) {
438 if(EXTENSION_MAP[i].extension == ext) {
439 return EXTENSION_MAP[i].version;
445 static BOOL match_ati_r300_to_500(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
446 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
448 if (card_vendor != HW_VENDOR_ATI) return FALSE;
449 if (device == CARD_ATI_RADEON_9500) return TRUE;
450 if (device == CARD_ATI_RADEON_X700) return TRUE;
451 if (device == CARD_ATI_RADEON_X1600) return TRUE;
455 static BOOL match_geforce5(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
456 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
458 if (card_vendor == HW_VENDOR_NVIDIA)
460 if (device == CARD_NVIDIA_GEFORCEFX_5200 ||
461 device == CARD_NVIDIA_GEFORCEFX_5600 ||
462 device == CARD_NVIDIA_GEFORCEFX_5800)
470 static BOOL match_apple(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)
473 /* MacOS has various specialities in the extensions it advertises. Some have to be loaded from
474 * the opengl 1.2+ core, while other extensions are advertised, but software emulated. So try to
475 * detect the Apple OpenGL implementation to apply some extension fixups afterwards.
477 * Detecting this isn't really easy. The vendor string doesn't mention Apple. Compile-time checks
478 * aren't sufficient either because a Linux binary may display on a macos X server via remote X11.
479 * So try to detect the GL implementation by looking at certain Apple extensions. Some extensions
480 * like client storage might be supported on other implementations too, but GL_APPLE_flush_render
481 * is specific to the Mac OS X window management, and GL_APPLE_ycbcr_422 is QuickTime specific. So
482 * the chance that other implementations support them is rather small since Win32 QuickTime uses
483 * DirectDraw, not OpenGL.
485 * This test has been moved into wined3d_guess_gl_vendor()
487 if (gl_vendor == GL_VENDOR_APPLE)
494 /* Context activation is done by the caller. */
495 static void test_pbo_functionality(struct wined3d_gl_info *gl_info)
497 /* Some OpenGL implementations, namely Apple's Geforce 8 driver, advertises PBOs,
498 * but glTexSubImage from a PBO fails miserably, with the first line repeated over
499 * all the texture. This function detects this bug by its symptom and disables PBOs
502 * The test uploads a 4x4 texture via the PBO in the "native" format GL_BGRA,
503 * GL_UNSIGNED_INT_8_8_8_8_REV. This format triggers the bug, and it is what we use
504 * for D3DFMT_A8R8G8B8. Then the texture is read back without any PBO and the data
505 * read back is compared to the original. If they are equal PBOs are assumed to work,
506 * otherwise the PBO extension is disabled. */
508 static const unsigned int pattern[] =
510 0x00000000, 0x000000ff, 0x0000ff00, 0x40ff0000,
511 0x80ffffff, 0x40ffff00, 0x00ff00ff, 0x0000ffff,
512 0x00ffff00, 0x00ff00ff, 0x0000ffff, 0x000000ff,
513 0x80ff00ff, 0x0000ffff, 0x00ff00ff, 0x40ff00ff
515 unsigned int check[sizeof(pattern) / sizeof(pattern[0])];
517 /* No PBO -> No point in testing them. */
518 if (!gl_info->supported[ARB_PIXEL_BUFFER_OBJECT]) return;
522 while (glGetError());
523 glGenTextures(1, &texture);
524 glBindTexture(GL_TEXTURE_2D, texture);
526 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
527 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 4, 4, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, 0);
528 checkGLcall("Specifying the PBO test texture");
530 GL_EXTCALL(glGenBuffersARB(1, &pbo));
531 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pbo));
532 GL_EXTCALL(glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, sizeof(pattern), pattern, GL_STREAM_DRAW_ARB));
533 checkGLcall("Specifying the PBO test pbo");
535 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL);
536 checkGLcall("Loading the PBO test texture");
538 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
541 wglFinish(); /* just to be sure */
543 memset(check, 0, sizeof(check));
545 glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, check);
546 checkGLcall("Reading back the PBO test texture");
548 glDeleteTextures(1, &texture);
549 GL_EXTCALL(glDeleteBuffersARB(1, &pbo));
550 checkGLcall("PBO test cleanup");
554 if (memcmp(check, pattern, sizeof(check)))
556 WARN_(d3d_caps)("PBO test failed, read back data doesn't match original.\n");
557 WARN_(d3d_caps)("Disabling PBOs. This may result in slower performance.\n");
558 gl_info->supported[ARB_PIXEL_BUFFER_OBJECT] = FALSE;
562 TRACE_(d3d_caps)("PBO test successful.\n");
566 static BOOL match_apple_intel(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
567 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
569 return (card_vendor == HW_VENDOR_INTEL) && (gl_vendor == GL_VENDOR_APPLE);
572 static BOOL match_apple_nonr500ati(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
573 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
575 if (gl_vendor != GL_VENDOR_APPLE) return FALSE;
576 if (card_vendor != HW_VENDOR_ATI) return FALSE;
577 if (device == CARD_ATI_RADEON_X1600) return FALSE;
581 static BOOL match_fglrx(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
582 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
584 return gl_vendor == GL_VENDOR_FGLRX;
588 static BOOL match_dx10_capable(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
589 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
591 /* DX9 cards support 40 single float varyings in hardware, most drivers report 32. ATI misreports
592 * 44 varyings. So assume that if we have more than 44 varyings we have a dx10 card.
593 * This detection is for the gl_ClipPos varying quirk. If a d3d9 card really supports more than 44
594 * varyings and we subtract one in dx9 shaders its not going to hurt us because the dx9 limit is
597 * dx10 cards usually have 64 varyings */
598 return gl_info->limits.glsl_varyings > 44;
601 /* A GL context is provided by the caller */
602 static BOOL match_allows_spec_alpha(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
603 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
608 if (!gl_info->supported[EXT_SECONDARY_COLOR]) return FALSE;
612 GL_EXTCALL(glSecondaryColorPointerEXT)(4, GL_UNSIGNED_BYTE, 4, data);
613 error = glGetError();
616 if(error == GL_NO_ERROR)
618 TRACE("GL Implementation accepts 4 component specular color pointers\n");
623 TRACE("GL implementation does not accept 4 component specular colors, error %s\n",
624 debug_glerror(error));
629 static BOOL match_apple_nvts(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
630 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
632 if (!match_apple(gl_info, gl_renderer, gl_vendor, card_vendor, device)) return FALSE;
633 return gl_info->supported[NV_TEXTURE_SHADER];
636 /* A GL context is provided by the caller */
637 static BOOL match_broken_nv_clip(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
638 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
643 const char *testcode =
645 "OPTION NV_vertex_program2;\n"
646 "MOV result.clip[0], 0.0;\n"
647 "MOV result.position, 0.0;\n"
650 if (!gl_info->supported[NV_VERTEX_PROGRAM2_OPTION]) return FALSE;
655 GL_EXTCALL(glGenProgramsARB(1, &prog));
658 ERR("Failed to create the NVvp clip test program\n");
662 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, prog));
663 GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
664 strlen(testcode), testcode));
665 glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &pos);
668 WARN("GL_NV_vertex_program2_option result.clip[] test failed\n");
669 TRACE("error: %s\n", debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
673 else TRACE("GL_NV_vertex_program2_option result.clip[] test passed\n");
675 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, 0));
676 GL_EXTCALL(glDeleteProgramsARB(1, &prog));
677 checkGLcall("GL_NV_vertex_program2_option result.clip[] test cleanup");
683 /* Context activation is done by the caller. */
684 static BOOL match_fbo_tex_update(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
685 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
687 char data[4 * 4 * 4];
691 if (wined3d_settings.offscreen_rendering_mode != ORM_FBO) return FALSE;
693 memset(data, 0xcc, sizeof(data));
697 glGenTextures(1, &tex);
698 glBindTexture(GL_TEXTURE_2D, tex);
699 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
700 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
701 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 4, 4, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL);
702 checkGLcall("glTexImage2D");
704 gl_info->fbo_ops.glGenFramebuffers(1, &fbo);
705 gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
706 gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0);
707 checkGLcall("glFramebufferTexture2D");
709 status = gl_info->fbo_ops.glCheckFramebufferStatus(GL_FRAMEBUFFER);
710 if (status != GL_FRAMEBUFFER_COMPLETE) ERR("FBO status %#x\n", status);
711 checkGLcall("glCheckFramebufferStatus");
713 memset(data, 0x11, sizeof(data));
714 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, data);
715 checkGLcall("glTexSubImage2D");
717 glClearColor(0.996f, 0.729f, 0.745f, 0.792f);
718 glClear(GL_COLOR_BUFFER_BIT);
719 checkGLcall("glClear");
721 glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, data);
722 checkGLcall("glGetTexImage");
724 gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
725 gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, 0);
726 glBindTexture(GL_TEXTURE_2D, 0);
727 checkGLcall("glBindTexture");
729 gl_info->fbo_ops.glDeleteFramebuffers(1, &fbo);
730 glDeleteTextures(1, &tex);
731 checkGLcall("glDeleteTextures");
735 return *(DWORD *)data == 0x11111111;
738 static void quirk_arb_constants(struct wined3d_gl_info *gl_info)
740 TRACE_(d3d_caps)("Using ARB vs constant limit(=%u) for GLSL.\n", gl_info->limits.arb_vs_native_constants);
741 gl_info->limits.glsl_vs_float_constants = gl_info->limits.arb_vs_native_constants;
742 TRACE_(d3d_caps)("Using ARB ps constant limit(=%u) for GLSL.\n", gl_info->limits.arb_ps_native_constants);
743 gl_info->limits.glsl_ps_float_constants = gl_info->limits.arb_ps_native_constants;
746 static void quirk_apple_glsl_constants(struct wined3d_gl_info *gl_info)
748 quirk_arb_constants(gl_info);
749 /* MacOS needs uniforms for relative addressing offsets. This can accumulate to quite a few uniforms.
750 * Beyond that the general uniform isn't optimal, so reserve a number of uniforms. 12 vec4's should
751 * allow 48 different offsets or other helper immediate values. */
752 TRACE_(d3d_caps)("Reserving 12 GLSL constants for compiler private use.\n");
753 gl_info->reserved_glsl_constants = max(gl_info->reserved_glsl_constants, 12);
756 /* fglrx crashes with a very bad kernel panic if GL_POINT_SPRITE_ARB is set to GL_COORD_REPLACE_ARB
757 * on more than one texture unit. This means that the d3d9 visual point size test will cause a
758 * kernel panic on any machine running fglrx 9.3(latest that supports r300 to r500 cards). This
759 * quirk only enables point sprites on the first texture unit. This keeps point sprites working in
760 * most games, but avoids the crash
762 * A more sophisticated way would be to find all units that need texture coordinates and enable
763 * point sprites for one if only one is found, and software emulate point sprites in drawStridedSlow
764 * if more than one unit needs texture coordinates(This requires software ffp and vertex shaders though)
766 * Note that disabling the extension entirely does not gain predictability because there is no point
767 * sprite capability flag in d3d, so the potential rendering bugs are the same if we disable the extension. */
768 static void quirk_one_point_sprite(struct wined3d_gl_info *gl_info)
770 if (gl_info->supported[ARB_POINT_SPRITE])
772 TRACE("Limiting point sprites to one texture unit.\n");
773 gl_info->limits.point_sprite_units = 1;
777 static void quirk_ati_dx9(struct wined3d_gl_info *gl_info)
779 quirk_arb_constants(gl_info);
781 /* MacOS advertises GL_ARB_texture_non_power_of_two on ATI r500 and earlier cards, although
782 * these cards only support GL_ARB_texture_rectangle(D3DPTEXTURECAPS_NONPOW2CONDITIONAL).
783 * If real NP2 textures are used, the driver falls back to software. We could just remove the
784 * extension and use GL_ARB_texture_rectangle instead, but texture_rectangle is inconventient
785 * due to the non-normalized texture coordinates. Thus set an internal extension flag,
786 * GL_WINE_normalized_texrect, which signals the code that it can use non power of two textures
787 * as per GL_ARB_texture_non_power_of_two, but has to stick to the texture_rectangle limits.
789 * fglrx doesn't advertise GL_ARB_texture_non_power_of_two, but it advertises opengl 2.0 which
790 * has this extension promoted to core. The extension loading code sets this extension supported
791 * due to that, so this code works on fglrx as well. */
792 if(gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO])
794 TRACE("GL_ARB_texture_non_power_of_two advertised on R500 or earlier card, removing.\n");
795 gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] = FALSE;
796 gl_info->supported[WINED3D_GL_NORMALIZED_TEXRECT] = TRUE;
799 /* fglrx has the same structural issues as the one described in quirk_apple_glsl_constants, although
800 * it is generally more efficient. Reserve just 8 constants. */
801 TRACE_(d3d_caps)("Reserving 8 GLSL constants for compiler private use.\n");
802 gl_info->reserved_glsl_constants = max(gl_info->reserved_glsl_constants, 8);
805 static void quirk_no_np2(struct wined3d_gl_info *gl_info)
807 /* The nVidia GeForceFX series reports OpenGL 2.0 capabilities with the latest drivers versions, but
808 * doesn't explicitly advertise the ARB_tex_npot extension in the GL extension string.
809 * This usually means that ARB_tex_npot is supported in hardware as long as the application is staying
810 * within the limits enforced by the ARB_texture_rectangle extension. This however is not true for the
811 * FX series, which instantly falls back to a slower software path as soon as ARB_tex_npot is used.
812 * We therefore completely remove ARB_tex_npot from the list of supported extensions.
814 * Note that wine_normalized_texrect can't be used in this case because internally it uses ARB_tex_npot,
815 * triggering the software fallback. There is not much we can do here apart from disabling the
816 * software-emulated extension and reenable ARB_tex_rect (which was previously disabled
817 * in IWineD3DImpl_FillGLCaps).
818 * This fixup removes performance problems on both the FX 5900 and FX 5700 (e.g. for framebuffer
819 * post-processing effects in the game "Max Payne 2").
820 * The behaviour can be verified through a simple test app attached in bugreport #14724. */
821 TRACE("GL_ARB_texture_non_power_of_two advertised through OpenGL 2.0 on NV FX card, removing.\n");
822 gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] = FALSE;
823 gl_info->supported[ARB_TEXTURE_RECTANGLE] = TRUE;
826 static void quirk_texcoord_w(struct wined3d_gl_info *gl_info)
828 /* The Intel GPUs on MacOS set the .w register of texcoords to 0.0 by default, which causes problems
829 * with fixed function fragment processing. Ideally this flag should be detected with a test shader
830 * and OpenGL feedback mode, but some GL implementations (MacOS ATI at least, probably all MacOS ones)
831 * do not like vertex shaders in feedback mode and return an error, even though it should be valid
832 * according to the spec.
834 * We don't want to enable this on all cards, as it adds an extra instruction per texcoord used. This
835 * makes the shader slower and eats instruction slots which should be available to the d3d app.
837 * ATI Radeon HD 2xxx cards on MacOS have the issue. Instead of checking for the buggy cards, blacklist
838 * all radeon cards on Macs and whitelist the good ones. That way we're prepared for the future. If
839 * this workaround is activated on cards that do not need it, it won't break things, just affect
840 * performance negatively. */
841 TRACE("Enabling vertex texture coord fixes in vertex shaders.\n");
842 gl_info->quirks |= WINED3D_QUIRK_SET_TEXCOORD_W;
845 static void quirk_clip_varying(struct wined3d_gl_info *gl_info)
847 gl_info->quirks |= WINED3D_QUIRK_GLSL_CLIP_VARYING;
850 static void quirk_allows_specular_alpha(struct wined3d_gl_info *gl_info)
852 gl_info->quirks |= WINED3D_QUIRK_ALLOWS_SPECULAR_ALPHA;
855 static void quirk_apple_nvts(struct wined3d_gl_info *gl_info)
857 gl_info->supported[NV_TEXTURE_SHADER] = FALSE;
858 gl_info->supported[NV_TEXTURE_SHADER2] = FALSE;
861 static void quirk_disable_nvvp_clip(struct wined3d_gl_info *gl_info)
863 gl_info->quirks |= WINED3D_QUIRK_NV_CLIP_BROKEN;
866 static void quirk_fbo_tex_update(struct wined3d_gl_info *gl_info)
868 gl_info->quirks |= WINED3D_QUIRK_FBO_TEX_UPDATE;
873 BOOL (*match)(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
874 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device);
875 void (*apply)(struct wined3d_gl_info *gl_info);
876 const char *description;
879 static const struct driver_quirk quirk_table[] =
882 match_ati_r300_to_500,
884 "ATI GLSL constant and normalized texrect quirk"
886 /* MacOS advertises more GLSL vertex shader uniforms than supported by the hardware, and if more are
887 * used it falls back to software. While the compiler can detect if the shader uses all declared
888 * uniforms, the optimization fails if the shader uses relative addressing. So any GLSL shader
889 * using relative addressing falls back to software.
891 * ARB vp gives the correct amount of uniforms, so use it instead of GLSL. */
894 quirk_apple_glsl_constants,
895 "Apple GLSL uniform override"
900 "Geforce 5 NP2 disable"
905 "Init texcoord .w for Apple Intel GPU driver"
908 match_apple_nonr500ati,
910 "Init texcoord .w for Apple ATI >= r600 GPU driver"
914 quirk_one_point_sprite,
915 "Fglrx point sprite crash workaround"
920 "Reserved varying for gl_ClipPos"
923 /* GL_EXT_secondary_color does not allow 4 component secondary colors, but most
924 * GL implementations accept it. The Mac GL is the only implementation known to
927 * If we can pass 4 component specular colors, do it, because (a) we don't have
928 * to screw around with the data, and (b) the D3D fixed function vertex pipeline
929 * passes specular alpha to the pixel shader if any is used. Otherwise the
930 * specular alpha is used to pass the fog coordinate, which we pass to opengl
931 * via GL_EXT_fog_coord.
933 match_allows_spec_alpha,
934 quirk_allows_specular_alpha,
935 "Allow specular alpha quirk"
938 /* The pixel formats provided by GL_NV_texture_shader are broken on OSX
943 "Apple NV_texture_shader disable"
946 match_broken_nv_clip,
947 quirk_disable_nvvp_clip,
948 "Apple NV_vertex_program clip bug quirk"
951 match_fbo_tex_update,
952 quirk_fbo_tex_update,
953 "FBO rebind for attachment updates"
957 /* Certain applications (Steam) complain if we report an outdated driver version. In general,
958 * reporting a driver version is moot because we are not the Windows driver, and we have different
959 * bugs, features, etc.
961 * The driver version has the form "x.y.z.w".
963 * "x" is the Windows version the driver is meant for:
970 * "y" is the maximum Direct3D version the driver supports.
971 * y -> d3d version mapping:
980 * "z" is the subversion number.
982 * "w" is the vendor specific driver build number.
985 struct driver_version_information
987 enum wined3d_display_driver driver;
988 enum wined3d_driver_model driver_model;
989 const char *driver_name; /* name of Windows driver */
990 WORD version; /* version word ('y'), contained in low word of DriverVersion.HighPart */
991 WORD subversion; /* subversion word ('z'), contained in high word of DriverVersion.LowPart */
992 WORD build; /* build number ('w'), contained in low word of DriverVersion.LowPart */
995 /* The driver version table contains driver information for different devices on several OS versions. */
996 static const struct driver_version_information driver_version_table[] =
999 * - Radeon HD2x00 (R600) and up supported by current drivers.
1000 * - Radeon 9500 (R300) - X1*00 (R5xx) supported up to Catalyst 9.3 (Linux) and 10.2 (XP/Vista/Win7)
1001 * - Radeon 7xxx (R100) - 9250 (RV250) supported up to Catalyst 6.11 (XP)
1002 * - Rage 128 supported up to XP, latest official build 6.13.3279 dated October 2001 */
1003 {DRIVER_ATI_RAGE_128PRO, DRIVER_MODEL_NT5X, "ati2dvaa.dll", 13, 3279, 0},
1004 {DRIVER_ATI_R100, DRIVER_MODEL_NT5X, "ati2dvag.dll", 14, 10, 6614},
1005 {DRIVER_ATI_R300, DRIVER_MODEL_NT5X, "ati2dvag.dll", 14, 10, 6764},
1006 {DRIVER_ATI_R600, DRIVER_MODEL_NT5X, "ati2dvag.dll", 14, 10, 8681},
1007 {DRIVER_ATI_R300, DRIVER_MODEL_NT6X, "atiumdag.dll", 14, 10, 741 },
1008 {DRIVER_ATI_R600, DRIVER_MODEL_NT6X, "atiumdag.dll", 14, 10, 741 },
1011 * The drivers are unified but not all versions support all GPUs. At some point the 2k/xp
1012 * drivers used ialmrnt5.dll for GMA800/GMA900 but at some point the file was renamed to
1013 * igxprd32.dll but the GMA800 driver was never updated. */
1014 {DRIVER_INTEL_GMA800, DRIVER_MODEL_NT5X, "ialmrnt5.dll", 14, 10, 3889},
1015 {DRIVER_INTEL_GMA900, DRIVER_MODEL_NT5X, "igxprd32.dll", 14, 10, 4764},
1016 {DRIVER_INTEL_GMA950, DRIVER_MODEL_NT5X, "igxprd32.dll", 14, 10, 4926},
1017 {DRIVER_INTEL_GMA3000, DRIVER_MODEL_NT5X, "igxprd32.dll", 14, 10, 5218},
1018 {DRIVER_INTEL_GMA950, DRIVER_MODEL_NT6X, "igdumd32.dll", 14, 10, 1504},
1019 {DRIVER_INTEL_GMA3000, DRIVER_MODEL_NT6X, "igdumd32.dll", 15, 10, 1666},
1022 * - Geforce6 and newer cards are supported by the current driver (197.x) on XP-Win7
1023 * - GeforceFX support is up to 173.x on <= XP
1024 * - Geforce2MX/3/4 up to 96.x on <= XP
1025 * - TNT/Geforce1/2 up to 71.x on <= XP
1026 * All version numbers used below are from the Linux nvidia drivers. */
1027 {DRIVER_NVIDIA_TNT, DRIVER_MODEL_NT5X, "nv4_disp.dll", 14, 10, 7186},
1028 {DRIVER_NVIDIA_GEFORCE2MX, DRIVER_MODEL_NT5X, "nv4_disp.dll", 14, 10, 9371},
1029 {DRIVER_NVIDIA_GEFORCEFX, DRIVER_MODEL_NT5X, "nv4_disp.dll", 14, 11, 7516},
1030 {DRIVER_NVIDIA_GEFORCE6, DRIVER_MODEL_NT5X, "nv4_disp.dll", 15, 11, 9745},
1031 {DRIVER_NVIDIA_GEFORCE6, DRIVER_MODEL_NT6X, "nvd3dum.dll", 15, 11, 9745},
1034 struct gpu_description
1036 WORD vendor; /* reported PCI card vendor ID */
1037 WORD card; /* reported PCI card device ID */
1038 const char *description; /* Description of the card e.g. NVIDIA RIVA TNT */
1039 enum wined3d_display_driver driver;
1040 unsigned int vidmem;
1043 /* The amount of video memory stored in the gpu description table is the minimum amount of video memory
1044 * found on a board containing a specific GPU. */
1045 static const struct gpu_description gpu_description_table[] =
1048 {HW_VENDOR_NVIDIA, CARD_NVIDIA_RIVA_TNT, "NVIDIA RIVA TNT", DRIVER_NVIDIA_TNT, 16 },
1049 {HW_VENDOR_NVIDIA, CARD_NVIDIA_RIVA_TNT2, "NVIDIA RIVA TNT2/TNT2 Pro", DRIVER_NVIDIA_TNT, 32 },
1050 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE, "NVIDIA GeForce 256", DRIVER_NVIDIA_TNT, 32 },
1051 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE2, "NVIDIA GeForce2 GTS/GeForce2 Pro", DRIVER_NVIDIA_TNT, 32 },
1052 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE2_MX, "NVIDIA GeForce2 MX/MX 400", DRIVER_NVIDIA_GEFORCE2MX,32 },
1053 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE3, "NVIDIA GeForce3", DRIVER_NVIDIA_GEFORCE2MX,64 },
1054 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE4_MX, "NVIDIA GeForce4 MX 460", DRIVER_NVIDIA_GEFORCE2MX,64 },
1055 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE4_TI4200, "NVIDIA GeForce4 Ti 4200", DRIVER_NVIDIA_GEFORCE2MX,64, },
1056 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCEFX_5200, "NVIDIA GeForce FX 5200", DRIVER_NVIDIA_GEFORCEFX, 64 },
1057 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCEFX_5600, "NVIDIA GeForce FX 5600", DRIVER_NVIDIA_GEFORCEFX, 128 },
1058 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCEFX_5800, "NVIDIA GeForce FX 5800", DRIVER_NVIDIA_GEFORCEFX, 256 },
1059 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_6200, "NVIDIA GeForce 6200", DRIVER_NVIDIA_GEFORCE6, 64 },
1060 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_6600GT, "NVIDIA GeForce 6600 GT", DRIVER_NVIDIA_GEFORCE6, 128 },
1061 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_6800, "NVIDIA GeForce 6800", DRIVER_NVIDIA_GEFORCE6, 128 },
1062 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7300, "NVIDIA GeForce Go 7300", DRIVER_NVIDIA_GEFORCE6, 256 },
1063 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7400, "NVIDIA GeForce Go 7400", DRIVER_NVIDIA_GEFORCE6, 256 },
1064 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7600, "NVIDIA GeForce 7600 GT", DRIVER_NVIDIA_GEFORCE6, 256 },
1065 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7800GT, "NVIDIA GeForce 7800 GT", DRIVER_NVIDIA_GEFORCE6, 256 },
1066 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8300GS, "NVIDIA GeForce 8300 GS", DRIVER_NVIDIA_GEFORCE6, 128 },
1067 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8400GS, "NVIDIA GeForce 8400 GS", DRIVER_NVIDIA_GEFORCE6, 128 },
1068 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8600GT, "NVIDIA GeForce 8600 GT", DRIVER_NVIDIA_GEFORCE6, 256 },
1069 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8600MGT, "NVIDIA GeForce 8600M GT", DRIVER_NVIDIA_GEFORCE6, 512 },
1070 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8800GTS, "NVIDIA GeForce 8800 GTS", DRIVER_NVIDIA_GEFORCE6, 320 },
1071 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8800GTX, "NVIDIA GeForce 8800 GTX", DRIVER_NVIDIA_GEFORCE6, 768 },
1072 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9200, "NVIDIA GeForce 9200", DRIVER_NVIDIA_GEFORCE6, 256 },
1073 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9400GT, "NVIDIA GeForce 9400 GT", DRIVER_NVIDIA_GEFORCE6, 256 },
1074 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9500GT, "NVIDIA GeForce 9500 GT", DRIVER_NVIDIA_GEFORCE6, 256 },
1075 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9600GT, "NVIDIA GeForce 9600 GT", DRIVER_NVIDIA_GEFORCE6, 384 },
1076 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9800GT, "NVIDIA GeForce 9800 GT", DRIVER_NVIDIA_GEFORCE6, 512 },
1077 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_210, "NVIDIA GeForce 210", DRIVER_NVIDIA_GEFORCE6, 512 },
1078 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT220, "NVIDIA GeForce GT 220", DRIVER_NVIDIA_GEFORCE6, 512 },
1079 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT240, "NVIDIA GeForce GT 240", DRIVER_NVIDIA_GEFORCE6, 512 },
1080 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX260, "NVIDIA GeForce GTX 260", DRIVER_NVIDIA_GEFORCE6, 1024},
1081 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX275, "NVIDIA GeForce GTX 275", DRIVER_NVIDIA_GEFORCE6, 896 },
1082 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX280, "NVIDIA GeForce GTX 280", DRIVER_NVIDIA_GEFORCE6, 1024},
1083 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT325M, "NVIDIA GeForce GT 325M", DRIVER_NVIDIA_GEFORCE6, 1024},
1084 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTS350M, "NVIDIA GeForce GTS 350M", DRIVER_NVIDIA_GEFORCE6, 1024},
1085 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX460, "NVIDIA GeForce GTX 460", DRIVER_NVIDIA_GEFORCE6, 768 },
1086 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX465, "NVIDIA GeForce GTX 465", DRIVER_NVIDIA_GEFORCE6, 1024},
1087 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX470, "NVIDIA GeForce GTX 470", DRIVER_NVIDIA_GEFORCE6, 1280},
1088 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX480, "NVIDIA GeForce GTX 480", DRIVER_NVIDIA_GEFORCE6, 1536},
1090 {HW_VENDOR_ATI, CARD_ATI_RAGE_128PRO, "ATI Rage Fury", DRIVER_ATI_RAGE_128PRO, 16 },
1091 {HW_VENDOR_ATI, CARD_ATI_RADEON_7200, "ATI RADEON 7200 SERIES", DRIVER_ATI_R100, 32 },
1092 {HW_VENDOR_ATI, CARD_ATI_RADEON_8500, "ATI RADEON 8500 SERIES", DRIVER_ATI_R100, 64 },
1093 {HW_VENDOR_ATI, CARD_ATI_RADEON_9500, "ATI Radeon 9500", DRIVER_ATI_R300, 64 },
1094 {HW_VENDOR_ATI, CARD_ATI_RADEON_XPRESS_200M, "ATI RADEON XPRESS 200M Series", DRIVER_ATI_R300, 64 },
1095 {HW_VENDOR_ATI, CARD_ATI_RADEON_X700, "ATI Radeon X700 SE", DRIVER_ATI_R300, 128 },
1096 {HW_VENDOR_ATI, CARD_ATI_RADEON_X1600, "ATI Radeon X1600 Series", DRIVER_ATI_R300, 128 },
1097 {HW_VENDOR_ATI, CARD_ATI_RADEON_HD2350, "ATI Mobility Radeon HD 2350", DRIVER_ATI_R600, 256 },
1098 {HW_VENDOR_ATI, CARD_ATI_RADEON_HD2600, "ATI Mobility Radeon HD 2600", DRIVER_ATI_R600, 256 },
1099 {HW_VENDOR_ATI, CARD_ATI_RADEON_HD2900, "ATI Radeon HD 2900 XT", DRIVER_ATI_R600, 512 },
1100 {HW_VENDOR_ATI, CARD_ATI_RADEON_HD3200, "ATI Radeon HD 3200 Graphics", DRIVER_ATI_R600, 128 },
1101 {HW_VENDOR_ATI, CARD_ATI_RADEON_HD4350, "ATI Radeon HD 4350", DRIVER_ATI_R600, 256 },
1102 {HW_VENDOR_ATI, CARD_ATI_RADEON_HD4600, "ATI Radeon HD 4600 Series", DRIVER_ATI_R600, 512 },
1103 {HW_VENDOR_ATI, CARD_ATI_RADEON_HD4700, "ATI Radeon HD 4700 Series", DRIVER_ATI_R600, 512 },
1104 {HW_VENDOR_ATI, CARD_ATI_RADEON_HD4800, "ATI Radeon HD 4800 Series", DRIVER_ATI_R600, 512 },
1105 {HW_VENDOR_ATI, CARD_ATI_RADEON_HD5400, "ATI Radeon HD 5400 Series", DRIVER_ATI_R600, 512 },
1106 {HW_VENDOR_ATI, CARD_ATI_RADEON_HD5600, "ATI Radeon HD 5600 Series", DRIVER_ATI_R600, 512 },
1107 {HW_VENDOR_ATI, CARD_ATI_RADEON_HD5700, "ATI Radeon HD 5700 Series", DRIVER_ATI_R600, 512 },
1108 {HW_VENDOR_ATI, CARD_ATI_RADEON_HD5800, "ATI Radeon HD 5800 Series", DRIVER_ATI_R600, 1024},
1109 {HW_VENDOR_ATI, CARD_ATI_RADEON_HD5900, "ATI Radeon HD 5900 Series", DRIVER_ATI_R600, 1024},
1111 {HW_VENDOR_INTEL, CARD_INTEL_I830G, "Intel(R) 82830M Graphics Controller", DRIVER_INTEL_GMA800, 32 },
1112 {HW_VENDOR_INTEL, CARD_INTEL_I855G, "Intel(R) 82852/82855 GM/GME Graphics Controller", DRIVER_INTEL_GMA800, 32 },
1113 {HW_VENDOR_INTEL, CARD_INTEL_I865G, "Intel(R) 82865G Graphics Controller", DRIVER_INTEL_GMA800, 32 },
1114 {HW_VENDOR_INTEL, CARD_INTEL_I915G, "Intel(R) 82915G/GV/910GL Express Chipset Family", DRIVER_INTEL_GMA900, 64 },
1115 {HW_VENDOR_INTEL, CARD_INTEL_I915GM, "Mobile Intel(R) 915GM/GMS,910GML Express Chipset Family", DRIVER_INTEL_GMA900, 64 },
1116 {HW_VENDOR_INTEL, CARD_INTEL_I945GM, "Mobile Intel(R) 945GM Express Chipset Family", DRIVER_INTEL_GMA950, 64 },
1117 {HW_VENDOR_INTEL, CARD_INTEL_X3100, "Mobile Intel(R) 965 Express Chipset Family", DRIVER_INTEL_GMA3000, 128}
1120 static const struct driver_version_information *get_driver_version_info(enum wined3d_display_driver driver,
1121 enum wined3d_driver_model driver_model)
1125 TRACE("Looking up version info for driver=%d driver_model=%d\n", driver, driver_model);
1126 for (i = 0; i < (sizeof(driver_version_table) / sizeof(driver_version_table[0])); i++)
1128 const struct driver_version_information *entry = &driver_version_table[i];
1130 if (entry->driver == driver && entry->driver_model == driver_model)
1132 TRACE_(d3d_caps)("Found driver '%s' version=%d subversion=%d build=%d\n",
1133 entry->driver_name, entry->version, entry->subversion, entry->build);
1141 static void init_driver_info(struct wined3d_driver_info *driver_info,
1142 enum wined3d_pci_vendor vendor, enum wined3d_pci_device device)
1144 OSVERSIONINFOW os_version;
1145 WORD driver_os_version;
1147 enum wined3d_display_driver driver = DRIVER_UNKNOWN;
1148 enum wined3d_driver_model driver_model;
1149 const struct driver_version_information *version_info;
1151 if (wined3d_settings.pci_vendor_id != PCI_VENDOR_NONE)
1153 TRACE_(d3d_caps)("Overriding PCI vendor ID with: %04x\n", wined3d_settings.pci_vendor_id);
1154 vendor = wined3d_settings.pci_vendor_id;
1156 driver_info->vendor = vendor;
1158 if (wined3d_settings.pci_device_id != PCI_DEVICE_NONE)
1160 TRACE_(d3d_caps)("Overriding PCI device ID with: %04x\n", wined3d_settings.pci_device_id);
1161 device = wined3d_settings.pci_device_id;
1163 driver_info->device = device;
1165 /* Set a default amount of video memory (64MB). In general this code isn't used unless the user
1166 * overrides the pci ids to a card which is not in our database. */
1167 driver_info->vidmem = WINE_DEFAULT_VIDMEM;
1169 memset(&os_version, 0, sizeof(os_version));
1170 os_version.dwOSVersionInfoSize = sizeof(os_version);
1171 if (!GetVersionExW(&os_version))
1173 ERR("Failed to get OS version, reporting 2000/XP.\n");
1174 driver_os_version = 6;
1175 driver_model = DRIVER_MODEL_NT5X;
1179 TRACE("OS version %u.%u.\n", os_version.dwMajorVersion, os_version.dwMinorVersion);
1180 switch (os_version.dwMajorVersion)
1183 /* If needed we could distinguish between 9x and NT4, but this code won't make
1184 * sense for NT4 since it had no way to obtain this info through DirectDraw 3.0.
1186 driver_os_version = 4;
1187 driver_model = DRIVER_MODEL_WIN9X;
1191 driver_os_version = 6;
1192 driver_model = DRIVER_MODEL_NT5X;
1196 if (os_version.dwMinorVersion == 0)
1198 driver_os_version = 7;
1199 driver_model = DRIVER_MODEL_NT6X;
1203 if (os_version.dwMinorVersion > 1)
1205 FIXME("Unhandled OS version %u.%u, reporting Win 7.\n",
1206 os_version.dwMajorVersion, os_version.dwMinorVersion);
1208 driver_os_version = 8;
1209 driver_model = DRIVER_MODEL_NT6X;
1214 FIXME("Unhandled OS version %u.%u, reporting 2000/XP.\n",
1215 os_version.dwMajorVersion, os_version.dwMinorVersion);
1216 driver_os_version = 6;
1217 driver_model = DRIVER_MODEL_NT5X;
1222 /* When we reach this stage we always have a vendor or device id (it can be a default one).
1223 * This means that unless the ids are overriden, we will always find a GPU description. */
1224 for (i = 0; i < (sizeof(gpu_description_table) / sizeof(gpu_description_table[0])); i++)
1226 if (vendor == gpu_description_table[i].vendor && device == gpu_description_table[i].card)
1228 TRACE_(d3d_caps)("Found card %04x:%04x in driver DB.\n", vendor, device);
1230 driver_info->description = gpu_description_table[i].description;
1231 driver_info->vidmem = gpu_description_table[i].vidmem * 1024*1024;
1232 driver = gpu_description_table[i].driver;
1237 if (wined3d_settings.emulated_textureram)
1239 TRACE_(d3d_caps)("Overriding amount of video memory with: %d byte\n", wined3d_settings.emulated_textureram);
1240 driver_info->vidmem = wined3d_settings.emulated_textureram;
1243 /* Try to obtain driver version information for the current Windows version. This fails in
1245 * - the gpu is not available on the currently selected OS version:
1246 * - Geforce GTX480 on Win98. When running applications in compatibility mode on Windows,
1247 * version information for the current Windows version is returned instead of faked info.
1248 * We do the same and assume the default Windows version to emulate is WinXP.
1250 * - Videocard is a Riva TNT but winver is set to win7 (there are no drivers for this beast)
1251 * For now return the XP driver info. Perhaps later on we should return VESA.
1253 * - the gpu is not in our database (can happen when the user overrides the vendor_id / device_id)
1254 * This could be an indication that our database is not up to date, so this should be fixed.
1256 version_info = get_driver_version_info(driver, driver_model);
1259 driver_info->name = version_info->driver_name;
1260 driver_info->version_high = MAKEDWORD_VERSION(driver_os_version, version_info->version);
1261 driver_info->version_low = MAKEDWORD_VERSION(version_info->subversion, version_info->build);
1265 version_info = get_driver_version_info(driver, DRIVER_MODEL_NT5X);
1268 driver_info->name = version_info->driver_name;
1269 driver_info->version_high = MAKEDWORD_VERSION(driver_os_version, version_info->version);
1270 driver_info->version_low = MAKEDWORD_VERSION(version_info->subversion, version_info->build);
1274 driver_info->description = "Direct3D HAL";
1275 driver_info->name = "Display";
1276 driver_info->version_high = MAKEDWORD_VERSION(driver_os_version, 15);
1277 driver_info->version_low = MAKEDWORD_VERSION(8, 6); /* Nvidia RIVA TNT, arbitrary */
1279 FIXME("Unable to find a driver/device info for vendor_id=%#x device_id=%#x for driver_model=%d\n",
1280 vendor, device, driver_model);
1284 TRACE_(d3d_caps)("Reporting (fake) driver version 0x%08x-0x%08x.\n",
1285 driver_info->version_high, driver_info->version_low);
1288 /* Context activation is done by the caller. */
1289 static void fixup_extensions(struct wined3d_gl_info *gl_info, const char *gl_renderer,
1290 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
1294 for (i = 0; i < (sizeof(quirk_table) / sizeof(*quirk_table)); ++i)
1296 if (!quirk_table[i].match(gl_info, gl_renderer, gl_vendor, card_vendor, device)) continue;
1297 TRACE_(d3d_caps)("Applying driver quirk \"%s\".\n", quirk_table[i].description);
1298 quirk_table[i].apply(gl_info);
1301 /* Find out if PBOs work as they are supposed to. */
1302 test_pbo_functionality(gl_info);
1305 static DWORD wined3d_parse_gl_version(const char *gl_version)
1307 const char *ptr = gl_version;
1311 if (major <= 0) ERR_(d3d_caps)("Invalid opengl major version: %d.\n", major);
1313 while (isdigit(*ptr)) ++ptr;
1314 if (*ptr++ != '.') ERR_(d3d_caps)("Invalid opengl version string: %s.\n", debugstr_a(gl_version));
1318 TRACE_(d3d_caps)("Found OpenGL version: %d.%d.\n", major, minor);
1320 return MAKEDWORD_VERSION(major, minor);
1323 static enum wined3d_gl_vendor wined3d_guess_gl_vendor(struct wined3d_gl_info *gl_info, const char *gl_vendor_string, const char *gl_renderer)
1326 /* MacOS has various specialities in the extensions it advertises. Some have to be loaded from
1327 * the opengl 1.2+ core, while other extensions are advertised, but software emulated. So try to
1328 * detect the Apple OpenGL implementation to apply some extension fixups afterwards.
1330 * Detecting this isn't really easy. The vendor string doesn't mention Apple. Compile-time checks
1331 * aren't sufficient either because a Linux binary may display on a macos X server via remote X11.
1332 * So try to detect the GL implementation by looking at certain Apple extensions. Some extensions
1333 * like client storage might be supported on other implementations too, but GL_APPLE_flush_render
1334 * is specific to the Mac OS X window management, and GL_APPLE_ycbcr_422 is QuickTime specific. So
1335 * the chance that other implementations support them is rather small since Win32 QuickTime uses
1336 * DirectDraw, not OpenGL. */
1337 if (gl_info->supported[APPLE_FENCE]
1338 && gl_info->supported[APPLE_CLIENT_STORAGE]
1339 && gl_info->supported[APPLE_FLUSH_RENDER]
1340 && gl_info->supported[APPLE_YCBCR_422])
1341 return GL_VENDOR_APPLE;
1343 if (strstr(gl_vendor_string, "NVIDIA"))
1344 return GL_VENDOR_NVIDIA;
1346 if (strstr(gl_vendor_string, "ATI"))
1347 return GL_VENDOR_FGLRX;
1349 if (strstr(gl_vendor_string, "Intel(R)")
1350 /* Intel switched from Intel(R) to Intel® recently, so just match Intel. */
1351 || strstr(gl_renderer, "Intel")
1352 || strstr(gl_vendor_string, "Intel Inc."))
1353 return GL_VENDOR_INTEL;
1355 if (strstr(gl_vendor_string, "Mesa")
1356 || strstr(gl_vendor_string, "Advanced Micro Devices, Inc.")
1357 || strstr(gl_vendor_string, "DRI R300 Project")
1358 || strstr(gl_vendor_string, "X.Org R300 Project")
1359 || strstr(gl_vendor_string, "Tungsten Graphics, Inc")
1360 || strstr(gl_vendor_string, "VMware, Inc.")
1361 || strstr(gl_renderer, "Mesa")
1362 || strstr(gl_renderer, "Gallium"))
1363 return GL_VENDOR_MESA;
1365 FIXME_(d3d_caps)("Received unrecognized GL_VENDOR %s. Returning GL_VENDOR_UNKNOWN.\n",
1366 debugstr_a(gl_vendor_string));
1368 return GL_VENDOR_UNKNOWN;
1371 static enum wined3d_pci_vendor wined3d_guess_card_vendor(const char *gl_vendor_string, const char *gl_renderer)
1373 if (strstr(gl_vendor_string, "NVIDIA"))
1374 return HW_VENDOR_NVIDIA;
1376 if (strstr(gl_vendor_string, "ATI")
1377 || strstr(gl_vendor_string, "Advanced Micro Devices, Inc.")
1378 || strstr(gl_vendor_string, "X.Org R300 Project")
1379 || strstr(gl_renderer, "AMD")
1380 || strstr(gl_renderer, "R100")
1381 || strstr(gl_renderer, "R200")
1382 || strstr(gl_renderer, "R300")
1383 || strstr(gl_renderer, "R600")
1384 || strstr(gl_renderer, "R700"))
1385 return HW_VENDOR_ATI;
1387 if (strstr(gl_vendor_string, "Intel(R)")
1388 /* Intel switched from Intel(R) to Intel® recently, so just match Intel. */
1389 || strstr(gl_renderer, "Intel")
1390 || strstr(gl_vendor_string, "Intel Inc."))
1391 return HW_VENDOR_INTEL;
1393 if (strstr(gl_vendor_string, "Mesa")
1394 || strstr(gl_vendor_string, "Tungsten Graphics, Inc")
1395 || strstr(gl_vendor_string, "VMware, Inc."))
1396 return HW_VENDOR_SOFTWARE;
1398 FIXME_(d3d_caps)("Received unrecognized GL_VENDOR %s. Returning HW_VENDOR_NVIDIA.\n", debugstr_a(gl_vendor_string));
1400 return HW_VENDOR_NVIDIA;
1405 static enum wined3d_pci_device select_card_nvidia_binary(const struct wined3d_gl_info *gl_info,
1406 const char *gl_renderer)
1410 if (WINE_D3D10_CAPABLE(gl_info))
1414 const char *renderer;
1415 enum wined3d_pci_device id;
1419 {"GTX 480", CARD_NVIDIA_GEFORCE_GTX480}, /* Geforce 400 - highend */
1420 {"GTX 470", CARD_NVIDIA_GEFORCE_GTX470}, /* Geforce 400 - midend high */
1421 {"GTX 465", CARD_NVIDIA_GEFORCE_GTX465}, /* Geforce 400 - midend */
1422 {"GTX 460", CARD_NVIDIA_GEFORCE_GTX460}, /* Geforce 400 - midend */
1423 {"GTS 360M", CARD_NVIDIA_GEFORCE_GTS350M}, /* Geforce 300 - highend mobile */
1424 {"GTS 350M", CARD_NVIDIA_GEFORCE_GTS350M}, /* Geforce 300 - highend mobile */
1425 {"GT 330M", CARD_NVIDIA_GEFORCE_GT325M}, /* Geforce 300 - midend mobile */
1426 {"GT 325M", CARD_NVIDIA_GEFORCE_GT325M}, /* Geforce 300 - midend mobile */
1427 {"GTX 295", CARD_NVIDIA_GEFORCE_GTX280}, /* Geforce 200 - highend */
1428 {"GTX 285", CARD_NVIDIA_GEFORCE_GTX280}, /* Geforce 200 - highend */
1429 {"GTX 280", CARD_NVIDIA_GEFORCE_GTX280}, /* Geforce 200 - highend */
1430 {"GTX 275", CARD_NVIDIA_GEFORCE_GTX275}, /* Geforce 200 - midend high */
1431 {"GTX 260", CARD_NVIDIA_GEFORCE_GTX260}, /* Geforce 200 - midend */
1432 {"GT 240", CARD_NVIDIA_GEFORCE_GT240}, /* Geforce 200 - midend */
1433 {"GT 220", CARD_NVIDIA_GEFORCE_GT220}, /* Geforce 200 - lowend */
1434 {"Geforce 310", CARD_NVIDIA_GEFORCE_210}, /* Geforce 200 - lowend */
1435 {"Geforce 305", CARD_NVIDIA_GEFORCE_210}, /* Geforce 200 - lowend */
1436 {"Geforce 210", CARD_NVIDIA_GEFORCE_210}, /* Geforce 200 - lowend */
1437 {"G 210", CARD_NVIDIA_GEFORCE_210}, /* Geforce 200 - lowend */
1438 {"GTS 250", CARD_NVIDIA_GEFORCE_9800GT}, /* Geforce 9 - highend / Geforce 200 - midend */
1439 {"GTS 150", CARD_NVIDIA_GEFORCE_9800GT}, /* Geforce 9 - highend / Geforce 200 - midend */
1440 {"9800", CARD_NVIDIA_GEFORCE_9800GT}, /* Geforce 9 - highend / Geforce 200 - midend */
1441 {"GT 140", CARD_NVIDIA_GEFORCE_9600GT}, /* Geforce 9 - midend */
1442 {"9600", CARD_NVIDIA_GEFORCE_9600GT}, /* Geforce 9 - midend */
1443 {"GT 130", CARD_NVIDIA_GEFORCE_9500GT}, /* Geforce 9 - midend low / Geforce 200 - low */
1444 {"GT 120", CARD_NVIDIA_GEFORCE_9500GT}, /* Geforce 9 - midend low / Geforce 200 - low */
1445 {"9500", CARD_NVIDIA_GEFORCE_9500GT}, /* Geforce 9 - midend low / Geforce 200 - low */
1446 {"9400", CARD_NVIDIA_GEFORCE_9400GT}, /* Geforce 9 - lowend */
1447 {"9300", CARD_NVIDIA_GEFORCE_9200}, /* Geforce 9 - lowend low */
1448 {"9200", CARD_NVIDIA_GEFORCE_9200}, /* Geforce 9 - lowend low */
1449 {"9100", CARD_NVIDIA_GEFORCE_9200}, /* Geforce 9 - lowend low */
1450 {"G 100", CARD_NVIDIA_GEFORCE_9200}, /* Geforce 9 - lowend low */
1451 {"8800 GTX", CARD_NVIDIA_GEFORCE_8800GTX}, /* Geforce 8 - highend high */
1452 {"8800", CARD_NVIDIA_GEFORCE_8800GTS}, /* Geforce 8 - highend */
1453 {"8600 M", CARD_NVIDIA_GEFORCE_8600MGT}, /* Geforce 8 - midend mobile */
1454 {"8700", CARD_NVIDIA_GEFORCE_8600GT}, /* Geforce 8 - midend */
1455 {"8600", CARD_NVIDIA_GEFORCE_8600GT}, /* Geforce 8 - midend */
1456 {"8500", CARD_NVIDIA_GEFORCE_8400GS}, /* Geforce 8 - mid-lowend */
1457 {"8400", CARD_NVIDIA_GEFORCE_8400GS}, /* Geforce 8 - mid-lowend */
1458 {"8300", CARD_NVIDIA_GEFORCE_8300GS}, /* Geforce 8 - lowend */
1459 {"8200", CARD_NVIDIA_GEFORCE_8300GS}, /* Geforce 8 - lowend */
1460 {"8100", CARD_NVIDIA_GEFORCE_8300GS}, /* Geforce 8 - lowend */
1463 for (i = 0; i < sizeof(cards) / sizeof(*cards); ++i)
1465 if (strstr(gl_renderer, cards[i].renderer))
1469 /* Geforce8-compatible fall back if the GPU is not in the list yet */
1470 return CARD_NVIDIA_GEFORCE_8300GS;
1473 /* Both the GeforceFX, 6xxx and 7xxx series support D3D9. The last two types have more
1474 * shader capabilities, so we use the shader capabilities to distinguish between FX and 6xxx/7xxx.
1476 if (WINE_D3D9_CAPABLE(gl_info) && gl_info->supported[NV_VERTEX_PROGRAM3])
1480 const char *renderer;
1481 enum wined3d_pci_device id;
1485 {"Quadro FX 5", CARD_NVIDIA_GEFORCE_7800GT}, /* Geforce 7 - highend */
1486 {"Quadro FX 4", CARD_NVIDIA_GEFORCE_7800GT}, /* Geforce 7 - highend */
1487 {"7950", CARD_NVIDIA_GEFORCE_7800GT}, /* Geforce 7 - highend */
1488 {"7900", CARD_NVIDIA_GEFORCE_7800GT}, /* Geforce 7 - highend */
1489 {"7800", CARD_NVIDIA_GEFORCE_7800GT}, /* Geforce 7 - highend */
1490 {"7700", CARD_NVIDIA_GEFORCE_7600}, /* Geforce 7 - midend */
1491 {"7600", CARD_NVIDIA_GEFORCE_7600}, /* Geforce 7 - midend */
1492 {"7400", CARD_NVIDIA_GEFORCE_7400}, /* Geforce 7 - lower medium */
1493 {"7300", CARD_NVIDIA_GEFORCE_7300}, /* Geforce 7 - lowend */
1494 {"6800", CARD_NVIDIA_GEFORCE_6800}, /* Geforce 6 - highend */
1495 {"6700", CARD_NVIDIA_GEFORCE_6600GT}, /* Geforce 6 - midend */
1496 {"6610", CARD_NVIDIA_GEFORCE_6600GT}, /* Geforce 6 - midend */
1497 {"6600", CARD_NVIDIA_GEFORCE_6600GT}, /* Geforce 6 - midend */
1500 for (i = 0; i < sizeof(cards) / sizeof(*cards); ++i)
1502 if (strstr(gl_renderer, cards[i].renderer))
1506 /* Geforce 6/7 - lowend */
1507 return CARD_NVIDIA_GEFORCE_6200; /* Geforce 6100/6150/6200/7300/7400/7500 */
1510 if (WINE_D3D9_CAPABLE(gl_info))
1512 /* GeforceFX - highend */
1513 if (strstr(gl_renderer, "5800")
1514 || strstr(gl_renderer, "5900")
1515 || strstr(gl_renderer, "5950")
1516 || strstr(gl_renderer, "Quadro FX"))
1518 return CARD_NVIDIA_GEFORCEFX_5800;
1521 /* GeforceFX - midend */
1522 if (strstr(gl_renderer, "5600")
1523 || strstr(gl_renderer, "5650")
1524 || strstr(gl_renderer, "5700")
1525 || strstr(gl_renderer, "5750"))
1527 return CARD_NVIDIA_GEFORCEFX_5600;
1530 /* GeforceFX - lowend */
1531 return CARD_NVIDIA_GEFORCEFX_5200; /* GeforceFX 5100/5200/5250/5300/5500 */
1534 if (WINE_D3D8_CAPABLE(gl_info))
1536 if (strstr(gl_renderer, "GeForce4 Ti") || strstr(gl_renderer, "Quadro4"))
1538 return CARD_NVIDIA_GEFORCE4_TI4200; /* Geforce4 Ti4200/Ti4400/Ti4600/Ti4800, Quadro4 */
1541 return CARD_NVIDIA_GEFORCE3; /* Geforce3 standard/Ti200/Ti500, Quadro DCC */
1544 if (WINE_D3D7_CAPABLE(gl_info))
1546 if (strstr(gl_renderer, "GeForce4 MX"))
1548 return CARD_NVIDIA_GEFORCE4_MX; /* MX420/MX440/MX460/MX4000 */
1551 if (strstr(gl_renderer, "GeForce2 MX") || strstr(gl_renderer, "Quadro2 MXR"))
1553 return CARD_NVIDIA_GEFORCE2_MX; /* Geforce2 standard/MX100/MX200/MX400, Quadro2 MXR */
1556 if (strstr(gl_renderer, "GeForce2") || strstr(gl_renderer, "Quadro2"))
1558 return CARD_NVIDIA_GEFORCE2; /* Geforce2 GTS/Pro/Ti/Ultra, Quadro2 */
1561 return CARD_NVIDIA_GEFORCE; /* Geforce 256/DDR, Quadro */
1564 if (strstr(gl_renderer, "TNT2"))
1566 return CARD_NVIDIA_RIVA_TNT2; /* Riva TNT2 standard/M64/Pro/Ultra */
1569 return CARD_NVIDIA_RIVA_TNT; /* Riva TNT, Vanta */
1572 static enum wined3d_pci_device select_card_ati_binary(const struct wined3d_gl_info *gl_info,
1573 const char *gl_renderer)
1575 /* See http://developer.amd.com/drivers/pc_vendor_id/Pages/default.aspx
1577 * Beware: renderer string do not match exact card model,
1578 * eg HD 4800 is returned for multiple cards, even for RV790 based ones. */
1579 if (WINE_D3D10_CAPABLE(gl_info))
1581 /* Radeon EG CYPRESS XT / PRO HD5800 - highend */
1582 if (strstr(gl_renderer, "HD 5800") /* Radeon EG CYPRESS HD58xx generic renderer string */
1583 || strstr(gl_renderer, "HD 5850") /* Radeon EG CYPRESS XT */
1584 || strstr(gl_renderer, "HD 5870")) /* Radeon EG CYPRESS PRO */
1586 return CARD_ATI_RADEON_HD5800;
1589 /* Radeon EG JUNIPER XT / LE HD5700 - midend */
1590 if (strstr(gl_renderer, "HD 5700") /* Radeon EG JUNIPER HD57xx generic renderer string */
1591 || strstr(gl_renderer, "HD 5750") /* Radeon EG JUNIPER LE */
1592 || strstr(gl_renderer, "HD 5770")) /* Radeon EG JUNIPER XT */
1594 return CARD_ATI_RADEON_HD5700;
1597 /* Radeon R7xx HD4800 - highend */
1598 if (strstr(gl_renderer, "HD 4800") /* Radeon RV7xx HD48xx generic renderer string */
1599 || strstr(gl_renderer, "HD 4830") /* Radeon RV770 */
1600 || strstr(gl_renderer, "HD 4850") /* Radeon RV770 */
1601 || strstr(gl_renderer, "HD 4870") /* Radeon RV770 */
1602 || strstr(gl_renderer, "HD 4890")) /* Radeon RV790 */
1604 return CARD_ATI_RADEON_HD4800;
1607 /* Radeon R740 HD4700 - midend */
1608 if (strstr(gl_renderer, "HD 4700") /* Radeon RV770 */
1609 || strstr(gl_renderer, "HD 4770")) /* Radeon RV740 */
1611 return CARD_ATI_RADEON_HD4700;
1614 /* Radeon R730 HD4600 - midend */
1615 if (strstr(gl_renderer, "HD 4600") /* Radeon RV730 */
1616 || strstr(gl_renderer, "HD 4650") /* Radeon RV730 */
1617 || strstr(gl_renderer, "HD 4670")) /* Radeon RV730 */
1619 return CARD_ATI_RADEON_HD4600;
1622 /* Radeon R710 HD4500/HD4350 - lowend */
1623 if (strstr(gl_renderer, "HD 4350") /* Radeon RV710 */
1624 || strstr(gl_renderer, "HD 4550")) /* Radeon RV710 */
1626 return CARD_ATI_RADEON_HD4350;
1629 /* Radeon R6xx HD2900/HD3800 - highend */
1630 if (strstr(gl_renderer, "HD 2900")
1631 || strstr(gl_renderer, "HD 3870")
1632 || strstr(gl_renderer, "HD 3850"))
1634 return CARD_ATI_RADEON_HD2900;
1637 /* Radeon R6xx HD2600/HD3600 - midend; HD3830 is China-only midend */
1638 if (strstr(gl_renderer, "HD 2600")
1639 || strstr(gl_renderer, "HD 3830")
1640 || strstr(gl_renderer, "HD 3690")
1641 || strstr(gl_renderer, "HD 3650"))
1643 return CARD_ATI_RADEON_HD2600;
1646 /* Radeon R6xx HD2350/HD2400/HD3400 - lowend
1647 * Note HD2300=DX9, HD2350=DX10 */
1648 if (strstr(gl_renderer, "HD 2350")
1649 || strstr(gl_renderer, "HD 2400")
1650 || strstr(gl_renderer, "HD 3470")
1651 || strstr(gl_renderer, "HD 3450")
1652 || strstr(gl_renderer, "HD 3430")
1653 || strstr(gl_renderer, "HD 3400"))
1655 return CARD_ATI_RADEON_HD2350;
1658 /* Radeon R6xx/R7xx integrated */
1659 if (strstr(gl_renderer, "HD 3100")
1660 || strstr(gl_renderer, "HD 3200")
1661 || strstr(gl_renderer, "HD 3300"))
1663 return CARD_ATI_RADEON_HD3200;
1666 /* Default for when no GPU has been found */
1667 return CARD_ATI_RADEON_HD3200;
1670 if (WINE_D3D8_CAPABLE(gl_info))
1673 if (strstr(gl_renderer, "X1600")
1674 || strstr(gl_renderer, "X1650")
1675 || strstr(gl_renderer, "X1800")
1676 || strstr(gl_renderer, "X1900")
1677 || strstr(gl_renderer, "X1950"))
1679 return CARD_ATI_RADEON_X1600;
1682 /* Radeon R4xx + X1300/X1400/X1450/X1550/X2300/X2500/HD2300 (lowend R5xx)
1683 * Note X2300/X2500/HD2300 are R5xx GPUs with a 2xxx naming but they are still DX9-only */
1684 if (strstr(gl_renderer, "X700")
1685 || strstr(gl_renderer, "X800")
1686 || strstr(gl_renderer, "X850")
1687 || strstr(gl_renderer, "X1300")
1688 || strstr(gl_renderer, "X1400")
1689 || strstr(gl_renderer, "X1450")
1690 || strstr(gl_renderer, "X1550")
1691 || strstr(gl_renderer, "X2300")
1692 || strstr(gl_renderer, "X2500")
1693 || strstr(gl_renderer, "HD 2300")
1696 return CARD_ATI_RADEON_X700;
1699 /* Radeon Xpress Series - onboard, DX9b, Shader 2.0, 300-400MHz */
1700 if (strstr(gl_renderer, "Radeon Xpress"))
1702 return CARD_ATI_RADEON_XPRESS_200M;
1706 return CARD_ATI_RADEON_9500; /* Radeon 9500/9550/9600/9700/9800/X300/X550/X600 */
1709 if (WINE_D3D8_CAPABLE(gl_info))
1711 return CARD_ATI_RADEON_8500; /* Radeon 8500/9000/9100/9200/9300 */
1714 if (WINE_D3D7_CAPABLE(gl_info))
1716 return CARD_ATI_RADEON_7200; /* Radeon 7000/7100/7200/7500 */
1719 return CARD_ATI_RAGE_128PRO;
1722 static enum wined3d_pci_device select_card_intel(const struct wined3d_gl_info *gl_info,
1723 const char *gl_renderer)
1725 if (strstr(gl_renderer, "X3100") || strstr(gl_renderer, "965GM"))
1727 /* MacOS calls the card GMA X3100, otherwise known as GM965/GL960 */
1728 return CARD_INTEL_X3100;
1731 if (strstr(gl_renderer, "GMA 950") || strstr(gl_renderer, "945GM"))
1733 /* MacOS calls the card GMA 950, but everywhere else the PCI ID is named 945GM */
1734 return CARD_INTEL_I945GM;
1737 if (strstr(gl_renderer, "915GM")) return CARD_INTEL_I915GM;
1738 if (strstr(gl_renderer, "915G")) return CARD_INTEL_I915G;
1739 if (strstr(gl_renderer, "865G")) return CARD_INTEL_I865G;
1740 if (strstr(gl_renderer, "855G")) return CARD_INTEL_I855G;
1741 if (strstr(gl_renderer, "830G")) return CARD_INTEL_I830G;
1742 return CARD_INTEL_I915G;
1746 static enum wined3d_pci_device select_card_ati_mesa(const struct wined3d_gl_info *gl_info,
1747 const char *gl_renderer)
1751 /* See http://developer.amd.com/drivers/pc_vendor_id/Pages/default.aspx
1753 * Beware: renderer string do not match exact card model,
1754 * eg HD 4800 is returned for multiple cards, even for RV790 based ones. */
1755 if (strstr(gl_renderer, "Gallium"))
1757 /* 20101109 - These are never returned by current Gallium radeon
1758 * drivers: R700, RV790, R680, RV535, RV516, R410, RS485, RV360, RV351.
1760 * These are returned but not handled: RC410, RV380. */
1763 const char *renderer;
1764 enum wined3d_pci_device id;
1769 {"HEMLOCK", CARD_ATI_RADEON_HD5900},
1770 {"CYPRESS", CARD_ATI_RADEON_HD5800},
1771 {"JUNIPER", CARD_ATI_RADEON_HD5700},
1772 {"REDWOOD", CARD_ATI_RADEON_HD5600},
1773 {"CEDAR", CARD_ATI_RADEON_HD5400},
1775 {"R700", CARD_ATI_RADEON_HD4800}, /* HD4800 - highend */
1776 {"RV790", CARD_ATI_RADEON_HD4800},
1777 {"RV770", CARD_ATI_RADEON_HD4800},
1778 {"RV740", CARD_ATI_RADEON_HD4700}, /* HD4700 - midend */
1779 {"RV730", CARD_ATI_RADEON_HD4600}, /* HD4600 - midend */
1780 {"RV710", CARD_ATI_RADEON_HD4350}, /* HD4500/HD4350 - lowend */
1781 /* R600/R700 integrated */
1782 {"RS880", CARD_ATI_RADEON_HD3200},
1783 {"RS780", CARD_ATI_RADEON_HD3200},
1785 {"R680", CARD_ATI_RADEON_HD2900}, /* HD2900/HD3800 - highend */
1786 {"R600", CARD_ATI_RADEON_HD2900},
1787 {"RV670", CARD_ATI_RADEON_HD2900},
1788 {"RV635", CARD_ATI_RADEON_HD2600}, /* HD2600/HD3600 - midend; HD3830 is China-only midend */
1789 {"RV630", CARD_ATI_RADEON_HD2600},
1790 {"RV620", CARD_ATI_RADEON_HD2350}, /* HD2350/HD2400/HD3400 - lowend */
1791 {"RV610", CARD_ATI_RADEON_HD2350},
1793 {"R580", CARD_ATI_RADEON_X1600},
1794 {"R520", CARD_ATI_RADEON_X1600},
1795 {"RV570", CARD_ATI_RADEON_X1600},
1796 {"RV560", CARD_ATI_RADEON_X1600},
1797 {"RV535", CARD_ATI_RADEON_X1600},
1798 {"RV530", CARD_ATI_RADEON_X1600},
1799 {"RV516", CARD_ATI_RADEON_X700}, /* X700 is actually R400. */
1800 {"RV515", CARD_ATI_RADEON_X700},
1802 {"R481", CARD_ATI_RADEON_X700},
1803 {"R480", CARD_ATI_RADEON_X700},
1804 {"R430", CARD_ATI_RADEON_X700},
1805 {"R423", CARD_ATI_RADEON_X700},
1806 {"R420", CARD_ATI_RADEON_X700},
1807 {"R410", CARD_ATI_RADEON_X700},
1808 {"RV410", CARD_ATI_RADEON_X700},
1809 /* Radeon Xpress - onboard, DX9b, Shader 2.0, 300-400MHz */
1810 {"RS740", CARD_ATI_RADEON_XPRESS_200M},
1811 {"RS690", CARD_ATI_RADEON_XPRESS_200M},
1812 {"RS600", CARD_ATI_RADEON_XPRESS_200M},
1813 {"RS485", CARD_ATI_RADEON_XPRESS_200M},
1814 {"RS482", CARD_ATI_RADEON_XPRESS_200M},
1815 {"RS480", CARD_ATI_RADEON_XPRESS_200M},
1816 {"RS400", CARD_ATI_RADEON_XPRESS_200M},
1818 {"R360", CARD_ATI_RADEON_9500},
1819 {"R350", CARD_ATI_RADEON_9500},
1820 {"R300", CARD_ATI_RADEON_9500},
1821 {"RV370", CARD_ATI_RADEON_9500},
1822 {"RV360", CARD_ATI_RADEON_9500},
1823 {"RV351", CARD_ATI_RADEON_9500},
1824 {"RV350", CARD_ATI_RADEON_9500},
1827 for (i = 0; i < sizeof(cards) / sizeof(*cards); ++i)
1829 if (strstr(gl_renderer, cards[i].renderer))
1834 if (WINE_D3D9_CAPABLE(gl_info))
1838 const char *renderer;
1839 enum wined3d_pci_device id;
1844 {"(R700", CARD_ATI_RADEON_HD4800}, /* HD4800 - highend */
1845 {"(RV790", CARD_ATI_RADEON_HD4800},
1846 {"(RV770", CARD_ATI_RADEON_HD4800},
1847 {"(RV740", CARD_ATI_RADEON_HD4700}, /* HD4700 - midend */
1848 {"(RV730", CARD_ATI_RADEON_HD4600}, /* HD4600 - midend */
1849 {"(RV710", CARD_ATI_RADEON_HD4350}, /* HD4500/HD4350 - lowend */
1850 /* R600/R700 integrated */
1851 {"RS880", CARD_ATI_RADEON_HD3200},
1852 {"RS780", CARD_ATI_RADEON_HD3200},
1854 {"(R680", CARD_ATI_RADEON_HD2900}, /* HD2900/HD3800 - highend */
1855 {"(R600", CARD_ATI_RADEON_HD2900},
1856 {"(RV670", CARD_ATI_RADEON_HD2900},
1857 {"(RV635", CARD_ATI_RADEON_HD2600}, /* HD2600/HD3600 - midend; HD3830 is China-only midend */
1858 {"(RV630", CARD_ATI_RADEON_HD2600},
1859 {"(RV620", CARD_ATI_RADEON_HD2350}, /* HD2300/HD2400/HD3400 - lowend */
1860 {"(RV610", CARD_ATI_RADEON_HD2350},
1863 for (i = 0; i < sizeof(cards) / sizeof(*cards); ++i)
1865 if (strstr(gl_renderer, cards[i].renderer))
1870 if (WINE_D3D8_CAPABLE(gl_info))
1872 return CARD_ATI_RADEON_8500; /* Radeon 8500/9000/9100/9200/9300 */
1875 if (WINE_D3D7_CAPABLE(gl_info))
1877 return CARD_ATI_RADEON_7200; /* Radeon 7000/7100/7200/7500 */
1880 return CARD_ATI_RAGE_128PRO;
1883 static enum wined3d_pci_device select_card_nvidia_mesa(const struct wined3d_gl_info *gl_info,
1884 const char *gl_renderer)
1886 FIXME_(d3d_caps)("Card selection not handled for Mesa Nouveau driver\n");
1887 if (WINE_D3D9_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCEFX_5600;
1888 if (WINE_D3D8_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCE3;
1889 if (WINE_D3D7_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCE;
1890 if (WINE_D3D6_CAPABLE(gl_info)) return CARD_NVIDIA_RIVA_TNT;
1891 return CARD_NVIDIA_RIVA_128;
1895 struct vendor_card_selection
1897 enum wined3d_gl_vendor gl_vendor;
1898 enum wined3d_pci_vendor card_vendor;
1899 const char *description; /* Description of the card selector i.e. Apple OS/X Intel */
1900 enum wined3d_pci_device (*select_card)(const struct wined3d_gl_info *gl_info, const char *gl_renderer);
1903 static const struct vendor_card_selection vendor_card_select_table[] =
1905 {GL_VENDOR_NVIDIA, HW_VENDOR_NVIDIA, "Nvidia binary driver", select_card_nvidia_binary},
1906 {GL_VENDOR_APPLE, HW_VENDOR_NVIDIA, "Apple OSX NVidia binary driver", select_card_nvidia_binary},
1907 {GL_VENDOR_APPLE, HW_VENDOR_ATI, "Apple OSX AMD/ATI binary driver", select_card_ati_binary},
1908 {GL_VENDOR_APPLE, HW_VENDOR_INTEL, "Apple OSX Intel binary driver", select_card_intel},
1909 {GL_VENDOR_FGLRX, HW_VENDOR_ATI, "AMD/ATI binary driver", select_card_ati_binary},
1910 {GL_VENDOR_MESA, HW_VENDOR_ATI, "Mesa AMD/ATI driver", select_card_ati_mesa},
1911 {GL_VENDOR_MESA, HW_VENDOR_NVIDIA, "Mesa Nouveau driver", select_card_nvidia_mesa},
1912 {GL_VENDOR_MESA, HW_VENDOR_INTEL, "Mesa Intel driver", select_card_intel},
1913 {GL_VENDOR_INTEL, HW_VENDOR_INTEL, "Mesa Intel driver", select_card_intel}
1917 static enum wined3d_pci_device wined3d_guess_card(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
1918 enum wined3d_gl_vendor *gl_vendor, enum wined3d_pci_vendor *card_vendor)
1920 /* Above is a list of Nvidia and ATI GPUs. Both vendors have dozens of
1921 * different GPUs with roughly the same features. In most cases GPUs from a
1922 * certain family differ in clockspeeds, the amount of video memory and the
1923 * number of shader pipelines.
1925 * A Direct3D device object contains the PCI id (vendor + device) of the
1926 * videocard which is used for rendering. Various applications use this
1927 * information to get a rough estimation of the features of the card and
1928 * some might use it for enabling 3d effects only on certain types of
1929 * videocards. In some cases games might even use it to work around bugs
1930 * which happen on certain videocards/driver combinations. The problem is
1931 * that OpenGL only exposes a rendering string containing the name of the
1932 * videocard and not the PCI id.
1934 * Various games depend on the PCI id, so somehow we need to provide one.
1935 * A simple option is to parse the renderer string and translate this to
1936 * the right PCI id. This is a lot of work because there are more than 200
1937 * GPUs just for Nvidia. Various cards share the same renderer string, so
1938 * the amount of code might be 'small' but there are quite a number of
1939 * exceptions which would make this a pain to maintain. Another way would
1940 * be to query the PCI id from the operating system (assuming this is the
1941 * videocard which is used for rendering which is not always the case).
1942 * This would work but it is not very portable. Second it would not work
1943 * well in, let's say, a remote X situation in which the amount of 3d
1944 * features which can be used is limited.
1946 * As said most games only use the PCI id to get an indication of the
1947 * capabilities of the card. It doesn't really matter if the given id is
1948 * the correct one if we return the id of a card with similar 3d features.
1950 * The code below checks the OpenGL capabilities of a videocard and matches
1951 * that to a certain level of Direct3D functionality. Once a card passes
1952 * the Direct3D9 check, we know that the card (in case of Nvidia) is at
1953 * least a GeforceFX. To give a better estimate we do a basic check on the
1954 * renderer string but if that won't pass we return a default card. This
1955 * way is better than maintaining a full card database as even without a
1956 * full database we can return a card with similar features. Second the
1957 * size of the database can be made quite small because when you know what
1958 * type of 3d functionality a card has, you know to which GPU family the
1959 * GPU must belong. Because of this you only have to check a small part of
1960 * the renderer string to distinguishes between different models from that
1963 * The code also selects a default amount of video memory which we will
1964 * use for an estimation of the amount of free texture memory. In case of
1965 * real D3D the amount of texture memory includes video memory and system
1966 * memory (to be specific AGP memory or in case of PCIE TurboCache /
1967 * HyperMemory). We don't know how much system memory can be addressed by
1968 * the system but we can make a reasonable estimation about the amount of
1969 * video memory. If the value is slightly wrong it doesn't matter as we
1970 * didn't include AGP-like memory which makes the amount of addressable
1971 * memory higher and second OpenGL isn't that critical it moves to system
1972 * memory behind our backs if really needed. Note that the amount of video
1973 * memory can be overruled using a registry setting. */
1977 for (i = 0; i < (sizeof(vendor_card_select_table) / sizeof(*vendor_card_select_table)); ++i)
1979 if ((vendor_card_select_table[i].gl_vendor != *gl_vendor)
1980 || (vendor_card_select_table[i].card_vendor != *card_vendor))
1982 TRACE_(d3d_caps)("Applying card_selector \"%s\".\n", vendor_card_select_table[i].description);
1983 return vendor_card_select_table[i].select_card(gl_info, gl_renderer);
1986 FIXME_(d3d_caps)("No card selector available for GL vendor %d and card vendor %04x.\n",
1987 *gl_vendor, *card_vendor);
1989 /* Default to generic Nvidia hardware based on the supported OpenGL extensions. The choice
1990 * for Nvidia was because the hardware and drivers they make are of good quality. This makes
1991 * them a good generic choice. */
1992 *card_vendor = HW_VENDOR_NVIDIA;
1993 if (WINE_D3D9_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCEFX_5600;
1994 if (WINE_D3D8_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCE3;
1995 if (WINE_D3D7_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCE;
1996 if (WINE_D3D6_CAPABLE(gl_info)) return CARD_NVIDIA_RIVA_TNT;
1997 return CARD_NVIDIA_RIVA_128;
2000 static const struct fragment_pipeline *select_fragment_implementation(struct wined3d_adapter *adapter)
2002 const struct wined3d_gl_info *gl_info = &adapter->gl_info;
2003 int vs_selected_mode, ps_selected_mode;
2005 select_shader_mode(gl_info, &ps_selected_mode, &vs_selected_mode);
2006 if ((ps_selected_mode == SHADER_ARB || ps_selected_mode == SHADER_GLSL)
2007 && gl_info->supported[ARB_FRAGMENT_PROGRAM]) return &arbfp_fragment_pipeline;
2008 else if (ps_selected_mode == SHADER_ATI) return &atifs_fragment_pipeline;
2009 else if (gl_info->supported[NV_REGISTER_COMBINERS]
2010 && gl_info->supported[NV_TEXTURE_SHADER2]) return &nvts_fragment_pipeline;
2011 else if (gl_info->supported[NV_REGISTER_COMBINERS]) return &nvrc_fragment_pipeline;
2012 else return &ffp_fragment_pipeline;
2015 static const shader_backend_t *select_shader_backend(struct wined3d_adapter *adapter)
2017 int vs_selected_mode, ps_selected_mode;
2019 select_shader_mode(&adapter->gl_info, &ps_selected_mode, &vs_selected_mode);
2020 if (vs_selected_mode == SHADER_GLSL || ps_selected_mode == SHADER_GLSL) return &glsl_shader_backend;
2021 if (vs_selected_mode == SHADER_ARB || ps_selected_mode == SHADER_ARB) return &arb_program_shader_backend;
2022 return &none_shader_backend;
2025 static const struct blit_shader *select_blit_implementation(struct wined3d_adapter *adapter)
2027 const struct wined3d_gl_info *gl_info = &adapter->gl_info;
2028 int vs_selected_mode, ps_selected_mode;
2030 select_shader_mode(gl_info, &ps_selected_mode, &vs_selected_mode);
2031 if ((ps_selected_mode == SHADER_ARB || ps_selected_mode == SHADER_GLSL)
2032 && gl_info->supported[ARB_FRAGMENT_PROGRAM]) return &arbfp_blit;
2033 else return &ffp_blit;
2036 static void load_gl_funcs(struct wined3d_gl_info *gl_info, DWORD gl_version)
2040 #define USE_GL_FUNC(type, pfn, ext, replace) \
2041 if (gl_info->supported[ext]) gl_info->pfn = (type)pwglGetProcAddress(#pfn); \
2042 else if ((ver = ver_for_ext(ext)) && ver <= gl_version) gl_info->pfn = (type)pwglGetProcAddress(#replace); \
2043 else gl_info->pfn = NULL;
2048 #define USE_GL_FUNC(type, pfn, ext, replace) gl_info->pfn = (type)pwglGetProcAddress(#pfn);
2053 /* Context activation is done by the caller. */
2054 static BOOL IWineD3DImpl_FillGLCaps(struct wined3d_adapter *adapter)
2056 struct wined3d_driver_info *driver_info = &adapter->driver_info;
2057 struct wined3d_gl_info *gl_info = &adapter->gl_info;
2058 const char *GL_Extensions = NULL;
2059 const char *WGL_Extensions = NULL;
2060 const char *gl_vendor_str, *gl_renderer_str, *gl_version_str;
2061 struct fragment_caps fragment_caps;
2062 enum wined3d_gl_vendor gl_vendor;
2063 enum wined3d_pci_vendor card_vendor;
2064 enum wined3d_pci_device device;
2066 GLfloat gl_floatv[2];
2072 TRACE_(d3d_caps)("(%p)\n", gl_info);
2076 gl_renderer_str = (const char *)glGetString(GL_RENDERER);
2077 TRACE_(d3d_caps)("GL_RENDERER: %s.\n", debugstr_a(gl_renderer_str));
2078 if (!gl_renderer_str)
2081 ERR_(d3d_caps)("Received a NULL GL_RENDERER.\n");
2085 gl_vendor_str = (const char *)glGetString(GL_VENDOR);
2086 TRACE_(d3d_caps)("GL_VENDOR: %s.\n", debugstr_a(gl_vendor_str));
2090 ERR_(d3d_caps)("Received a NULL GL_VENDOR.\n");
2094 /* Parse the GL_VERSION field into major and minor information */
2095 gl_version_str = (const char *)glGetString(GL_VERSION);
2096 TRACE_(d3d_caps)("GL_VERSION: %s.\n", debugstr_a(gl_version_str));
2097 if (!gl_version_str)
2100 ERR_(d3d_caps)("Received a NULL GL_VERSION.\n");
2103 gl_version = wined3d_parse_gl_version(gl_version_str);
2106 * Initialize openGL extension related variables
2107 * with Default values
2109 memset(gl_info->supported, 0, sizeof(gl_info->supported));
2110 gl_info->limits.blends = 1;
2111 gl_info->limits.buffers = 1;
2112 gl_info->limits.textures = 1;
2113 gl_info->limits.fragment_samplers = 1;
2114 gl_info->limits.vertex_samplers = 0;
2115 gl_info->limits.combined_samplers = gl_info->limits.fragment_samplers + gl_info->limits.vertex_samplers;
2116 gl_info->limits.sampler_stages = 1;
2117 gl_info->limits.glsl_vs_float_constants = 0;
2118 gl_info->limits.glsl_ps_float_constants = 0;
2119 gl_info->limits.arb_vs_float_constants = 0;
2120 gl_info->limits.arb_vs_native_constants = 0;
2121 gl_info->limits.arb_vs_instructions = 0;
2122 gl_info->limits.arb_vs_temps = 0;
2123 gl_info->limits.arb_ps_float_constants = 0;
2124 gl_info->limits.arb_ps_local_constants = 0;
2125 gl_info->limits.arb_ps_instructions = 0;
2126 gl_info->limits.arb_ps_temps = 0;
2128 /* Retrieve opengl defaults */
2129 glGetIntegerv(GL_MAX_CLIP_PLANES, &gl_max);
2130 gl_info->limits.clipplanes = min(WINED3DMAXUSERCLIPPLANES, gl_max);
2131 TRACE_(d3d_caps)("ClipPlanes support - num Planes=%d\n", gl_max);
2133 glGetIntegerv(GL_MAX_LIGHTS, &gl_max);
2134 gl_info->limits.lights = gl_max;
2135 TRACE_(d3d_caps)("Lights support - max lights=%d\n", gl_max);
2137 glGetIntegerv(GL_MAX_TEXTURE_SIZE, &gl_max);
2138 gl_info->limits.texture_size = gl_max;
2139 TRACE_(d3d_caps)("Maximum texture size support - max texture size=%d\n", gl_max);
2141 glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, gl_floatv);
2142 gl_info->limits.pointsize_min = gl_floatv[0];
2143 gl_info->limits.pointsize_max = gl_floatv[1];
2144 TRACE_(d3d_caps)("Maximum point size support - max point size=%f\n", gl_floatv[1]);
2146 /* Parse the gl supported features, in theory enabling parts of our code appropriately. */
2147 GL_Extensions = (const char *)glGetString(GL_EXTENSIONS);
2151 ERR_(d3d_caps)("Received a NULL GL_EXTENSIONS.\n");
2157 TRACE_(d3d_caps)("GL_Extensions reported:\n");
2159 gl_info->supported[WINED3D_GL_EXT_NONE] = TRUE;
2161 while (*GL_Extensions)
2165 while (isspace(*GL_Extensions)) ++GL_Extensions;
2166 start = GL_Extensions;
2167 while (!isspace(*GL_Extensions) && *GL_Extensions) ++GL_Extensions;
2169 len = GL_Extensions - start;
2172 TRACE_(d3d_caps)("- %s\n", debugstr_an(start, len));
2174 for (i = 0; i < (sizeof(EXTENSION_MAP) / sizeof(*EXTENSION_MAP)); ++i)
2176 if (len == strlen(EXTENSION_MAP[i].extension_string)
2177 && !memcmp(start, EXTENSION_MAP[i].extension_string, len))
2179 TRACE_(d3d_caps)(" FOUND: %s support.\n", EXTENSION_MAP[i].extension_string);
2180 gl_info->supported[EXTENSION_MAP[i].extension] = TRUE;
2186 /* Now work out what GL support this card really has */
2187 load_gl_funcs( gl_info, gl_version );
2191 /* Now mark all the extensions supported which are included in the opengl core version. Do this *after*
2192 * loading the functions, otherwise the code above will load the extension entry points instead of the
2193 * core functions, which may not work. */
2194 for (i = 0; i < (sizeof(EXTENSION_MAP) / sizeof(*EXTENSION_MAP)); ++i)
2196 if (!gl_info->supported[EXTENSION_MAP[i].extension]
2197 && EXTENSION_MAP[i].version <= gl_version && EXTENSION_MAP[i].version)
2199 TRACE_(d3d_caps)(" GL CORE: %s support.\n", EXTENSION_MAP[i].extension_string);
2200 gl_info->supported[EXTENSION_MAP[i].extension] = TRUE;
2204 if (gl_version >= MAKEDWORD_VERSION(2, 0)) gl_info->supported[WINED3D_GL_VERSION_2_0] = TRUE;
2206 if (gl_info->supported[APPLE_FENCE])
2208 /* GL_NV_fence and GL_APPLE_fence provide the same functionality basically.
2209 * The apple extension interacts with some other apple exts. Disable the NV
2210 * extension if the apple one is support to prevent confusion in other parts
2212 gl_info->supported[NV_FENCE] = FALSE;
2214 if (gl_info->supported[APPLE_FLOAT_PIXELS])
2216 /* GL_APPLE_float_pixels == GL_ARB_texture_float + GL_ARB_half_float_pixel
2218 * The enums are the same:
2219 * GL_RGBA16F_ARB = GL_RGBA_FLOAT16_APPLE = 0x881A
2220 * GL_RGB16F_ARB = GL_RGB_FLOAT16_APPLE = 0x881B
2221 * GL_RGBA32F_ARB = GL_RGBA_FLOAT32_APPLE = 0x8814
2222 * GL_RGB32F_ARB = GL_RGB_FLOAT32_APPLE = 0x8815
2223 * GL_HALF_FLOAT_ARB = GL_HALF_APPLE = 0x140B
2225 if (!gl_info->supported[ARB_TEXTURE_FLOAT])
2227 TRACE_(d3d_caps)(" IMPLIED: GL_ARB_texture_float support(from GL_APPLE_float_pixels.\n");
2228 gl_info->supported[ARB_TEXTURE_FLOAT] = TRUE;
2230 if (!gl_info->supported[ARB_HALF_FLOAT_PIXEL])
2232 TRACE_(d3d_caps)(" IMPLIED: GL_ARB_half_float_pixel support(from GL_APPLE_float_pixels.\n");
2233 gl_info->supported[ARB_HALF_FLOAT_PIXEL] = TRUE;
2236 if (gl_info->supported[ARB_MAP_BUFFER_RANGE])
2238 /* GL_ARB_map_buffer_range and GL_APPLE_flush_buffer_range provide the same
2239 * functionality. Prefer the ARB extension */
2240 gl_info->supported[APPLE_FLUSH_BUFFER_RANGE] = FALSE;
2242 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
2244 TRACE_(d3d_caps)(" IMPLIED: NVIDIA (NV) Texture Gen Reflection support.\n");
2245 gl_info->supported[NV_TEXGEN_REFLECTION] = TRUE;
2247 if (!gl_info->supported[ARB_DEPTH_CLAMP] && gl_info->supported[NV_DEPTH_CLAMP])
2249 TRACE_(d3d_caps)(" IMPLIED: ARB_depth_clamp support (by NV_depth_clamp).\n");
2250 gl_info->supported[ARB_DEPTH_CLAMP] = TRUE;
2252 if (!gl_info->supported[ARB_VERTEX_ARRAY_BGRA] && gl_info->supported[EXT_VERTEX_ARRAY_BGRA])
2254 TRACE_(d3d_caps)(" IMPLIED: ARB_vertex_array_bgra support (by EXT_vertex_array_bgra).\n");
2255 gl_info->supported[ARB_VERTEX_ARRAY_BGRA] = TRUE;
2257 if (!gl_info->supported[ARB_TEXTURE_COMPRESSION_RGTC] && gl_info->supported[EXT_TEXTURE_COMPRESSION_RGTC])
2259 TRACE_(d3d_caps)(" IMPLIED: ARB_texture_compression_rgtc support (by EXT_texture_compression_rgtc).\n");
2260 gl_info->supported[ARB_TEXTURE_COMPRESSION_RGTC] = TRUE;
2262 if (gl_info->supported[NV_TEXTURE_SHADER2])
2264 if (gl_info->supported[NV_REGISTER_COMBINERS])
2266 /* Also disable ATI_FRAGMENT_SHADER if register combiners and texture_shader2
2267 * are supported. The nv extensions provide the same functionality as the
2268 * ATI one, and a bit more(signed pixelformats). */
2269 gl_info->supported[ATI_FRAGMENT_SHADER] = FALSE;
2273 if (gl_info->supported[NV_REGISTER_COMBINERS])
2275 glGetIntegerv(GL_MAX_GENERAL_COMBINERS_NV, &gl_max);
2276 gl_info->limits.general_combiners = gl_max;
2277 TRACE_(d3d_caps)("Max general combiners: %d.\n", gl_max);
2279 if (gl_info->supported[ARB_DRAW_BUFFERS])
2281 glGetIntegerv(GL_MAX_DRAW_BUFFERS_ARB, &gl_max);
2282 gl_info->limits.buffers = gl_max;
2283 TRACE_(d3d_caps)("Max draw buffers: %u.\n", gl_max);
2285 if (gl_info->supported[ARB_MULTITEXTURE])
2287 glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &gl_max);
2288 gl_info->limits.textures = min(MAX_TEXTURES, gl_max);
2289 TRACE_(d3d_caps)("Max textures: %d.\n", gl_info->limits.textures);
2291 if (gl_info->supported[ARB_FRAGMENT_PROGRAM])
2294 glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS_ARB, &tmp);
2295 gl_info->limits.fragment_samplers = min(MAX_FRAGMENT_SAMPLERS, tmp);
2299 gl_info->limits.fragment_samplers = max(gl_info->limits.fragment_samplers, gl_max);
2301 TRACE_(d3d_caps)("Max fragment samplers: %d.\n", gl_info->limits.fragment_samplers);
2303 if (gl_info->supported[ARB_VERTEX_SHADER])
2306 glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB, &tmp);
2307 gl_info->limits.vertex_samplers = tmp;
2308 glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB, &tmp);
2309 gl_info->limits.combined_samplers = tmp;
2311 /* Loading GLSL sampler uniforms is much simpler if we can assume that the sampler setup
2312 * is known at shader link time. In a vertex shader + pixel shader combination this isn't
2313 * an issue because then the sampler setup only depends on the two shaders. If a pixel
2314 * shader is used with fixed function vertex processing we're fine too because fixed function
2315 * vertex processing doesn't use any samplers. If fixed function fragment processing is
2316 * used we have to make sure that all vertex sampler setups are valid together with all
2317 * possible fixed function fragment processing setups. This is true if vsamplers + MAX_TEXTURES
2318 * <= max_samplers. This is true on all d3d9 cards that support vtf(gf 6 and gf7 cards).
2319 * dx9 radeon cards do not support vertex texture fetch. DX10 cards have 128 samplers, and
2320 * dx9 is limited to 8 fixed function texture stages and 4 vertex samplers. DX10 does not have
2321 * a fixed function pipeline anymore.
2323 * So this is just a check to check that our assumption holds true. If not, write a warning
2324 * and reduce the number of vertex samplers or probably disable vertex texture fetch. */
2325 if (gl_info->limits.vertex_samplers && gl_info->limits.combined_samplers < 12
2326 && MAX_TEXTURES + gl_info->limits.vertex_samplers > gl_info->limits.combined_samplers)
2328 FIXME("OpenGL implementation supports %u vertex samplers and %u total samplers.\n",
2329 gl_info->limits.vertex_samplers, gl_info->limits.combined_samplers);
2330 FIXME("Expected vertex samplers + MAX_TEXTURES(=8) > combined_samplers.\n");
2331 if (gl_info->limits.combined_samplers > MAX_TEXTURES)
2332 gl_info->limits.vertex_samplers = gl_info->limits.combined_samplers - MAX_TEXTURES;
2334 gl_info->limits.vertex_samplers = 0;
2339 gl_info->limits.combined_samplers = gl_info->limits.fragment_samplers;
2341 TRACE_(d3d_caps)("Max vertex samplers: %u.\n", gl_info->limits.vertex_samplers);
2342 TRACE_(d3d_caps)("Max combined samplers: %u.\n", gl_info->limits.combined_samplers);
2344 if (gl_info->supported[ARB_VERTEX_BLEND])
2346 glGetIntegerv(GL_MAX_VERTEX_UNITS_ARB, &gl_max);
2347 gl_info->limits.blends = gl_max;
2348 TRACE_(d3d_caps)("Max blends: %u.\n", gl_info->limits.blends);
2350 if (gl_info->supported[EXT_TEXTURE3D])
2352 glGetIntegerv(GL_MAX_3D_TEXTURE_SIZE_EXT, &gl_max);
2353 gl_info->limits.texture3d_size = gl_max;
2354 TRACE_(d3d_caps)("Max texture3D size: %d.\n", gl_info->limits.texture3d_size);
2356 if (gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC])
2358 glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &gl_max);
2359 gl_info->limits.anisotropy = gl_max;
2360 TRACE_(d3d_caps)("Max anisotropy: %d.\n", gl_info->limits.anisotropy);
2362 if (gl_info->supported[ARB_FRAGMENT_PROGRAM])
2364 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max));
2365 gl_info->limits.arb_ps_float_constants = gl_max;
2366 TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM float constants: %d.\n", gl_info->limits.arb_ps_float_constants);
2367 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB, &gl_max));
2368 gl_info->limits.arb_ps_native_constants = gl_max;
2369 TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM native float constants: %d.\n",
2370 gl_info->limits.arb_ps_native_constants);
2371 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, &gl_max));
2372 gl_info->limits.arb_ps_temps = gl_max;
2373 TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM native temporaries: %d.\n", gl_info->limits.arb_ps_temps);
2374 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, &gl_max));
2375 gl_info->limits.arb_ps_instructions = gl_max;
2376 TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM native instructions: %d.\n", gl_info->limits.arb_ps_instructions);
2377 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB, &gl_max));
2378 gl_info->limits.arb_ps_local_constants = gl_max;
2379 TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM local parameters: %d.\n", gl_info->limits.arb_ps_instructions);
2381 if (gl_info->supported[ARB_VERTEX_PROGRAM])
2383 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max));
2384 gl_info->limits.arb_vs_float_constants = gl_max;
2385 TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM float constants: %d.\n", gl_info->limits.arb_vs_float_constants);
2386 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB, &gl_max));
2387 gl_info->limits.arb_vs_native_constants = gl_max;
2388 TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM native float constants: %d.\n",
2389 gl_info->limits.arb_vs_native_constants);
2390 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, &gl_max));
2391 gl_info->limits.arb_vs_temps = gl_max;
2392 TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM native temporaries: %d.\n", gl_info->limits.arb_vs_temps);
2393 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, &gl_max));
2394 gl_info->limits.arb_vs_instructions = gl_max;
2395 TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM native instructions: %d.\n", gl_info->limits.arb_vs_instructions);
2397 if (test_arb_vs_offset_limit(gl_info)) gl_info->quirks |= WINED3D_QUIRK_ARB_VS_OFFSET_LIMIT;
2399 if (gl_info->supported[ARB_VERTEX_SHADER])
2401 glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB, &gl_max);
2402 gl_info->limits.glsl_vs_float_constants = gl_max / 4;
2403 TRACE_(d3d_caps)("Max ARB_VERTEX_SHADER float constants: %u.\n", gl_info->limits.glsl_vs_float_constants);
2405 if (gl_info->supported[ARB_FRAGMENT_SHADER])
2407 glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB, &gl_max);
2408 gl_info->limits.glsl_ps_float_constants = gl_max / 4;
2409 TRACE_(d3d_caps)("Max ARB_FRAGMENT_SHADER float constants: %u.\n", gl_info->limits.glsl_ps_float_constants);
2410 glGetIntegerv(GL_MAX_VARYING_FLOATS_ARB, &gl_max);
2411 gl_info->limits.glsl_varyings = gl_max;
2412 TRACE_(d3d_caps)("Max GLSL varyings: %u (%u 4 component varyings).\n", gl_max, gl_max / 4);
2414 if (gl_info->supported[ARB_SHADING_LANGUAGE_100])
2416 const char *str = (const char *)glGetString(GL_SHADING_LANGUAGE_VERSION_ARB);
2417 unsigned int major, minor;
2419 TRACE_(d3d_caps)("GLSL version string: %s.\n", debugstr_a(str));
2421 /* The format of the GLSL version string is "major.minor[.release] [vendor info]". */
2422 sscanf(str, "%u.%u", &major, &minor);
2423 gl_info->glsl_version = MAKEDWORD_VERSION(major, minor);
2425 if (gl_info->supported[NV_LIGHT_MAX_EXPONENT])
2427 glGetFloatv(GL_MAX_SHININESS_NV, &gl_info->limits.shininess);
2431 gl_info->limits.shininess = 128.0f;
2433 if (gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO])
2435 /* If we have full NP2 texture support, disable
2436 * GL_ARB_texture_rectangle because we will never use it.
2437 * This saves a few redundant glDisable calls. */
2438 gl_info->supported[ARB_TEXTURE_RECTANGLE] = FALSE;
2440 if (gl_info->supported[ATI_FRAGMENT_SHADER])
2442 /* Disable NV_register_combiners and fragment shader if this is supported.
2443 * generally the NV extensions are preferred over the ATI ones, and this
2444 * extension is disabled if register_combiners and texture_shader2 are both
2445 * supported. So we reach this place only if we have incomplete NV dxlevel 8
2446 * fragment processing support. */
2447 gl_info->supported[NV_REGISTER_COMBINERS] = FALSE;
2448 gl_info->supported[NV_REGISTER_COMBINERS2] = FALSE;
2449 gl_info->supported[NV_TEXTURE_SHADER] = FALSE;
2450 gl_info->supported[NV_TEXTURE_SHADER2] = FALSE;
2452 if (gl_info->supported[NV_HALF_FLOAT])
2454 /* GL_ARB_half_float_vertex is a subset of GL_NV_half_float. */
2455 gl_info->supported[ARB_HALF_FLOAT_VERTEX] = TRUE;
2457 if (gl_info->supported[ARB_POINT_SPRITE])
2459 gl_info->limits.point_sprite_units = gl_info->limits.textures;
2463 gl_info->limits.point_sprite_units = 0;
2465 checkGLcall("extension detection");
2469 adapter->fragment_pipe = select_fragment_implementation(adapter);
2470 adapter->shader_backend = select_shader_backend(adapter);
2471 adapter->blitter = select_blit_implementation(adapter);
2473 adapter->fragment_pipe->get_caps(gl_info, &fragment_caps);
2474 gl_info->limits.texture_stages = fragment_caps.MaxTextureBlendStages;
2475 TRACE_(d3d_caps)("Max texture stages: %u.\n", gl_info->limits.texture_stages);
2477 /* In some cases the number of texture stages can be larger than the number
2478 * of samplers. The GF4 for example can use only 2 samplers (no fragment
2479 * shaders), but 8 texture stages (register combiners). */
2480 gl_info->limits.sampler_stages = max(gl_info->limits.fragment_samplers, gl_info->limits.texture_stages);
2482 if (gl_info->supported[ARB_FRAMEBUFFER_OBJECT])
2484 gl_info->fbo_ops.glIsRenderbuffer = gl_info->glIsRenderbuffer;
2485 gl_info->fbo_ops.glBindRenderbuffer = gl_info->glBindRenderbuffer;
2486 gl_info->fbo_ops.glDeleteRenderbuffers = gl_info->glDeleteRenderbuffers;
2487 gl_info->fbo_ops.glGenRenderbuffers = gl_info->glGenRenderbuffers;
2488 gl_info->fbo_ops.glRenderbufferStorage = gl_info->glRenderbufferStorage;
2489 gl_info->fbo_ops.glRenderbufferStorageMultisample = gl_info->glRenderbufferStorageMultisample;
2490 gl_info->fbo_ops.glGetRenderbufferParameteriv = gl_info->glGetRenderbufferParameteriv;
2491 gl_info->fbo_ops.glIsFramebuffer = gl_info->glIsFramebuffer;
2492 gl_info->fbo_ops.glBindFramebuffer = gl_info->glBindFramebuffer;
2493 gl_info->fbo_ops.glDeleteFramebuffers = gl_info->glDeleteFramebuffers;
2494 gl_info->fbo_ops.glGenFramebuffers = gl_info->glGenFramebuffers;
2495 gl_info->fbo_ops.glCheckFramebufferStatus = gl_info->glCheckFramebufferStatus;
2496 gl_info->fbo_ops.glFramebufferTexture1D = gl_info->glFramebufferTexture1D;
2497 gl_info->fbo_ops.glFramebufferTexture2D = gl_info->glFramebufferTexture2D;
2498 gl_info->fbo_ops.glFramebufferTexture3D = gl_info->glFramebufferTexture3D;
2499 gl_info->fbo_ops.glFramebufferRenderbuffer = gl_info->glFramebufferRenderbuffer;
2500 gl_info->fbo_ops.glGetFramebufferAttachmentParameteriv = gl_info->glGetFramebufferAttachmentParameteriv;
2501 gl_info->fbo_ops.glBlitFramebuffer = gl_info->glBlitFramebuffer;
2502 gl_info->fbo_ops.glGenerateMipmap = gl_info->glGenerateMipmap;
2506 if (gl_info->supported[EXT_FRAMEBUFFER_OBJECT])
2508 gl_info->fbo_ops.glIsRenderbuffer = gl_info->glIsRenderbufferEXT;
2509 gl_info->fbo_ops.glBindRenderbuffer = gl_info->glBindRenderbufferEXT;
2510 gl_info->fbo_ops.glDeleteRenderbuffers = gl_info->glDeleteRenderbuffersEXT;
2511 gl_info->fbo_ops.glGenRenderbuffers = gl_info->glGenRenderbuffersEXT;
2512 gl_info->fbo_ops.glRenderbufferStorage = gl_info->glRenderbufferStorageEXT;
2513 gl_info->fbo_ops.glGetRenderbufferParameteriv = gl_info->glGetRenderbufferParameterivEXT;
2514 gl_info->fbo_ops.glIsFramebuffer = gl_info->glIsFramebufferEXT;
2515 gl_info->fbo_ops.glBindFramebuffer = gl_info->glBindFramebufferEXT;
2516 gl_info->fbo_ops.glDeleteFramebuffers = gl_info->glDeleteFramebuffersEXT;
2517 gl_info->fbo_ops.glGenFramebuffers = gl_info->glGenFramebuffersEXT;
2518 gl_info->fbo_ops.glCheckFramebufferStatus = gl_info->glCheckFramebufferStatusEXT;
2519 gl_info->fbo_ops.glFramebufferTexture1D = gl_info->glFramebufferTexture1DEXT;
2520 gl_info->fbo_ops.glFramebufferTexture2D = gl_info->glFramebufferTexture2DEXT;
2521 gl_info->fbo_ops.glFramebufferTexture3D = gl_info->glFramebufferTexture3DEXT;
2522 gl_info->fbo_ops.glFramebufferRenderbuffer = gl_info->glFramebufferRenderbufferEXT;
2523 gl_info->fbo_ops.glGetFramebufferAttachmentParameteriv = gl_info->glGetFramebufferAttachmentParameterivEXT;
2524 gl_info->fbo_ops.glGenerateMipmap = gl_info->glGenerateMipmapEXT;
2526 else if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
2528 WARN_(d3d_caps)("Framebuffer objects not supported, falling back to backbuffer offscreen rendering mode.\n");
2529 wined3d_settings.offscreen_rendering_mode = ORM_BACKBUFFER;
2531 if (gl_info->supported[EXT_FRAMEBUFFER_BLIT])
2533 gl_info->fbo_ops.glBlitFramebuffer = gl_info->glBlitFramebufferEXT;
2535 if (gl_info->supported[EXT_FRAMEBUFFER_MULTISAMPLE])
2537 gl_info->fbo_ops.glRenderbufferStorageMultisample = gl_info->glRenderbufferStorageMultisampleEXT;
2541 /* MRTs are currently only supported when FBOs are used. */
2542 if (wined3d_settings.offscreen_rendering_mode != ORM_FBO)
2544 gl_info->limits.buffers = 1;
2547 gl_vendor = wined3d_guess_gl_vendor(gl_info, gl_vendor_str, gl_renderer_str);
2548 card_vendor = wined3d_guess_card_vendor(gl_vendor_str, gl_renderer_str);
2549 TRACE_(d3d_caps)("found GL_VENDOR (%s)->(0x%04x/0x%04x)\n", debugstr_a(gl_vendor_str), gl_vendor, card_vendor);
2551 device = wined3d_guess_card(gl_info, gl_renderer_str, &gl_vendor, &card_vendor);
2552 TRACE_(d3d_caps)("FOUND (fake) card: 0x%x (vendor id), 0x%x (device id)\n", card_vendor, device);
2554 gl_info->wrap_lookup[WINED3DTADDRESS_WRAP - WINED3DTADDRESS_WRAP] = GL_REPEAT;
2555 gl_info->wrap_lookup[WINED3DTADDRESS_MIRROR - WINED3DTADDRESS_WRAP] =
2556 gl_info->supported[ARB_TEXTURE_MIRRORED_REPEAT] ? GL_MIRRORED_REPEAT_ARB : GL_REPEAT;
2557 gl_info->wrap_lookup[WINED3DTADDRESS_CLAMP - WINED3DTADDRESS_WRAP] = GL_CLAMP_TO_EDGE;
2558 gl_info->wrap_lookup[WINED3DTADDRESS_BORDER - WINED3DTADDRESS_WRAP] =
2559 gl_info->supported[ARB_TEXTURE_BORDER_CLAMP] ? GL_CLAMP_TO_BORDER_ARB : GL_REPEAT;
2560 gl_info->wrap_lookup[WINED3DTADDRESS_MIRRORONCE - WINED3DTADDRESS_WRAP] =
2561 gl_info->supported[ATI_TEXTURE_MIRROR_ONCE] ? GL_MIRROR_CLAMP_TO_EDGE_ATI : GL_REPEAT;
2563 /* Make sure there's an active HDC else the WGL extensions will fail */
2564 hdc = pwglGetCurrentDC();
2566 /* Not all GL drivers might offer WGL extensions e.g. VirtualBox */
2567 if(GL_EXTCALL(wglGetExtensionsStringARB))
2568 WGL_Extensions = GL_EXTCALL(wglGetExtensionsStringARB(hdc));
2570 if (!WGL_Extensions)
2572 ERR(" WGL_Extensions returns NULL\n");
2576 TRACE_(d3d_caps)("WGL_Extensions reported:\n");
2577 while (*WGL_Extensions)
2582 while (isspace(*WGL_Extensions)) WGL_Extensions++;
2583 Start = WGL_Extensions;
2584 while (!isspace(*WGL_Extensions) && *WGL_Extensions) ++WGL_Extensions;
2586 len = WGL_Extensions - Start;
2587 if (!len || len >= sizeof(ThisExtn))
2590 memcpy(ThisExtn, Start, len);
2591 ThisExtn[len] = '\0';
2592 TRACE_(d3d_caps)("- %s\n", debugstr_a(ThisExtn));
2594 if (!strcmp(ThisExtn, "WGL_ARB_pixel_format")) {
2595 gl_info->supported[WGL_ARB_PIXEL_FORMAT] = TRUE;
2596 TRACE_(d3d_caps)("FOUND: WGL_ARB_pixel_format support\n");
2598 if (!strcmp(ThisExtn, "WGL_WINE_pixel_format_passthrough")) {
2599 gl_info->supported[WGL_WINE_PIXEL_FORMAT_PASSTHROUGH] = TRUE;
2600 TRACE_(d3d_caps)("FOUND: WGL_WINE_pixel_format_passthrough support\n");
2606 fixup_extensions(gl_info, gl_renderer_str, gl_vendor, card_vendor, device);
2607 init_driver_info(driver_info, card_vendor, device);
2608 add_gl_compat_wrappers(gl_info);
2613 /**********************************************************
2614 * IWineD3D implementation follows
2615 **********************************************************/
2617 static UINT WINAPI IWineD3DImpl_GetAdapterCount (IWineD3D *iface) {
2618 IWineD3DImpl *This = (IWineD3DImpl *)iface;
2620 TRACE_(d3d_caps)("(%p): Reporting %u adapters\n", This, This->adapter_count);
2622 return This->adapter_count;
2625 static HRESULT WINAPI IWineD3DImpl_RegisterSoftwareDevice(IWineD3D *iface, void *init_function)
2627 FIXME("iface %p, init_function %p stub!\n", iface, init_function);
2632 static HMONITOR WINAPI IWineD3DImpl_GetAdapterMonitor(IWineD3D *iface, UINT Adapter) {
2633 IWineD3DImpl *This = (IWineD3DImpl *)iface;
2635 TRACE_(d3d_caps)("(%p)->(%d)\n", This, Adapter);
2637 if (Adapter >= IWineD3DImpl_GetAdapterCount(iface)) {
2641 return MonitorFromPoint(This->adapters[Adapter].monitorPoint, MONITOR_DEFAULTTOPRIMARY);
2644 /* FIXME: GetAdapterModeCount and EnumAdapterModes currently only returns modes
2645 of the same bpp but different resolutions */
2647 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */
2648 static UINT WINAPI IWineD3DImpl_GetAdapterModeCount(IWineD3D *iface, UINT Adapter, enum wined3d_format_id format_id)
2650 IWineD3DImpl *This = (IWineD3DImpl *)iface;
2652 TRACE_(d3d_caps)("iface %p, adapter %u, format_id: %s.\n", iface, Adapter, debug_d3dformat(format_id));
2654 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
2658 /* TODO: Store modes per adapter and read it from the adapter structure */
2661 const struct wined3d_format *format = wined3d_get_format(&This->adapters[Adapter].gl_info, format_id);
2662 UINT format_bits = format->byte_count * CHAR_BIT;
2667 memset(&mode, 0, sizeof(mode));
2668 mode.dmSize = sizeof(mode);
2670 while (EnumDisplaySettingsExW(NULL, j, &mode, 0))
2674 if (format_id == WINED3DFMT_UNKNOWN)
2676 /* This is for D3D8, do not enumerate P8 here */
2677 if (mode.dmBitsPerPel == 32 || mode.dmBitsPerPel == 16) ++i;
2679 else if (mode.dmBitsPerPel == format_bits)
2685 TRACE_(d3d_caps)("(%p}->(Adapter: %d) => %d (out of %d)\n", This, Adapter, i, j);
2688 FIXME_(d3d_caps)("Adapter not primary display\n");
2693 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */
2694 static HRESULT WINAPI IWineD3DImpl_EnumAdapterModes(IWineD3D *iface, UINT Adapter,
2695 enum wined3d_format_id format_id, UINT Mode, WINED3DDISPLAYMODE *pMode)
2697 IWineD3DImpl *This = (IWineD3DImpl *)iface;
2699 TRACE_(d3d_caps)("iface %p, adapter_idx %u, format %s, mode_idx %u, mode %p.\n",
2700 iface, Adapter, debug_d3dformat(format_id), Mode, pMode);
2702 /* Validate the parameters as much as possible */
2703 if (!pMode || Adapter >= IWineD3DImpl_GetAdapterCount(iface)
2704 || Mode >= IWineD3DImpl_GetAdapterModeCount(iface, Adapter, format_id))
2706 return WINED3DERR_INVALIDCALL;
2709 /* TODO: Store modes per adapter and read it from the adapter structure */
2712 const struct wined3d_format *format = wined3d_get_format(&This->adapters[Adapter].gl_info, format_id);
2713 UINT format_bits = format->byte_count * CHAR_BIT;
2719 ZeroMemory(&DevModeW, sizeof(DevModeW));
2720 DevModeW.dmSize = sizeof(DevModeW);
2722 /* If we are filtering to a specific format (D3D9), then need to skip
2723 all unrelated modes, but if mode is irrelevant (D3D8), then we can
2724 just count through the ones with valid bit depths */
2725 while ((i<=Mode) && EnumDisplaySettingsExW(NULL, j++, &DevModeW, 0))
2727 if (format_id == WINED3DFMT_UNKNOWN)
2729 /* This is for D3D8, do not enumerate P8 here */
2730 if (DevModeW.dmBitsPerPel == 32 || DevModeW.dmBitsPerPel == 16) ++i;
2732 else if (DevModeW.dmBitsPerPel == format_bits)
2740 TRACE_(d3d_caps)("No modes found for format (%x - %s)\n", format_id, debug_d3dformat(format_id));
2741 return WINED3DERR_INVALIDCALL;
2745 /* Now get the display mode via the calculated index */
2746 if (EnumDisplaySettingsExW(NULL, ModeIdx, &DevModeW, 0)) {
2747 pMode->Width = DevModeW.dmPelsWidth;
2748 pMode->Height = DevModeW.dmPelsHeight;
2749 pMode->RefreshRate = DEFAULT_REFRESH_RATE;
2750 if (DevModeW.dmFields & DM_DISPLAYFREQUENCY)
2751 pMode->RefreshRate = DevModeW.dmDisplayFrequency;
2753 if (format_id == WINED3DFMT_UNKNOWN)
2754 pMode->Format = pixelformat_for_depth(DevModeW.dmBitsPerPel);
2756 pMode->Format = format_id;
2760 TRACE_(d3d_caps)("Requested mode out of range %d\n", Mode);
2761 return WINED3DERR_INVALIDCALL;
2764 TRACE_(d3d_caps)("W %d H %d rr %d fmt (%x - %s) bpp %u\n", pMode->Width, pMode->Height,
2765 pMode->RefreshRate, pMode->Format, debug_d3dformat(pMode->Format),
2766 DevModeW.dmBitsPerPel);
2771 FIXME_(d3d_caps)("Adapter not primary display\n");
2777 static HRESULT WINAPI IWineD3DImpl_GetAdapterDisplayMode(IWineD3D *iface, UINT Adapter, WINED3DDISPLAYMODE *pMode)
2779 TRACE("iface %p, adapter_idx %u, display_mode %p.\n", iface, Adapter, pMode);
2781 if (!pMode || Adapter >= IWineD3D_GetAdapterCount(iface))
2782 return WINED3DERR_INVALIDCALL;
2784 if (Adapter == 0) { /* Display */
2788 ZeroMemory(&DevModeW, sizeof(DevModeW));
2789 DevModeW.dmSize = sizeof(DevModeW);
2791 EnumDisplaySettingsExW(NULL, ENUM_CURRENT_SETTINGS, &DevModeW, 0);
2792 pMode->Width = DevModeW.dmPelsWidth;
2793 pMode->Height = DevModeW.dmPelsHeight;
2794 bpp = DevModeW.dmBitsPerPel;
2795 pMode->RefreshRate = DEFAULT_REFRESH_RATE;
2796 if (DevModeW.dmFields&DM_DISPLAYFREQUENCY)
2798 pMode->RefreshRate = DevModeW.dmDisplayFrequency;
2801 pMode->Format = pixelformat_for_depth(bpp);
2803 FIXME_(d3d_caps)("Adapter not primary display\n");
2806 TRACE_(d3d_caps)("returning w:%d, h:%d, ref:%d, fmt:%s\n", pMode->Width,
2807 pMode->Height, pMode->RefreshRate, debug_d3dformat(pMode->Format));
2811 /* NOTE: due to structure differences between dx8 and dx9 D3DADAPTER_IDENTIFIER,
2812 and fields being inserted in the middle, a new structure is used in place */
2813 static HRESULT WINAPI IWineD3DImpl_GetAdapterIdentifier(IWineD3D *iface, UINT Adapter, DWORD Flags,
2814 WINED3DADAPTER_IDENTIFIER* pIdentifier) {
2815 IWineD3DImpl *This = (IWineD3DImpl *)iface;
2816 struct wined3d_adapter *adapter;
2819 TRACE_(d3d_caps)("(%p}->(Adapter: %d, Flags: %x, pId=%p)\n", This, Adapter, Flags, pIdentifier);
2821 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
2822 return WINED3DERR_INVALIDCALL;
2825 adapter = &This->adapters[Adapter];
2827 /* Return the information requested */
2828 TRACE_(d3d_caps)("device/Vendor Name and Version detection using FillGLCaps\n");
2830 if (pIdentifier->driver_size)
2832 const char *name = adapter->driver_info.name;
2833 len = min(strlen(name), pIdentifier->driver_size - 1);
2834 memcpy(pIdentifier->driver, name, len);
2835 pIdentifier->driver[len] = '\0';
2838 if (pIdentifier->description_size)
2840 const char *description = adapter->driver_info.description;
2841 len = min(strlen(description), pIdentifier->description_size - 1);
2842 memcpy(pIdentifier->description, description, len);
2843 pIdentifier->description[len] = '\0';
2846 /* Note that d3d8 doesn't supply a device name. */
2847 if (pIdentifier->device_name_size)
2849 static const char *device_name = "\\\\.\\DISPLAY1"; /* FIXME: May depend on desktop? */
2851 len = strlen(device_name);
2852 if (len >= pIdentifier->device_name_size)
2854 ERR("Device name size too small.\n");
2855 return WINED3DERR_INVALIDCALL;
2858 memcpy(pIdentifier->device_name, device_name, len);
2859 pIdentifier->device_name[len] = '\0';
2862 pIdentifier->driver_version.u.HighPart = adapter->driver_info.version_high;
2863 pIdentifier->driver_version.u.LowPart = adapter->driver_info.version_low;
2864 pIdentifier->vendor_id = adapter->driver_info.vendor;
2865 pIdentifier->device_id = adapter->driver_info.device;
2866 pIdentifier->subsystem_id = 0;
2867 pIdentifier->revision = 0;
2868 memcpy(&pIdentifier->device_identifier, &IID_D3DDEVICE_D3DUID, sizeof(pIdentifier->device_identifier));
2869 pIdentifier->whql_level = (Flags & WINED3DENUM_NO_WHQL_LEVEL) ? 0 : 1;
2870 memcpy(&pIdentifier->adapter_luid, &adapter->luid, sizeof(pIdentifier->adapter_luid));
2871 pIdentifier->video_memory = adapter->TextureRam;
2876 static BOOL IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(const struct wined3d_gl_info *gl_info,
2877 const WineD3D_PixelFormat *cfg, const struct wined3d_format *format)
2879 short redSize, greenSize, blueSize, alphaSize, colorBits;
2884 /* Float formats need FBOs. If FBOs are used this function isn't called */
2885 if (format->Flags & WINED3DFMT_FLAG_FLOAT) return FALSE;
2887 if(cfg->iPixelType == WGL_TYPE_RGBA_ARB) { /* Integer RGBA formats */
2888 if (!getColorBits(format, &redSize, &greenSize, &blueSize, &alphaSize, &colorBits))
2890 ERR("Unable to check compatibility for format %s.\n", debug_d3dformat(format->id));
2894 if(cfg->redSize < redSize)
2897 if(cfg->greenSize < greenSize)
2900 if(cfg->blueSize < blueSize)
2903 if(cfg->alphaSize < alphaSize)
2909 /* Probably a RGBA_float or color index mode */
2913 static BOOL IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(const struct wined3d_gl_info *gl_info,
2914 const WineD3D_PixelFormat *cfg, const struct wined3d_format *format)
2916 short depthSize, stencilSize;
2917 BOOL lockable = FALSE;
2922 if (!getDepthStencilBits(format, &depthSize, &stencilSize))
2924 ERR("Unable to check compatibility for format %s.\n", debug_d3dformat(format->id));
2928 /* Float formats need FBOs. If FBOs are used this function isn't called */
2929 if (format->Flags & WINED3DFMT_FLAG_FLOAT) return FALSE;
2931 if ((format->id == WINED3DFMT_D16_LOCKABLE) || (format->id == WINED3DFMT_D32_FLOAT))
2934 /* On some modern cards like the Geforce8/9 GLX doesn't offer some dephthstencil formats which D3D9 reports.
2935 * We can safely report 'compatible' formats (e.g. D24 can be used for D16) as long as we aren't dealing with
2936 * a lockable format. This also helps D3D <= 7 as they expect D16 which isn't offered without this on Geforce8 cards. */
2937 if(!(cfg->depthSize == depthSize || (!lockable && cfg->depthSize > depthSize)))
2940 /* Some cards like Intel i915 ones only offer D24S8 but lots of games also need a format without stencil, so
2941 * allow more stencil bits than requested. */
2942 if(cfg->stencilSize < stencilSize)
2948 static HRESULT WINAPI IWineD3DImpl_CheckDepthStencilMatch(IWineD3D *iface,
2949 UINT Adapter, WINED3DDEVTYPE DeviceType, enum wined3d_format_id AdapterFormat,
2950 enum wined3d_format_id RenderTargetFormat, enum wined3d_format_id DepthStencilFormat)
2952 IWineD3DImpl *This = (IWineD3DImpl *)iface;
2954 const WineD3D_PixelFormat *cfgs;
2955 const struct wined3d_adapter *adapter;
2956 const struct wined3d_format *rt_format;
2957 const struct wined3d_format *ds_format;
2960 WARN_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, DevType:(%x,%s), AdptFmt:(%x,%s), RendrTgtFmt:(%x,%s), DepthStencilFmt:(%x,%s))\n",
2962 DeviceType, debug_d3ddevicetype(DeviceType),
2963 AdapterFormat, debug_d3dformat(AdapterFormat),
2964 RenderTargetFormat, debug_d3dformat(RenderTargetFormat),
2965 DepthStencilFormat, debug_d3dformat(DepthStencilFormat));
2967 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
2968 TRACE("(%p) Failed: Atapter (%u) higher than supported adapters (%u) returning WINED3DERR_INVALIDCALL\n", This, Adapter, IWineD3D_GetAdapterCount(iface));
2969 return WINED3DERR_INVALIDCALL;
2972 adapter = &This->adapters[Adapter];
2973 rt_format = wined3d_get_format(&adapter->gl_info, RenderTargetFormat);
2974 ds_format = wined3d_get_format(&adapter->gl_info, DepthStencilFormat);
2975 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
2977 if ((rt_format->Flags & WINED3DFMT_FLAG_RENDERTARGET)
2978 && (ds_format->Flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL)))
2980 TRACE_(d3d_caps)("(%p) : Formats matched\n", This);
2986 cfgs = adapter->cfgs;
2987 nCfgs = adapter->nCfgs;
2988 for (it = 0; it < nCfgs; ++it)
2990 if (IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&adapter->gl_info, &cfgs[it], rt_format))
2992 if (IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&adapter->gl_info, &cfgs[it], ds_format))
2994 TRACE_(d3d_caps)("(%p) : Formats matched\n", This);
3000 WARN_(d3d_caps)("unsupported format pair: %s and %s\n", debug_d3dformat(RenderTargetFormat), debug_d3dformat(DepthStencilFormat));
3002 return WINED3DERR_NOTAVAILABLE;
3005 static HRESULT WINAPI IWineD3DImpl_CheckDeviceMultiSampleType(IWineD3D *iface, UINT Adapter,
3006 WINED3DDEVTYPE DeviceType, enum wined3d_format_id SurfaceFormat, BOOL Windowed,
3007 WINED3DMULTISAMPLE_TYPE MultiSampleType, DWORD *pQualityLevels)
3009 IWineD3DImpl *This = (IWineD3DImpl *)iface;
3010 const struct wined3d_adapter *adapter;
3011 const struct wined3d_format *format;
3013 TRACE_(d3d_caps)("(%p)-> (Adptr:%d, DevType:(%x,%s), SurfFmt:(%x,%s), Win?%d, MultiSamp:%x, pQual:%p)\n",
3016 DeviceType, debug_d3ddevicetype(DeviceType),
3017 SurfaceFormat, debug_d3dformat(SurfaceFormat),
3022 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
3023 return WINED3DERR_INVALIDCALL;
3026 /* TODO: handle Windowed, add more quality levels */
3028 if (WINED3DMULTISAMPLE_NONE == MultiSampleType) {
3029 if(pQualityLevels) *pQualityLevels = 1;
3033 /* By default multisampling is disabled right now as it causes issues
3034 * on some Nvidia driver versions and it doesn't work well in combination
3036 if(!wined3d_settings.allow_multisampling)
3037 return WINED3DERR_NOTAVAILABLE;
3039 adapter = &This->adapters[Adapter];
3040 format = wined3d_get_format(&adapter->gl_info, SurfaceFormat);
3041 if (!format) return WINED3DERR_INVALIDCALL;
3043 if (format->Flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL))
3046 const WineD3D_PixelFormat *cfgs;
3048 cfgs = adapter->cfgs;
3049 nCfgs = adapter->nCfgs;
3050 for(i=0; i<nCfgs; i++) {
3051 if(cfgs[i].numSamples != MultiSampleType)
3054 if (!IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&adapter->gl_info, &cfgs[i], format))
3057 TRACE("Found iPixelFormat=%d to support MultiSampleType=%d for format %s\n", cfgs[i].iPixelFormat, MultiSampleType, debug_d3dformat(SurfaceFormat));
3060 *pQualityLevels = 1; /* Guess at a value! */
3064 else if (format->Flags & WINED3DFMT_FLAG_RENDERTARGET)
3066 short redSize, greenSize, blueSize, alphaSize, colorBits;
3068 const WineD3D_PixelFormat *cfgs;
3070 if (!getColorBits(format, &redSize, &greenSize, &blueSize, &alphaSize, &colorBits))
3072 ERR("Unable to color bits for format %#x, can't check multisampling capability!\n", SurfaceFormat);
3073 return WINED3DERR_NOTAVAILABLE;
3076 cfgs = adapter->cfgs;
3077 nCfgs = adapter->nCfgs;
3078 for(i=0; i<nCfgs; i++) {
3079 if(cfgs[i].numSamples != MultiSampleType)
3081 if(cfgs[i].redSize != redSize)
3083 if(cfgs[i].greenSize != greenSize)
3085 if(cfgs[i].blueSize != blueSize)
3087 /* Not all drivers report alpha-less formats since they use 32-bit anyway, so accept alpha even if we didn't ask for it. */
3088 if(alphaSize && cfgs[i].alphaSize != alphaSize)
3090 if (cfgs[i].colorSize != (format->byte_count << 3))
3093 TRACE("Found iPixelFormat=%d to support MultiSampleType=%d for format %s\n", cfgs[i].iPixelFormat, MultiSampleType, debug_d3dformat(SurfaceFormat));
3096 *pQualityLevels = 1; /* Guess at a value! */
3100 return WINED3DERR_NOTAVAILABLE;
3103 /* Check if we support bumpmapping for a format */
3104 static BOOL CheckBumpMapCapability(struct wined3d_adapter *adapter, const struct wined3d_format *format)
3106 /* Ask the fixed function pipeline implementation if it can deal
3107 * with the conversion. If we've got a GL extension giving native
3108 * support this will be an identity conversion. */
3109 return (format->Flags & WINED3DFMT_FLAG_BUMPMAP)
3110 && adapter->fragment_pipe->color_fixup_supported(format->color_fixup);
3113 /* Check if the given DisplayFormat + DepthStencilFormat combination is valid for the Adapter */
3114 static BOOL CheckDepthStencilCapability(struct wined3d_adapter *adapter,
3115 const struct wined3d_format *display_format, const struct wined3d_format *ds_format)
3119 /* Only allow depth/stencil formats */
3120 if (!(ds_format->depth_size || ds_format->stencil_size)) return FALSE;
3122 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
3124 /* With FBOs WGL limitations do not apply, but the format needs to be FBO attachable */
3125 if (ds_format->Flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL)) return TRUE;
3129 /* Walk through all WGL pixel formats to find a match */
3130 for (it = 0; it < adapter->nCfgs; ++it)
3132 WineD3D_PixelFormat *cfg = &adapter->cfgs[it];
3133 if (IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&adapter->gl_info, cfg, display_format))
3135 if (IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&adapter->gl_info, cfg, ds_format))
3146 static BOOL CheckFilterCapability(struct wined3d_adapter *adapter, const struct wined3d_format *format)
3148 /* The flags entry of a format contains the filtering capability */
3149 if (format->Flags & WINED3DFMT_FLAG_FILTERING) return TRUE;
3154 /* Check the render target capabilities of a format */
3155 static BOOL CheckRenderTargetCapability(struct wined3d_adapter *adapter,
3156 const struct wined3d_format *adapter_format, const struct wined3d_format *check_format)
3158 /* Filter out non-RT formats */
3159 if (!(check_format->Flags & WINED3DFMT_FLAG_RENDERTARGET)) return FALSE;
3160 if (wined3d_settings.offscreen_rendering_mode == ORM_BACKBUFFER)
3162 WineD3D_PixelFormat *cfgs = adapter->cfgs;
3164 short AdapterRed, AdapterGreen, AdapterBlue, AdapterAlpha, AdapterTotalSize;
3165 short CheckRed, CheckGreen, CheckBlue, CheckAlpha, CheckTotalSize;
3167 getColorBits(adapter_format, &AdapterRed, &AdapterGreen, &AdapterBlue, &AdapterAlpha, &AdapterTotalSize);
3168 getColorBits(check_format, &CheckRed, &CheckGreen, &CheckBlue, &CheckAlpha, &CheckTotalSize);
3170 /* In backbuffer mode the front and backbuffer share the same WGL pixelformat.
3171 * The format must match in RGB, alpha is allowed to be different. (Only the backbuffer can have alpha) */
3172 if(!((AdapterRed == CheckRed) && (AdapterGreen == CheckGreen) && (AdapterBlue == CheckBlue))) {
3173 TRACE_(d3d_caps)("[FAILED]\n");
3177 /* Check if there is a WGL pixel format matching the requirements, the format should also be window
3178 * drawable (not offscreen; e.g. Nvidia offers R5G6B5 for pbuffers even when X is running at 24bit) */
3179 for (it = 0; it < adapter->nCfgs; ++it)
3181 if (cfgs[it].windowDrawable && IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&adapter->gl_info,
3182 &cfgs[it], check_format))
3184 TRACE_(d3d_caps)("Pixel format %d is compatible with format %s.\n",
3185 cfgs[it].iPixelFormat, debug_d3dformat(check_format->id));
3190 else if(wined3d_settings.offscreen_rendering_mode == ORM_FBO)
3192 /* For now return TRUE for FBOs until we have some proper checks.
3193 * Note that this function will only be called when the format is around for texturing. */
3199 static BOOL CheckSrgbReadCapability(struct wined3d_adapter *adapter, const struct wined3d_format *format)
3201 return adapter->gl_info.supported[EXT_TEXTURE_SRGB] && (format->Flags & WINED3DFMT_FLAG_SRGB_READ);
3204 static BOOL CheckSrgbWriteCapability(struct wined3d_adapter *adapter, const struct wined3d_format *format)
3206 /* Only offer SRGB writing on X8R8G8B8/A8R8G8B8 when we use ARB or GLSL shaders as we are
3207 * doing the color fixup in shaders.
3208 * Note Windows drivers (at least on the Geforce 8800) also offer this on R5G6B5. */
3209 if (format->Flags & WINED3DFMT_FLAG_SRGB_WRITE)
3211 int vs_selected_mode;
3212 int ps_selected_mode;
3213 select_shader_mode(&adapter->gl_info, &ps_selected_mode, &vs_selected_mode);
3215 if((ps_selected_mode == SHADER_ARB) || (ps_selected_mode == SHADER_GLSL)) {
3216 TRACE_(d3d_caps)("[OK]\n");
3221 TRACE_(d3d_caps)("[FAILED] - sRGB writes not supported by format %s.\n", debug_d3dformat(format->id));
3225 /* Check if a format support blending in combination with pixel shaders */
3226 static BOOL CheckPostPixelShaderBlendingCapability(struct wined3d_adapter *adapter,
3227 const struct wined3d_format *format)
3229 /* The flags entry of a format contains the post pixel shader blending capability */
3230 if (format->Flags & WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING) return TRUE;
3235 static BOOL CheckWrapAndMipCapability(struct wined3d_adapter *adapter, const struct wined3d_format *format)
3237 /* OpenGL supports mipmapping on all formats basically. Wrapping is unsupported,
3238 * but we have to report mipmapping so we cannot reject this flag. Tests show that
3239 * windows reports WRAPANDMIP on unfilterable surfaces as well, apparently to show
3240 * that wrapping is supported. The lack of filtering will sort out the mipmapping
3241 * capability anyway.
3243 * For now lets report this on all formats, but in the future we may want to
3244 * restrict it to some should games need that
3249 /* Check if a texture format is supported on the given adapter */
3250 static BOOL CheckTextureCapability(struct wined3d_adapter *adapter, const struct wined3d_format *format)
3252 const struct wined3d_gl_info *gl_info = &adapter->gl_info;
3257 * supported: RGB(A) formats
3259 case WINED3DFMT_B8G8R8_UNORM: /* Enable for dx7, blacklisted for 8 and 9 above */
3260 case WINED3DFMT_B8G8R8A8_UNORM:
3261 case WINED3DFMT_B8G8R8X8_UNORM:
3262 case WINED3DFMT_B5G6R5_UNORM:
3263 case WINED3DFMT_B5G5R5X1_UNORM:
3264 case WINED3DFMT_B5G5R5A1_UNORM:
3265 case WINED3DFMT_B4G4R4A4_UNORM:
3266 case WINED3DFMT_A8_UNORM:
3267 case WINED3DFMT_B4G4R4X4_UNORM:
3268 case WINED3DFMT_R8G8B8A8_UNORM:
3269 case WINED3DFMT_R8G8B8X8_UNORM:
3270 case WINED3DFMT_B10G10R10A2_UNORM:
3271 case WINED3DFMT_R10G10B10A2_UNORM:
3272 case WINED3DFMT_R16G16_UNORM:
3273 TRACE_(d3d_caps)("[OK]\n");
3276 case WINED3DFMT_B2G3R3_UNORM:
3277 TRACE_(d3d_caps)("[FAILED] - Not supported on Windows\n");
3281 * Not supported: Palettized
3282 * Only some Geforce/Voodoo3/G400 cards offer 8-bit textures in case of <=Direct3D7.
3283 * Since it is not widely available, don't offer it. Further no Windows driver offers
3284 * WINED3DFMT_P8_UINT_A8_NORM, so don't offer it either.
3286 case WINED3DFMT_P8_UINT:
3287 case WINED3DFMT_P8_UINT_A8_UNORM:
3291 * Supported: (Alpha)-Luminance
3293 case WINED3DFMT_L8_UNORM:
3294 case WINED3DFMT_L8A8_UNORM:
3295 case WINED3DFMT_L16_UNORM:
3296 TRACE_(d3d_caps)("[OK]\n");
3299 /* Not supported on Windows, thus disabled */
3300 case WINED3DFMT_L4A4_UNORM:
3301 TRACE_(d3d_caps)("[FAILED] - not supported on windows\n");
3305 * Supported: Depth/Stencil formats
3307 case WINED3DFMT_D16_LOCKABLE:
3308 case WINED3DFMT_D16_UNORM:
3309 case WINED3DFMT_S1_UINT_D15_UNORM:
3310 case WINED3DFMT_X8D24_UNORM:
3311 case WINED3DFMT_S4X4_UINT_D24_UNORM:
3312 case WINED3DFMT_D24_UNORM_S8_UINT:
3313 case WINED3DFMT_S8_UINT_D24_FLOAT:
3314 case WINED3DFMT_D32_UNORM:
3315 case WINED3DFMT_D32_FLOAT:
3318 case WINED3DFMT_INTZ:
3319 if (gl_info->supported[EXT_PACKED_DEPTH_STENCIL]
3320 || gl_info->supported[ARB_FRAMEBUFFER_OBJECT])
3325 * Not supported everywhere(depends on GL_ATI_envmap_bumpmap or
3326 * GL_NV_texture_shader). Emulated by shaders
3328 case WINED3DFMT_R8G8_SNORM:
3329 case WINED3DFMT_R8G8_SNORM_L8X8_UNORM:
3330 case WINED3DFMT_R5G5_SNORM_L6_UNORM:
3331 case WINED3DFMT_R8G8B8A8_SNORM:
3332 case WINED3DFMT_R16G16_SNORM:
3333 /* Ask the shader backend if it can deal with the conversion. If
3334 * we've got a GL extension giving native support this will be an
3335 * identity conversion. */
3336 if (adapter->shader_backend->shader_color_fixup_supported(format->color_fixup))
3338 TRACE_(d3d_caps)("[OK]\n");
3341 TRACE_(d3d_caps)("[FAILED]\n");
3344 case WINED3DFMT_DXT1:
3345 case WINED3DFMT_DXT2:
3346 case WINED3DFMT_DXT3:
3347 case WINED3DFMT_DXT4:
3348 case WINED3DFMT_DXT5:
3349 if (gl_info->supported[EXT_TEXTURE_COMPRESSION_S3TC])
3351 TRACE_(d3d_caps)("[OK]\n");
3354 TRACE_(d3d_caps)("[FAILED]\n");
3359 * Odd formats - not supported
3361 case WINED3DFMT_VERTEXDATA:
3362 case WINED3DFMT_R16_UINT:
3363 case WINED3DFMT_R32_UINT:
3364 case WINED3DFMT_R16G16B16A16_SNORM:
3365 case WINED3DFMT_R10G10B10_SNORM_A2_UNORM:
3366 case WINED3DFMT_R10G11B11_SNORM:
3367 TRACE_(d3d_caps)("[FAILED]\n"); /* Enable when implemented */
3371 * WINED3DFMT_R8G8_SNORM_Cx: Not supported right now
3373 case WINED3DFMT_R8G8_SNORM_Cx:
3374 TRACE_(d3d_caps)("[FAILED]\n"); /* Enable when implemented */
3378 case WINED3DFMT_UYVY:
3379 case WINED3DFMT_YUY2:
3380 if (gl_info->supported[APPLE_YCBCR_422])
3382 TRACE_(d3d_caps)("[OK]\n");
3385 TRACE_(d3d_caps)("[FAILED]\n");
3387 case WINED3DFMT_YV12:
3388 TRACE_(d3d_caps)("[FAILED]\n");
3392 case WINED3DFMT_R16G16B16A16_UNORM:
3393 case WINED3DFMT_B2G3R3A8_UNORM:
3394 TRACE_(d3d_caps)("[FAILED]\n"); /* Enable when implemented */
3397 /* Floating point formats */
3398 case WINED3DFMT_R16_FLOAT:
3399 case WINED3DFMT_R16G16_FLOAT:
3400 case WINED3DFMT_R16G16B16A16_FLOAT:
3401 if (gl_info->supported[ARB_TEXTURE_FLOAT] && gl_info->supported[ARB_HALF_FLOAT_PIXEL])
3403 TRACE_(d3d_caps)("[OK]\n");
3406 TRACE_(d3d_caps)("[FAILED]\n");
3409 case WINED3DFMT_R32_FLOAT:
3410 case WINED3DFMT_R32G32_FLOAT:
3411 case WINED3DFMT_R32G32B32A32_FLOAT:
3412 if (gl_info->supported[ARB_TEXTURE_FLOAT])
3414 TRACE_(d3d_caps)("[OK]\n");
3417 TRACE_(d3d_caps)("[FAILED]\n");
3420 /* ATI instancing hack: Although ATI cards do not support Shader Model 3.0, they support
3421 * instancing. To query if the card supports instancing CheckDeviceFormat with the special format
3422 * MAKEFOURCC('I','N','S','T') is used. Should a (broken) app check for this provide a proper return value.
3423 * We can do instancing with all shader versions, but we need vertex shaders.
3425 * Additionally applications have to set the D3DRS_POINTSIZE render state to MAKEFOURCC('I','N','S','T') once
3426 * to enable instancing. WineD3D doesn't need that and just ignores it.
3428 * With Shader Model 3.0 capable cards Instancing 'just works' in Windows.
3430 case WINED3DFMT_INST:
3431 TRACE("ATI Instancing check hack\n");
3432 if (gl_info->supported[ARB_VERTEX_PROGRAM] || gl_info->supported[ARB_VERTEX_SHADER])
3434 TRACE_(d3d_caps)("[OK]\n");
3437 TRACE_(d3d_caps)("[FAILED]\n");
3440 /* Some weird FOURCC formats */
3441 case WINED3DFMT_R8G8_B8G8:
3442 case WINED3DFMT_G8R8_G8B8:
3443 case WINED3DFMT_MULTI2_ARGB8:
3444 TRACE_(d3d_caps)("[FAILED]\n");
3447 /* Vendor specific formats */
3448 case WINED3DFMT_ATI2N:
3449 if (gl_info->supported[ATI_TEXTURE_COMPRESSION_3DC]
3450 || gl_info->supported[ARB_TEXTURE_COMPRESSION_RGTC])
3452 if (adapter->shader_backend->shader_color_fixup_supported(format->color_fixup)
3453 && adapter->fragment_pipe->color_fixup_supported(format->color_fixup))
3455 TRACE_(d3d_caps)("[OK]\n");
3459 TRACE_(d3d_caps)("[OK]\n");
3462 TRACE_(d3d_caps)("[FAILED]\n");
3465 /* Depth bound test. To query if the card supports it CheckDeviceFormat with the special
3466 * format MAKEFOURCC('N','V','D','B') is used.
3467 * It is enabled by setting D3DRS_ADAPTIVETESS_X render state to MAKEFOURCC('N','V','D','B') and
3468 * then controlled by setting D3DRS_ADAPTIVETESS_Z (zMin) and D3DRS_ADAPTIVETESS_W (zMax)
3471 case WINED3DFMT_NVDB:
3472 if (gl_info->supported[EXT_DEPTH_BOUNDS_TEST])
3474 TRACE_(d3d_caps)("[OK]\n");
3477 TRACE_(d3d_caps)("[FAILED]\n");
3480 case WINED3DFMT_NVHU:
3481 case WINED3DFMT_NVHS:
3482 /* These formats seem to be similar to the HILO formats in GL_NV_texture_shader. NVHU
3483 * is said to be GL_UNSIGNED_HILO16, NVHS GL_SIGNED_HILO16. Rumours say that d3d computes
3484 * a 3rd channel similarly to D3DFMT_CxV8U8(So NVHS could be called D3DFMT_CxV16U16).
3485 * ATI refused to support formats which can easilly be emulated with pixel shaders, so
3486 * Applications have to deal with not having NVHS and NVHU.
3488 TRACE_(d3d_caps)("[FAILED]\n");
3491 case WINED3DFMT_UNKNOWN:
3495 ERR("Unhandled format %s.\n", debug_d3dformat(format->id));
3501 static BOOL CheckSurfaceCapability(struct wined3d_adapter *adapter,
3502 const struct wined3d_format *adapter_format,
3503 const struct wined3d_format *check_format,
3504 WINED3DSURFTYPE SurfaceType)
3506 if (SurfaceType == SURFACE_GDI)
3508 switch (check_format->id)
3510 case WINED3DFMT_B8G8R8_UNORM:
3511 case WINED3DFMT_B8G8R8A8_UNORM:
3512 case WINED3DFMT_B8G8R8X8_UNORM:
3513 case WINED3DFMT_B5G6R5_UNORM:
3514 case WINED3DFMT_B5G5R5X1_UNORM:
3515 case WINED3DFMT_B5G5R5A1_UNORM:
3516 case WINED3DFMT_B4G4R4A4_UNORM:
3517 case WINED3DFMT_B2G3R3_UNORM:
3518 case WINED3DFMT_A8_UNORM:
3519 case WINED3DFMT_B2G3R3A8_UNORM:
3520 case WINED3DFMT_B4G4R4X4_UNORM:
3521 case WINED3DFMT_R10G10B10A2_UNORM:
3522 case WINED3DFMT_R8G8B8A8_UNORM:
3523 case WINED3DFMT_R8G8B8X8_UNORM:
3524 case WINED3DFMT_R16G16_UNORM:
3525 case WINED3DFMT_B10G10R10A2_UNORM:
3526 case WINED3DFMT_R16G16B16A16_UNORM:
3527 case WINED3DFMT_P8_UINT:
3528 TRACE_(d3d_caps)("[OK]\n");
3531 TRACE_(d3d_caps)("[FAILED] - not available on GDI surfaces\n");
3536 /* All format that are supported for textures are supported for surfaces as well */
3537 if (CheckTextureCapability(adapter, check_format)) return TRUE;
3538 /* All depth stencil formats are supported on surfaces */
3539 if (CheckDepthStencilCapability(adapter, adapter_format, check_format)) return TRUE;
3541 /* If opengl can't process the format natively, the blitter may be able to convert it */
3542 if (adapter->blitter->blit_supported(&adapter->gl_info, BLIT_OP_BLIT,
3543 NULL, WINED3DPOOL_DEFAULT, 0, check_format,
3544 NULL, WINED3DPOOL_DEFAULT, 0, adapter_format))
3546 TRACE_(d3d_caps)("[OK]\n");
3550 /* Reject other formats */
3551 TRACE_(d3d_caps)("[FAILED]\n");
3555 static BOOL CheckVertexTextureCapability(struct wined3d_adapter *adapter,
3556 const struct wined3d_format *format)
3558 return adapter->gl_info.limits.vertex_samplers && (format->Flags & WINED3DFMT_FLAG_VTF);
3561 static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
3562 enum wined3d_format_id AdapterFormat, DWORD Usage, WINED3DRESOURCETYPE RType,
3563 enum wined3d_format_id CheckFormat, WINED3DSURFTYPE SurfaceType)
3565 IWineD3DImpl *This = (IWineD3DImpl *)iface;
3566 struct wined3d_adapter *adapter = &This->adapters[Adapter];
3567 const struct wined3d_gl_info *gl_info = &adapter->gl_info;
3568 const struct wined3d_format *format = wined3d_get_format(gl_info, CheckFormat);
3569 const struct wined3d_format *adapter_format = wined3d_get_format(gl_info, AdapterFormat);
3570 DWORD UsageCaps = 0;
3572 TRACE_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, DevType:(%u,%s), AdptFmt:(%u,%s), Use:(%u,%s,%s), ResTyp:(%x,%s), CheckFmt:(%u,%s))\n",
3575 DeviceType, debug_d3ddevicetype(DeviceType),
3576 AdapterFormat, debug_d3dformat(AdapterFormat),
3577 Usage, debug_d3dusage(Usage), debug_d3dusagequery(Usage),
3578 RType, debug_d3dresourcetype(RType),
3579 CheckFormat, debug_d3dformat(CheckFormat));
3581 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
3582 return WINED3DERR_INVALIDCALL;
3587 case WINED3DRTYPE_CUBETEXTURE:
3588 /* Cubetexture allows:
3589 * - WINED3DUSAGE_AUTOGENMIPMAP
3590 * - WINED3DUSAGE_DEPTHSTENCIL
3591 * - WINED3DUSAGE_DYNAMIC
3592 * - WINED3DUSAGE_NONSECURE (d3d9ex)
3593 * - WINED3DUSAGE_RENDERTARGET
3594 * - WINED3DUSAGE_SOFTWAREPROCESSING
3595 * - WINED3DUSAGE_QUERY_WRAPANDMIP
3597 if (SurfaceType != SURFACE_OPENGL)
3599 TRACE_(d3d_caps)("[FAILED]\n");
3600 return WINED3DERR_NOTAVAILABLE;
3603 if (!gl_info->supported[ARB_TEXTURE_CUBE_MAP])
3605 TRACE_(d3d_caps)("[FAILED] - No cube texture support\n");
3606 return WINED3DERR_NOTAVAILABLE;
3609 if (!CheckTextureCapability(adapter, format))
3611 TRACE_(d3d_caps)("[FAILED] - Cube texture format not supported\n");
3612 return WINED3DERR_NOTAVAILABLE;
3615 if (Usage & WINED3DUSAGE_AUTOGENMIPMAP)
3617 if (!gl_info->supported[SGIS_GENERATE_MIPMAP])
3618 /* When autogenmipmap isn't around continue and return
3619 * WINED3DOK_NOAUTOGEN instead of D3D_OK. */
3620 TRACE_(d3d_caps)("[FAILED] - No autogenmipmap support, but continuing\n");
3622 UsageCaps |= WINED3DUSAGE_AUTOGENMIPMAP;
3625 /* Always report dynamic locking. */
3626 if (Usage & WINED3DUSAGE_DYNAMIC)
3627 UsageCaps |= WINED3DUSAGE_DYNAMIC;
3629 if (Usage & WINED3DUSAGE_RENDERTARGET)
3631 if (!CheckRenderTargetCapability(adapter, adapter_format, format))
3633 TRACE_(d3d_caps)("[FAILED] - No rendertarget support\n");
3634 return WINED3DERR_NOTAVAILABLE;
3636 UsageCaps |= WINED3DUSAGE_RENDERTARGET;
3639 /* Always report software processing. */
3640 if (Usage & WINED3DUSAGE_SOFTWAREPROCESSING)
3641 UsageCaps |= WINED3DUSAGE_SOFTWAREPROCESSING;
3643 if (Usage & WINED3DUSAGE_QUERY_FILTER)
3645 if (!CheckFilterCapability(adapter, format))
3647 TRACE_(d3d_caps)("[FAILED] - No query filter support\n");
3648 return WINED3DERR_NOTAVAILABLE;
3650 UsageCaps |= WINED3DUSAGE_QUERY_FILTER;
3653 if (Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING)
3655 if (!CheckPostPixelShaderBlendingCapability(adapter, format))
3657 TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
3658 return WINED3DERR_NOTAVAILABLE;
3660 UsageCaps |= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
3663 if (Usage & WINED3DUSAGE_QUERY_SRGBREAD)
3665 if (!CheckSrgbReadCapability(adapter, format))
3667 TRACE_(d3d_caps)("[FAILED] - No query srgbread support\n");
3668 return WINED3DERR_NOTAVAILABLE;
3670 UsageCaps |= WINED3DUSAGE_QUERY_SRGBREAD;
3673 if (Usage & WINED3DUSAGE_QUERY_SRGBWRITE)
3675 if (!CheckSrgbWriteCapability(adapter, format))
3677 TRACE_(d3d_caps)("[FAILED] - No query srgbwrite support\n");
3678 return WINED3DERR_NOTAVAILABLE;
3680 UsageCaps |= WINED3DUSAGE_QUERY_SRGBWRITE;
3683 if (Usage & WINED3DUSAGE_QUERY_VERTEXTEXTURE)
3685 if (!CheckVertexTextureCapability(adapter, format))
3687 TRACE_(d3d_caps)("[FAILED] - No query vertextexture support\n");
3688 return WINED3DERR_NOTAVAILABLE;
3690 UsageCaps |= WINED3DUSAGE_QUERY_VERTEXTEXTURE;
3693 if (Usage & WINED3DUSAGE_QUERY_WRAPANDMIP)
3695 if (!CheckWrapAndMipCapability(adapter, format))
3697 TRACE_(d3d_caps)("[FAILED] - No wrapping and mipmapping support\n");
3698 return WINED3DERR_NOTAVAILABLE;
3700 UsageCaps |= WINED3DUSAGE_QUERY_WRAPANDMIP;
3704 case WINED3DRTYPE_SURFACE:
3706 * - WINED3DUSAGE_DEPTHSTENCIL
3707 * - WINED3DUSAGE_NONSECURE (d3d9ex)
3708 * - WINED3DUSAGE_RENDERTARGET
3710 if (!CheckSurfaceCapability(adapter, adapter_format, format, SurfaceType))
3712 TRACE_(d3d_caps)("[FAILED] - Not supported for plain surfaces\n");
3713 return WINED3DERR_NOTAVAILABLE;
3716 if (Usage & WINED3DUSAGE_DEPTHSTENCIL)
3718 if (!CheckDepthStencilCapability(adapter, adapter_format, format))
3720 TRACE_(d3d_caps)("[FAILED] - No depthstencil support\n");
3721 return WINED3DERR_NOTAVAILABLE;
3723 UsageCaps |= WINED3DUSAGE_DEPTHSTENCIL;
3726 if (Usage & WINED3DUSAGE_RENDERTARGET)
3728 if (!CheckRenderTargetCapability(adapter, adapter_format, format))
3730 TRACE_(d3d_caps)("[FAILED] - No rendertarget support\n");
3731 return WINED3DERR_NOTAVAILABLE;
3733 UsageCaps |= WINED3DUSAGE_RENDERTARGET;
3736 if (Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING)
3738 if (!CheckPostPixelShaderBlendingCapability(adapter, format))
3740 TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
3741 return WINED3DERR_NOTAVAILABLE;
3743 UsageCaps |= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
3747 case WINED3DRTYPE_TEXTURE:
3749 * - WINED3DUSAGE_AUTOGENMIPMAP
3750 * - WINED3DUSAGE_DEPTHSTENCIL
3751 * - WINED3DUSAGE_DMAP
3752 * - WINED3DUSAGE_DYNAMIC
3753 * - WINED3DUSAGE_NONSECURE (d3d9ex)
3754 * - WINED3DUSAGE_RENDERTARGET
3755 * - WINED3DUSAGE_SOFTWAREPROCESSING
3756 * - WINED3DUSAGE_TEXTAPI (d3d9ex)
3757 * - WINED3DUSAGE_QUERY_WRAPANDMIP
3759 if (SurfaceType != SURFACE_OPENGL)
3761 TRACE_(d3d_caps)("[FAILED]\n");
3762 return WINED3DERR_NOTAVAILABLE;
3765 if (!CheckTextureCapability(adapter, format))
3767 TRACE_(d3d_caps)("[FAILED] - Texture format not supported\n");
3768 return WINED3DERR_NOTAVAILABLE;
3771 if (Usage & WINED3DUSAGE_AUTOGENMIPMAP)
3773 if (!gl_info->supported[SGIS_GENERATE_MIPMAP])
3774 /* When autogenmipmap isn't around continue and return
3775 * WINED3DOK_NOAUTOGEN instead of D3D_OK. */
3776 TRACE_(d3d_caps)("[FAILED] - No autogenmipmap support, but continuing\n");
3778 UsageCaps |= WINED3DUSAGE_AUTOGENMIPMAP;
3781 /* Always report dynamic locking. */
3782 if (Usage & WINED3DUSAGE_DYNAMIC)
3783 UsageCaps |= WINED3DUSAGE_DYNAMIC;
3785 if (Usage & WINED3DUSAGE_RENDERTARGET)
3787 if (!CheckRenderTargetCapability(adapter, adapter_format, format))
3789 TRACE_(d3d_caps)("[FAILED] - No rendertarget support\n");
3790 return WINED3DERR_NOTAVAILABLE;
3792 UsageCaps |= WINED3DUSAGE_RENDERTARGET;
3795 /* Always report software processing. */
3796 if (Usage & WINED3DUSAGE_SOFTWAREPROCESSING)
3797 UsageCaps |= WINED3DUSAGE_SOFTWAREPROCESSING;
3799 if (Usage & WINED3DUSAGE_QUERY_FILTER)
3801 if (!CheckFilterCapability(adapter, format))
3803 TRACE_(d3d_caps)("[FAILED] - No query filter support\n");
3804 return WINED3DERR_NOTAVAILABLE;
3806 UsageCaps |= WINED3DUSAGE_QUERY_FILTER;
3809 if (Usage & WINED3DUSAGE_QUERY_LEGACYBUMPMAP)
3811 if (!CheckBumpMapCapability(adapter, format))
3813 TRACE_(d3d_caps)("[FAILED] - No legacy bumpmap support\n");
3814 return WINED3DERR_NOTAVAILABLE;
3816 UsageCaps |= WINED3DUSAGE_QUERY_LEGACYBUMPMAP;
3819 if (Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING)
3821 if (!CheckPostPixelShaderBlendingCapability(adapter, format))
3823 TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
3824 return WINED3DERR_NOTAVAILABLE;
3826 UsageCaps |= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
3829 if (Usage & WINED3DUSAGE_QUERY_SRGBREAD)
3831 if (!CheckSrgbReadCapability(adapter, format))
3833 TRACE_(d3d_caps)("[FAILED] - No query srgbread support\n");
3834 return WINED3DERR_NOTAVAILABLE;
3836 UsageCaps |= WINED3DUSAGE_QUERY_SRGBREAD;
3839 if (Usage & WINED3DUSAGE_QUERY_SRGBWRITE)
3841 if (!CheckSrgbWriteCapability(adapter, format))
3843 TRACE_(d3d_caps)("[FAILED] - No query srgbwrite support\n");
3844 return WINED3DERR_NOTAVAILABLE;
3846 UsageCaps |= WINED3DUSAGE_QUERY_SRGBWRITE;
3849 if (Usage & WINED3DUSAGE_QUERY_VERTEXTEXTURE)
3851 if (!CheckVertexTextureCapability(adapter, format))
3853 TRACE_(d3d_caps)("[FAILED] - No query vertextexture support\n");
3854 return WINED3DERR_NOTAVAILABLE;
3856 UsageCaps |= WINED3DUSAGE_QUERY_VERTEXTEXTURE;
3859 if (Usage & WINED3DUSAGE_QUERY_WRAPANDMIP)
3861 if (!CheckWrapAndMipCapability(adapter, format))
3863 TRACE_(d3d_caps)("[FAILED] - No wrapping and mipmapping support\n");
3864 return WINED3DERR_NOTAVAILABLE;
3866 UsageCaps |= WINED3DUSAGE_QUERY_WRAPANDMIP;
3869 if (Usage & WINED3DUSAGE_DEPTHSTENCIL)
3871 if (!CheckDepthStencilCapability(adapter, adapter_format, format))
3873 TRACE_(d3d_caps)("[FAILED] - No depth stencil support\n");
3874 return WINED3DERR_NOTAVAILABLE;
3876 if ((format->Flags & WINED3DFMT_FLAG_SHADOW) && !gl_info->supported[ARB_SHADOW])
3878 TRACE_(d3d_caps)("[FAILED] - No shadow sampler support.\n");
3879 return WINED3DERR_NOTAVAILABLE;
3881 UsageCaps |= WINED3DUSAGE_DEPTHSTENCIL;
3885 case WINED3DRTYPE_VOLUMETEXTURE:
3886 case WINED3DRTYPE_VOLUME:
3887 /* Volume is to VolumeTexture what Surface is to Texture, but its
3888 * usage caps are not documented. Most driver seem to offer
3889 * (nearly) the same on Volume and VolumeTexture, so do that too.
3891 * Volumetexture allows:
3892 * - D3DUSAGE_DYNAMIC
3893 * - D3DUSAGE_NONSECURE (d3d9ex)
3894 * - D3DUSAGE_SOFTWAREPROCESSING
3895 * - D3DUSAGE_QUERY_WRAPANDMIP
3897 if (SurfaceType != SURFACE_OPENGL)
3899 TRACE_(d3d_caps)("[FAILED]\n");
3900 return WINED3DERR_NOTAVAILABLE;
3903 if (!gl_info->supported[EXT_TEXTURE3D])
3905 TRACE_(d3d_caps)("[FAILED] - No volume texture support\n");
3906 return WINED3DERR_NOTAVAILABLE;
3909 if (!CheckTextureCapability(adapter, format))
3911 TRACE_(d3d_caps)("[FAILED] - Format not supported\n");
3912 return WINED3DERR_NOTAVAILABLE;
3915 /* Filter formats that need conversion; For one part, this
3916 * conversion is unimplemented, and volume textures are huge, so
3917 * it would be a big performance hit. Unless we hit an application
3918 * needing one of those formats, don't advertize them to avoid
3919 * leading applications into temptation. The windows drivers don't
3920 * support most of those formats on volumes anyway, except for
3921 * WINED3DFMT_R32_FLOAT. */
3922 switch (CheckFormat)
3924 case WINED3DFMT_P8_UINT:
3925 case WINED3DFMT_L4A4_UNORM:
3926 case WINED3DFMT_R32_FLOAT:
3927 case WINED3DFMT_R16_FLOAT:
3928 case WINED3DFMT_R8G8_SNORM_L8X8_UNORM:
3929 case WINED3DFMT_R5G5_SNORM_L6_UNORM:
3930 case WINED3DFMT_R16G16_UNORM:
3931 TRACE_(d3d_caps)("[FAILED] - No converted formats on volumes\n");
3932 return WINED3DERR_NOTAVAILABLE;
3934 case WINED3DFMT_R8G8B8A8_SNORM:
3935 case WINED3DFMT_R16G16_SNORM:
3936 if (!gl_info->supported[NV_TEXTURE_SHADER])
3938 TRACE_(d3d_caps)("[FAILED] - No converted formats on volumes\n");
3939 return WINED3DERR_NOTAVAILABLE;
3943 case WINED3DFMT_R8G8_SNORM:
3944 if (!gl_info->supported[NV_TEXTURE_SHADER])
3946 TRACE_(d3d_caps)("[FAILED] - No converted formats on volumes\n");
3947 return WINED3DERR_NOTAVAILABLE;
3951 case WINED3DFMT_DXT1:
3952 case WINED3DFMT_DXT2:
3953 case WINED3DFMT_DXT3:
3954 case WINED3DFMT_DXT4:
3955 case WINED3DFMT_DXT5:
3956 /* The GL_EXT_texture_compression_s3tc spec requires that
3957 * loading an s3tc compressed texture results in an error.
3958 * While the D3D refrast does support s3tc volumes, at
3959 * least the nvidia windows driver does not, so we're free
3960 * not to support this format. */
3961 TRACE_(d3d_caps)("[FAILED] - DXTn does not support 3D textures\n");
3962 return WINED3DERR_NOTAVAILABLE;
3965 /* Do nothing, continue with checking the format below */
3969 /* Always report dynamic locking. */
3970 if (Usage & WINED3DUSAGE_DYNAMIC)
3971 UsageCaps |= WINED3DUSAGE_DYNAMIC;
3973 /* Always report software processing. */
3974 if (Usage & WINED3DUSAGE_SOFTWAREPROCESSING)
3975 UsageCaps |= WINED3DUSAGE_SOFTWAREPROCESSING;
3977 if (Usage & WINED3DUSAGE_QUERY_FILTER)
3979 if (!CheckFilterCapability(adapter, format))
3981 TRACE_(d3d_caps)("[FAILED] - No query filter support\n");
3982 return WINED3DERR_NOTAVAILABLE;
3984 UsageCaps |= WINED3DUSAGE_QUERY_FILTER;
3987 if (Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING)
3989 if (!CheckPostPixelShaderBlendingCapability(adapter, format))
3991 TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
3992 return WINED3DERR_NOTAVAILABLE;
3994 UsageCaps |= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
3997 if (Usage & WINED3DUSAGE_QUERY_SRGBREAD)
3999 if (!CheckSrgbReadCapability(adapter, format))
4001 TRACE_(d3d_caps)("[FAILED] - No query srgbread support\n");
4002 return WINED3DERR_NOTAVAILABLE;
4004 UsageCaps |= WINED3DUSAGE_QUERY_SRGBREAD;
4007 if (Usage & WINED3DUSAGE_QUERY_SRGBWRITE)
4009 if (!CheckSrgbWriteCapability(adapter, format))
4011 TRACE_(d3d_caps)("[FAILED] - No query srgbwrite support\n");
4012 return WINED3DERR_NOTAVAILABLE;
4014 UsageCaps |= WINED3DUSAGE_QUERY_SRGBWRITE;
4017 if (Usage & WINED3DUSAGE_QUERY_VERTEXTEXTURE)
4019 if (!CheckVertexTextureCapability(adapter, format))
4021 TRACE_(d3d_caps)("[FAILED] - No query vertextexture support\n");
4022 return WINED3DERR_NOTAVAILABLE;
4024 UsageCaps |= WINED3DUSAGE_QUERY_VERTEXTEXTURE;
4027 if (Usage & WINED3DUSAGE_QUERY_WRAPANDMIP)
4029 if (!CheckWrapAndMipCapability(adapter, format))
4031 TRACE_(d3d_caps)("[FAILED] - No wrapping and mipmapping support\n");
4032 return WINED3DERR_NOTAVAILABLE;
4034 UsageCaps |= WINED3DUSAGE_QUERY_WRAPANDMIP;
4039 FIXME_(d3d_caps)("Unhandled resource type %s.\n", debug_d3dresourcetype(RType));
4040 return WINED3DERR_NOTAVAILABLE;
4043 /* When the UsageCaps exactly matches Usage return WINED3D_OK except for
4044 * the situation in which WINED3DUSAGE_AUTOGENMIPMAP isn't around, then
4045 * WINED3DOK_NOAUTOGEN is returned if all the other usage flags match. */
4046 if (UsageCaps == Usage)
4048 if (UsageCaps == (Usage & ~WINED3DUSAGE_AUTOGENMIPMAP))
4049 return WINED3DOK_NOAUTOGEN;
4051 TRACE_(d3d_caps)("[FAILED] - Usage %#x requested for CheckFormat %s and RType %s but only %#x is available\n",
4052 Usage, debug_d3dformat(CheckFormat), debug_d3dresourcetype(RType), UsageCaps);
4054 return WINED3DERR_NOTAVAILABLE;
4057 static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormatConversion(IWineD3D *iface, UINT adapter_idx,
4058 WINED3DDEVTYPE device_type, enum wined3d_format_id src_format, enum wined3d_format_id dst_format)
4060 FIXME("iface %p, adapter_idx %u, device_type %s, src_format %s, dst_format %s stub!\n",
4061 iface, adapter_idx, debug_d3ddevicetype(device_type), debug_d3dformat(src_format),
4062 debug_d3dformat(dst_format));
4067 static HRESULT WINAPI IWineD3DImpl_CheckDeviceType(IWineD3D *iface, UINT adapter_idx, WINED3DDEVTYPE device_type,
4068 enum wined3d_format_id display_format, enum wined3d_format_id backbuffer_format, BOOL windowed)
4073 TRACE("iface %p, adapter_idx %u, device_type %s, display_format %s, backbuffer_format %s, windowed %#x.\n",
4074 iface, adapter_idx, debug_d3ddevicetype(device_type), debug_d3dformat(display_format),
4075 debug_d3dformat(backbuffer_format), windowed);
4077 if (adapter_idx >= IWineD3D_GetAdapterCount(iface))
4079 WARN_(d3d_caps)("adapter_idx >= IWineD3D_GetAdapterCount(iface), returning WINED3DERR_INVALIDCALL\n");
4080 return WINED3DERR_INVALIDCALL;
4083 /* The task of this function is to check whether a certain display / backbuffer format
4084 * combination is available on the given adapter. In fullscreen mode microsoft specified
4085 * that the display format shouldn't provide alpha and that ignoring alpha the backbuffer
4086 * and display format should match exactly.
4087 * In windowed mode format conversion can occur and this depends on the driver. When format
4088 * conversion is done, this function should nevertheless fail and applications need to use
4089 * CheckDeviceFormatConversion.
4090 * At the moment we assume that fullscreen and windowed have the same capabilities. */
4092 /* There are only 4 display formats. */
4093 if (!(display_format == WINED3DFMT_B5G6R5_UNORM
4094 || display_format == WINED3DFMT_B5G5R5X1_UNORM
4095 || display_format == WINED3DFMT_B8G8R8X8_UNORM
4096 || display_format == WINED3DFMT_B10G10R10A2_UNORM))
4098 TRACE_(d3d_caps)("Format %s is not supported as display format.\n", debug_d3dformat(display_format));
4099 return WINED3DERR_NOTAVAILABLE;
4102 /* If the requested display format is not available, don't continue. */
4103 mode_count = IWineD3DImpl_GetAdapterModeCount(iface, adapter_idx, display_format);
4106 TRACE_(d3d_caps)("No available modes for display format %s.\n", debug_d3dformat(display_format));
4107 return WINED3DERR_NOTAVAILABLE;
4110 /* Windowed mode allows you to specify WINED3DFMT_UNKNOWN for the backbuffer format,
4111 * it means 'reuse' the display format for the backbuffer. */
4112 if (!windowed && backbuffer_format == WINED3DFMT_UNKNOWN)
4114 TRACE_(d3d_caps)("backbuffer_format WINED3FMT_UNKNOWN only available in windowed mode.\n");
4115 return WINED3DERR_NOTAVAILABLE;
4118 /* In FULLSCREEN mode WINED3DFMT_B5G6R5_UNORM can only be mixed with
4119 * backbuffer format WINED3DFMT_B5G6R5_UNORM. */
4120 if (display_format == WINED3DFMT_B5G6R5_UNORM && backbuffer_format != WINED3DFMT_B5G6R5_UNORM)
4122 TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s / %s.\n",
4123 debug_d3dformat(display_format), debug_d3dformat(backbuffer_format));
4124 return WINED3DERR_NOTAVAILABLE;
4127 /* In FULLSCREEN mode WINED3DFMT_B5G5R5X1_UNORM can only be mixed with
4128 * backbuffer formats WINED3DFMT_B5G5R5X1_UNORM and
4129 * WINED3DFMT_B5G5R5A1_UNORM. */
4130 if (display_format == WINED3DFMT_B5G5R5X1_UNORM
4131 && !(backbuffer_format == WINED3DFMT_B5G5R5X1_UNORM || backbuffer_format == WINED3DFMT_B5G5R5A1_UNORM))
4133 TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s / %s.\n",
4134 debug_d3dformat(display_format), debug_d3dformat(backbuffer_format));
4135 return WINED3DERR_NOTAVAILABLE;
4138 /* In FULLSCREEN mode WINED3DFMT_B8G8R8X8_UNORM can only be mixed with
4139 * backbuffer formats WINED3DFMT_B8G8R8X8_UNORM and
4140 * WINED3DFMT_B8G8R8A8_UNORM. */
4141 if (display_format == WINED3DFMT_B8G8R8X8_UNORM
4142 && !(backbuffer_format == WINED3DFMT_B8G8R8X8_UNORM || backbuffer_format == WINED3DFMT_B8G8R8A8_UNORM))
4144 TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s / %s.\n",
4145 debug_d3dformat(display_format), debug_d3dformat(backbuffer_format));
4146 return WINED3DERR_NOTAVAILABLE;
4149 /* WINED3DFMT_B10G10R10A2_UNORM is only allowed in fullscreen mode and it
4150 * can only be mixed with backbuffer format WINED3DFMT_B10G10R10A2_UNORM. */
4151 if (display_format == WINED3DFMT_B10G10R10A2_UNORM
4152 && (backbuffer_format != WINED3DFMT_B10G10R10A2_UNORM || windowed))
4154 TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s / %s.\n",
4155 debug_d3dformat(display_format), debug_d3dformat(backbuffer_format));
4156 return WINED3DERR_NOTAVAILABLE;
4159 /* Use CheckDeviceFormat to see if the backbuffer_format is usable with the given display_format */
4160 hr = IWineD3DImpl_CheckDeviceFormat(iface, adapter_idx, device_type, display_format,
4161 WINED3DUSAGE_RENDERTARGET, WINED3DRTYPE_SURFACE, backbuffer_format, SURFACE_OPENGL);
4163 TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s / %s.\n",
4164 debug_d3dformat(display_format), debug_d3dformat(backbuffer_format));
4169 /* Note: d3d8 passes in a pointer to a D3DCAPS8 structure, which is a true
4170 subset of a D3DCAPS9 structure. However, it has to come via a void *
4171 as the d3d8 interface cannot import the d3d9 header */
4172 static HRESULT WINAPI IWineD3DImpl_GetDeviceCaps(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType, WINED3DCAPS* pCaps) {
4174 IWineD3DImpl *This = (IWineD3DImpl *)iface;
4175 struct wined3d_adapter *adapter = &This->adapters[Adapter];
4176 const struct wined3d_gl_info *gl_info = &adapter->gl_info;
4177 int vs_selected_mode;
4178 int ps_selected_mode;
4179 struct shader_caps shader_caps;
4180 struct fragment_caps fragment_caps;
4181 DWORD ckey_caps, blit_caps, fx_caps, pal_caps;
4183 TRACE_(d3d_caps)("(%p)->(Adptr:%d, DevType: %x, pCaps: %p)\n", This, Adapter, DeviceType, pCaps);
4185 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
4186 return WINED3DERR_INVALIDCALL;
4189 select_shader_mode(&adapter->gl_info, &ps_selected_mode, &vs_selected_mode);
4191 /* ------------------------------------------------
4192 The following fields apply to both d3d8 and d3d9
4193 ------------------------------------------------ */
4194 pCaps->DeviceType = (DeviceType == WINED3DDEVTYPE_HAL) ? WINED3DDEVTYPE_HAL : WINED3DDEVTYPE_REF; /* Not quite true, but use h/w supported by opengl I suppose */
4195 pCaps->AdapterOrdinal = Adapter;
4198 pCaps->Caps2 = WINED3DCAPS2_CANRENDERWINDOWED |
4199 WINED3DCAPS2_FULLSCREENGAMMA |
4200 WINED3DCAPS2_DYNAMICTEXTURES;
4201 if (gl_info->supported[SGIS_GENERATE_MIPMAP])
4203 pCaps->Caps2 |= WINED3DCAPS2_CANAUTOGENMIPMAP;
4206 pCaps->Caps3 = WINED3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD |
4207 WINED3DCAPS3_COPY_TO_VIDMEM |
4208 WINED3DCAPS3_COPY_TO_SYSTEMMEM;
4210 pCaps->PresentationIntervals = WINED3DPRESENT_INTERVAL_IMMEDIATE |
4211 WINED3DPRESENT_INTERVAL_ONE;
4213 pCaps->CursorCaps = WINED3DCURSORCAPS_COLOR |
4214 WINED3DCURSORCAPS_LOWRES;
4216 pCaps->DevCaps = WINED3DDEVCAPS_FLOATTLVERTEX |
4217 WINED3DDEVCAPS_EXECUTESYSTEMMEMORY |
4218 WINED3DDEVCAPS_TLVERTEXSYSTEMMEMORY|
4219 WINED3DDEVCAPS_TLVERTEXVIDEOMEMORY |
4220 WINED3DDEVCAPS_DRAWPRIMTLVERTEX |
4221 WINED3DDEVCAPS_HWTRANSFORMANDLIGHT |
4222 WINED3DDEVCAPS_EXECUTEVIDEOMEMORY |
4223 WINED3DDEVCAPS_PUREDEVICE |
4224 WINED3DDEVCAPS_HWRASTERIZATION |
4225 WINED3DDEVCAPS_TEXTUREVIDEOMEMORY |
4226 WINED3DDEVCAPS_TEXTURESYSTEMMEMORY |
4227 WINED3DDEVCAPS_CANRENDERAFTERFLIP |
4228 WINED3DDEVCAPS_DRAWPRIMITIVES2 |
4229 WINED3DDEVCAPS_DRAWPRIMITIVES2EX |
4230 WINED3DDEVCAPS_RTPATCHES;
4232 pCaps->PrimitiveMiscCaps = WINED3DPMISCCAPS_CULLNONE |
4233 WINED3DPMISCCAPS_CULLCCW |
4234 WINED3DPMISCCAPS_CULLCW |
4235 WINED3DPMISCCAPS_COLORWRITEENABLE |
4236 WINED3DPMISCCAPS_CLIPTLVERTS |
4237 WINED3DPMISCCAPS_CLIPPLANESCALEDPOINTS |
4238 WINED3DPMISCCAPS_MASKZ |
4239 WINED3DPMISCCAPS_BLENDOP |
4240 WINED3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING;
4242 WINED3DPMISCCAPS_NULLREFERENCE
4243 WINED3DPMISCCAPS_FOGANDSPECULARALPHA
4244 WINED3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS
4245 WINED3DPMISCCAPS_FOGVERTEXCLAMPED */
4247 if (gl_info->supported[EXT_BLEND_EQUATION_SEPARATE] && gl_info->supported[EXT_BLEND_FUNC_SEPARATE])
4248 pCaps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_SEPARATEALPHABLEND;
4249 if (gl_info->supported[EXT_DRAW_BUFFERS2])
4250 pCaps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_INDEPENDENTWRITEMASKS;
4252 pCaps->RasterCaps = WINED3DPRASTERCAPS_DITHER |
4253 WINED3DPRASTERCAPS_PAT |
4254 WINED3DPRASTERCAPS_WFOG |
4255 WINED3DPRASTERCAPS_ZFOG |
4256 WINED3DPRASTERCAPS_FOGVERTEX |
4257 WINED3DPRASTERCAPS_FOGTABLE |
4258 WINED3DPRASTERCAPS_STIPPLE |
4259 WINED3DPRASTERCAPS_SUBPIXEL |
4260 WINED3DPRASTERCAPS_ZTEST |
4261 WINED3DPRASTERCAPS_SCISSORTEST |
4262 WINED3DPRASTERCAPS_SLOPESCALEDEPTHBIAS |
4263 WINED3DPRASTERCAPS_DEPTHBIAS;
4265 if (gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC])
4267 pCaps->RasterCaps |= WINED3DPRASTERCAPS_ANISOTROPY |
4268 WINED3DPRASTERCAPS_ZBIAS |
4269 WINED3DPRASTERCAPS_MIPMAPLODBIAS;
4271 if (gl_info->supported[NV_FOG_DISTANCE])
4273 pCaps->RasterCaps |= WINED3DPRASTERCAPS_FOGRANGE;
4276 WINED3DPRASTERCAPS_COLORPERSPECTIVE
4277 WINED3DPRASTERCAPS_STRETCHBLTMULTISAMPLE
4278 WINED3DPRASTERCAPS_ANTIALIASEDGES
4279 WINED3DPRASTERCAPS_ZBUFFERLESSHSR
4280 WINED3DPRASTERCAPS_WBUFFER */
4282 pCaps->ZCmpCaps = WINED3DPCMPCAPS_ALWAYS |
4283 WINED3DPCMPCAPS_EQUAL |
4284 WINED3DPCMPCAPS_GREATER |
4285 WINED3DPCMPCAPS_GREATEREQUAL |
4286 WINED3DPCMPCAPS_LESS |
4287 WINED3DPCMPCAPS_LESSEQUAL |
4288 WINED3DPCMPCAPS_NEVER |
4289 WINED3DPCMPCAPS_NOTEQUAL;
4291 pCaps->SrcBlendCaps = WINED3DPBLENDCAPS_BOTHINVSRCALPHA |
4292 WINED3DPBLENDCAPS_BOTHSRCALPHA |
4293 WINED3DPBLENDCAPS_DESTALPHA |
4294 WINED3DPBLENDCAPS_DESTCOLOR |
4295 WINED3DPBLENDCAPS_INVDESTALPHA |
4296 WINED3DPBLENDCAPS_INVDESTCOLOR |
4297 WINED3DPBLENDCAPS_INVSRCALPHA |
4298 WINED3DPBLENDCAPS_INVSRCCOLOR |
4299 WINED3DPBLENDCAPS_ONE |
4300 WINED3DPBLENDCAPS_SRCALPHA |
4301 WINED3DPBLENDCAPS_SRCALPHASAT |
4302 WINED3DPBLENDCAPS_SRCCOLOR |
4303 WINED3DPBLENDCAPS_ZERO;
4305 pCaps->DestBlendCaps = WINED3DPBLENDCAPS_DESTALPHA |
4306 WINED3DPBLENDCAPS_DESTCOLOR |
4307 WINED3DPBLENDCAPS_INVDESTALPHA |
4308 WINED3DPBLENDCAPS_INVDESTCOLOR |
4309 WINED3DPBLENDCAPS_INVSRCALPHA |
4310 WINED3DPBLENDCAPS_INVSRCCOLOR |
4311 WINED3DPBLENDCAPS_ONE |
4312 WINED3DPBLENDCAPS_SRCALPHA |
4313 WINED3DPBLENDCAPS_SRCCOLOR |
4314 WINED3DPBLENDCAPS_ZERO;
4315 /* NOTE: WINED3DPBLENDCAPS_SRCALPHASAT is not supported as dest blend factor,
4316 * according to the glBlendFunc manpage
4318 * WINED3DPBLENDCAPS_BOTHINVSRCALPHA and WINED3DPBLENDCAPS_BOTHSRCALPHA are
4319 * legacy settings for srcblend only
4322 if (gl_info->supported[EXT_BLEND_COLOR])
4324 pCaps->SrcBlendCaps |= WINED3DPBLENDCAPS_BLENDFACTOR;
4325 pCaps->DestBlendCaps |= WINED3DPBLENDCAPS_BLENDFACTOR;
4329 pCaps->AlphaCmpCaps = WINED3DPCMPCAPS_ALWAYS |
4330 WINED3DPCMPCAPS_EQUAL |
4331 WINED3DPCMPCAPS_GREATER |
4332 WINED3DPCMPCAPS_GREATEREQUAL |
4333 WINED3DPCMPCAPS_LESS |
4334 WINED3DPCMPCAPS_LESSEQUAL |
4335 WINED3DPCMPCAPS_NEVER |
4336 WINED3DPCMPCAPS_NOTEQUAL;
4338 pCaps->ShadeCaps = WINED3DPSHADECAPS_SPECULARGOURAUDRGB |
4339 WINED3DPSHADECAPS_COLORGOURAUDRGB |
4340 WINED3DPSHADECAPS_ALPHAFLATBLEND |
4341 WINED3DPSHADECAPS_ALPHAGOURAUDBLEND |
4342 WINED3DPSHADECAPS_COLORFLATRGB |
4343 WINED3DPSHADECAPS_FOGFLAT |
4344 WINED3DPSHADECAPS_FOGGOURAUD |
4345 WINED3DPSHADECAPS_SPECULARFLATRGB;
4347 pCaps->TextureCaps = WINED3DPTEXTURECAPS_ALPHA |
4348 WINED3DPTEXTURECAPS_ALPHAPALETTE |
4349 WINED3DPTEXTURECAPS_TRANSPARENCY |
4350 WINED3DPTEXTURECAPS_BORDER |
4351 WINED3DPTEXTURECAPS_MIPMAP |
4352 WINED3DPTEXTURECAPS_PROJECTED |
4353 WINED3DPTEXTURECAPS_PERSPECTIVE;
4355 if (!gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO])
4357 pCaps->TextureCaps |= WINED3DPTEXTURECAPS_POW2 |
4358 WINED3DPTEXTURECAPS_NONPOW2CONDITIONAL;
4361 if (gl_info->supported[EXT_TEXTURE3D])
4363 pCaps->TextureCaps |= WINED3DPTEXTURECAPS_VOLUMEMAP |
4364 WINED3DPTEXTURECAPS_MIPVOLUMEMAP |
4365 WINED3DPTEXTURECAPS_VOLUMEMAP_POW2;
4368 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
4370 pCaps->TextureCaps |= WINED3DPTEXTURECAPS_CUBEMAP |
4371 WINED3DPTEXTURECAPS_MIPCUBEMAP |
4372 WINED3DPTEXTURECAPS_CUBEMAP_POW2;
4376 pCaps->TextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR |
4377 WINED3DPTFILTERCAPS_MAGFPOINT |
4378 WINED3DPTFILTERCAPS_MINFLINEAR |
4379 WINED3DPTFILTERCAPS_MINFPOINT |
4380 WINED3DPTFILTERCAPS_MIPFLINEAR |
4381 WINED3DPTFILTERCAPS_MIPFPOINT |
4382 WINED3DPTFILTERCAPS_LINEAR |
4383 WINED3DPTFILTERCAPS_LINEARMIPLINEAR |
4384 WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
4385 WINED3DPTFILTERCAPS_MIPLINEAR |
4386 WINED3DPTFILTERCAPS_MIPNEAREST |
4387 WINED3DPTFILTERCAPS_NEAREST;
4389 if (gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC])
4391 pCaps->TextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC |
4392 WINED3DPTFILTERCAPS_MINFANISOTROPIC;
4395 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
4397 pCaps->CubeTextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR |
4398 WINED3DPTFILTERCAPS_MAGFPOINT |
4399 WINED3DPTFILTERCAPS_MINFLINEAR |
4400 WINED3DPTFILTERCAPS_MINFPOINT |
4401 WINED3DPTFILTERCAPS_MIPFLINEAR |
4402 WINED3DPTFILTERCAPS_MIPFPOINT |
4403 WINED3DPTFILTERCAPS_LINEAR |
4404 WINED3DPTFILTERCAPS_LINEARMIPLINEAR |
4405 WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
4406 WINED3DPTFILTERCAPS_MIPLINEAR |
4407 WINED3DPTFILTERCAPS_MIPNEAREST |
4408 WINED3DPTFILTERCAPS_NEAREST;
4410 if (gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC])
4412 pCaps->CubeTextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC |
4413 WINED3DPTFILTERCAPS_MINFANISOTROPIC;
4416 pCaps->CubeTextureFilterCaps = 0;
4418 if (gl_info->supported[EXT_TEXTURE3D])
4420 pCaps->VolumeTextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR |
4421 WINED3DPTFILTERCAPS_MAGFPOINT |
4422 WINED3DPTFILTERCAPS_MINFLINEAR |
4423 WINED3DPTFILTERCAPS_MINFPOINT |
4424 WINED3DPTFILTERCAPS_MIPFLINEAR |
4425 WINED3DPTFILTERCAPS_MIPFPOINT |
4426 WINED3DPTFILTERCAPS_LINEAR |
4427 WINED3DPTFILTERCAPS_LINEARMIPLINEAR |
4428 WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
4429 WINED3DPTFILTERCAPS_MIPLINEAR |
4430 WINED3DPTFILTERCAPS_MIPNEAREST |
4431 WINED3DPTFILTERCAPS_NEAREST;
4433 pCaps->VolumeTextureFilterCaps = 0;
4435 pCaps->TextureAddressCaps = WINED3DPTADDRESSCAPS_INDEPENDENTUV |
4436 WINED3DPTADDRESSCAPS_CLAMP |
4437 WINED3DPTADDRESSCAPS_WRAP;
4439 if (gl_info->supported[ARB_TEXTURE_BORDER_CLAMP])
4441 pCaps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_BORDER;
4443 if (gl_info->supported[ARB_TEXTURE_MIRRORED_REPEAT])
4445 pCaps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRROR;
4447 if (gl_info->supported[ATI_TEXTURE_MIRROR_ONCE])
4449 pCaps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRRORONCE;
4452 if (gl_info->supported[EXT_TEXTURE3D])
4454 pCaps->VolumeTextureAddressCaps = WINED3DPTADDRESSCAPS_INDEPENDENTUV |
4455 WINED3DPTADDRESSCAPS_CLAMP |
4456 WINED3DPTADDRESSCAPS_WRAP;
4457 if (gl_info->supported[ARB_TEXTURE_BORDER_CLAMP])
4459 pCaps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_BORDER;
4461 if (gl_info->supported[ARB_TEXTURE_MIRRORED_REPEAT])
4463 pCaps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRROR;
4465 if (gl_info->supported[ATI_TEXTURE_MIRROR_ONCE])
4467 pCaps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRRORONCE;
4470 pCaps->VolumeTextureAddressCaps = 0;
4472 pCaps->LineCaps = WINED3DLINECAPS_TEXTURE |
4473 WINED3DLINECAPS_ZTEST |
4474 WINED3DLINECAPS_BLEND |
4475 WINED3DLINECAPS_ALPHACMP |
4476 WINED3DLINECAPS_FOG;
4477 /* WINED3DLINECAPS_ANTIALIAS is not supported on Windows, and dx and gl seem to have a different
4478 * idea how generating the smoothing alpha values works; the result is different
4481 pCaps->MaxTextureWidth = gl_info->limits.texture_size;
4482 pCaps->MaxTextureHeight = gl_info->limits.texture_size;
4484 if (gl_info->supported[EXT_TEXTURE3D])
4485 pCaps->MaxVolumeExtent = gl_info->limits.texture3d_size;
4487 pCaps->MaxVolumeExtent = 0;
4489 pCaps->MaxTextureRepeat = 32768;
4490 pCaps->MaxTextureAspectRatio = gl_info->limits.texture_size;
4491 pCaps->MaxVertexW = 1.0f;
4493 pCaps->GuardBandLeft = 0.0f;
4494 pCaps->GuardBandTop = 0.0f;
4495 pCaps->GuardBandRight = 0.0f;
4496 pCaps->GuardBandBottom = 0.0f;
4498 pCaps->ExtentsAdjust = 0.0f;
4500 pCaps->StencilCaps = WINED3DSTENCILCAPS_DECRSAT |
4501 WINED3DSTENCILCAPS_INCRSAT |
4502 WINED3DSTENCILCAPS_INVERT |
4503 WINED3DSTENCILCAPS_KEEP |
4504 WINED3DSTENCILCAPS_REPLACE |
4505 WINED3DSTENCILCAPS_ZERO;
4506 if (gl_info->supported[EXT_STENCIL_WRAP])
4508 pCaps->StencilCaps |= WINED3DSTENCILCAPS_DECR |
4509 WINED3DSTENCILCAPS_INCR;
4511 if (gl_info->supported[EXT_STENCIL_TWO_SIDE] || gl_info->supported[ATI_SEPARATE_STENCIL])
4513 pCaps->StencilCaps |= WINED3DSTENCILCAPS_TWOSIDED;
4516 pCaps->FVFCaps = WINED3DFVFCAPS_PSIZE | 0x0008; /* 8 texture coords */
4518 pCaps->MaxUserClipPlanes = gl_info->limits.clipplanes;
4519 pCaps->MaxActiveLights = gl_info->limits.lights;
4521 pCaps->MaxVertexBlendMatrices = gl_info->limits.blends;
4522 pCaps->MaxVertexBlendMatrixIndex = 0;
4524 pCaps->MaxAnisotropy = gl_info->limits.anisotropy;
4525 pCaps->MaxPointSize = gl_info->limits.pointsize_max;
4528 /* FIXME: Add D3DVTXPCAPS_TWEENING, D3DVTXPCAPS_TEXGEN_SPHEREMAP */
4529 pCaps->VertexProcessingCaps = WINED3DVTXPCAPS_DIRECTIONALLIGHTS |
4530 WINED3DVTXPCAPS_MATERIALSOURCE7 |
4531 WINED3DVTXPCAPS_POSITIONALLIGHTS |
4532 WINED3DVTXPCAPS_LOCALVIEWER |
4533 WINED3DVTXPCAPS_VERTEXFOG |
4534 WINED3DVTXPCAPS_TEXGEN;
4536 pCaps->MaxPrimitiveCount = 0xFFFFF; /* For now set 2^20-1 which is used by most >=Geforce3/Radeon8500 cards */
4537 pCaps->MaxVertexIndex = 0xFFFFF;
4538 pCaps->MaxStreams = MAX_STREAMS;
4539 pCaps->MaxStreamStride = 1024;
4541 /* d3d9.dll sets D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES here because StretchRects is implemented in d3d9 */
4542 pCaps->DevCaps2 = WINED3DDEVCAPS2_STREAMOFFSET |
4543 WINED3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET;
4544 pCaps->MaxNpatchTessellationLevel = 0;
4545 pCaps->MasterAdapterOrdinal = 0;
4546 pCaps->AdapterOrdinalInGroup = 0;
4547 pCaps->NumberOfAdaptersInGroup = 1;
4549 pCaps->NumSimultaneousRTs = gl_info->limits.buffers;
4551 pCaps->StretchRectFilterCaps = WINED3DPTFILTERCAPS_MINFPOINT |
4552 WINED3DPTFILTERCAPS_MAGFPOINT |
4553 WINED3DPTFILTERCAPS_MINFLINEAR |
4554 WINED3DPTFILTERCAPS_MAGFLINEAR;
4555 pCaps->VertexTextureFilterCaps = 0;
4557 adapter->shader_backend->shader_get_caps(&adapter->gl_info, &shader_caps);
4558 adapter->fragment_pipe->get_caps(&adapter->gl_info, &fragment_caps);
4560 /* Add shader misc caps. Only some of them belong to the shader parts of the pipeline */
4561 pCaps->PrimitiveMiscCaps |= fragment_caps.PrimitiveMiscCaps;
4563 /* This takes care for disabling vertex shader or pixel shader caps while leaving the other one enabled.
4564 * Ignore shader model capabilities if disabled in config
4566 if(vs_selected_mode == SHADER_NONE) {
4567 TRACE_(d3d_caps)("Vertex shader disabled in config, reporting version 0.0\n");
4568 pCaps->VertexShaderVersion = WINED3DVS_VERSION(0,0);
4569 pCaps->MaxVertexShaderConst = 0;
4571 pCaps->VertexShaderVersion = shader_caps.VertexShaderVersion;
4572 pCaps->MaxVertexShaderConst = shader_caps.MaxVertexShaderConst;
4575 if(ps_selected_mode == SHADER_NONE) {
4576 TRACE_(d3d_caps)("Pixel shader disabled in config, reporting version 0.0\n");
4577 pCaps->PixelShaderVersion = WINED3DPS_VERSION(0,0);
4578 pCaps->PixelShader1xMaxValue = 0.0f;
4580 pCaps->PixelShaderVersion = shader_caps.PixelShaderVersion;
4581 pCaps->PixelShader1xMaxValue = shader_caps.PixelShader1xMaxValue;
4584 pCaps->TextureOpCaps = fragment_caps.TextureOpCaps;
4585 pCaps->MaxTextureBlendStages = fragment_caps.MaxTextureBlendStages;
4586 pCaps->MaxSimultaneousTextures = fragment_caps.MaxSimultaneousTextures;
4588 /* The following caps are shader specific, but they are things we cannot detect, or which
4589 * are the same among all shader models. So to avoid code duplication set the shader version
4590 * specific, but otherwise constant caps here
4592 if(pCaps->VertexShaderVersion == WINED3DVS_VERSION(3,0)) {
4593 /* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering)
4594 use the VS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum VS3.0 value. */
4595 pCaps->VS20Caps.Caps = WINED3DVS20CAPS_PREDICATION;
4596 pCaps->VS20Caps.DynamicFlowControlDepth = WINED3DVS20_MAX_DYNAMICFLOWCONTROLDEPTH; /* VS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
4597 pCaps->VS20Caps.NumTemps = max(32, adapter->gl_info.limits.arb_vs_temps);
4598 pCaps->VS20Caps.StaticFlowControlDepth = WINED3DVS20_MAX_STATICFLOWCONTROLDEPTH ; /* level of nesting in loops / if-statements; VS 3.0 requires MAX (4) */
4600 pCaps->MaxVShaderInstructionsExecuted = 65535; /* VS 3.0 needs at least 65535, some cards even use 2^32-1 */
4601 pCaps->MaxVertexShader30InstructionSlots = max(512, adapter->gl_info.limits.arb_vs_instructions);
4603 else if (pCaps->VertexShaderVersion == WINED3DVS_VERSION(2,0))
4605 pCaps->VS20Caps.Caps = 0;
4606 pCaps->VS20Caps.DynamicFlowControlDepth = WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH;
4607 pCaps->VS20Caps.NumTemps = max(12, adapter->gl_info.limits.arb_vs_temps);
4608 pCaps->VS20Caps.StaticFlowControlDepth = 1;
4610 pCaps->MaxVShaderInstructionsExecuted = 65535;
4611 pCaps->MaxVertexShader30InstructionSlots = 0;
4612 } else { /* VS 1.x */
4613 pCaps->VS20Caps.Caps = 0;
4614 pCaps->VS20Caps.DynamicFlowControlDepth = 0;
4615 pCaps->VS20Caps.NumTemps = 0;
4616 pCaps->VS20Caps.StaticFlowControlDepth = 0;
4618 pCaps->MaxVShaderInstructionsExecuted = 0;
4619 pCaps->MaxVertexShader30InstructionSlots = 0;
4622 if(pCaps->PixelShaderVersion == WINED3DPS_VERSION(3,0)) {
4623 /* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering)
4624 use the PS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum PS 3.0 value. */
4626 /* Caps is more or less undocumented on MSDN but it appears to be used for PS20Caps based on results from R9600/FX5900/Geforce6800 cards from Windows */
4627 pCaps->PS20Caps.Caps = WINED3DPS20CAPS_ARBITRARYSWIZZLE |
4628 WINED3DPS20CAPS_GRADIENTINSTRUCTIONS |
4629 WINED3DPS20CAPS_PREDICATION |
4630 WINED3DPS20CAPS_NODEPENDENTREADLIMIT |
4631 WINED3DPS20CAPS_NOTEXINSTRUCTIONLIMIT;
4632 pCaps->PS20Caps.DynamicFlowControlDepth = WINED3DPS20_MAX_DYNAMICFLOWCONTROLDEPTH; /* PS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
4633 pCaps->PS20Caps.NumTemps = max(32, adapter->gl_info.limits.arb_ps_temps);
4634 pCaps->PS20Caps.StaticFlowControlDepth = WINED3DPS20_MAX_STATICFLOWCONTROLDEPTH; /* PS 3.0 requires MAX_STATICFLOWCONTROLDEPTH (4) */
4635 pCaps->PS20Caps.NumInstructionSlots = WINED3DPS20_MAX_NUMINSTRUCTIONSLOTS; /* PS 3.0 requires MAX_NUMINSTRUCTIONSLOTS (512) */
4637 pCaps->MaxPShaderInstructionsExecuted = 65535;
4638 pCaps->MaxPixelShader30InstructionSlots = max(WINED3DMIN30SHADERINSTRUCTIONS,
4639 adapter->gl_info.limits.arb_ps_instructions);
4641 else if(pCaps->PixelShaderVersion == WINED3DPS_VERSION(2,0))
4643 /* Below we assume PS2.0 specs, not extended 2.0a(GeforceFX)/2.0b(Radeon R3xx) ones */
4644 pCaps->PS20Caps.Caps = 0;
4645 pCaps->PS20Caps.DynamicFlowControlDepth = 0; /* WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH = 0 */
4646 pCaps->PS20Caps.NumTemps = max(12, adapter->gl_info.limits.arb_ps_temps);
4647 pCaps->PS20Caps.StaticFlowControlDepth = WINED3DPS20_MIN_STATICFLOWCONTROLDEPTH; /* Minimum: 1 */
4648 pCaps->PS20Caps.NumInstructionSlots = WINED3DPS20_MIN_NUMINSTRUCTIONSLOTS; /* Minimum number (64 ALU + 32 Texture), a GeforceFX uses 512 */
4650 pCaps->MaxPShaderInstructionsExecuted = 512; /* Minimum value, a GeforceFX uses 1024 */
4651 pCaps->MaxPixelShader30InstructionSlots = 0;
4652 } else { /* PS 1.x */
4653 pCaps->PS20Caps.Caps = 0;
4654 pCaps->PS20Caps.DynamicFlowControlDepth = 0;
4655 pCaps->PS20Caps.NumTemps = 0;
4656 pCaps->PS20Caps.StaticFlowControlDepth = 0;
4657 pCaps->PS20Caps.NumInstructionSlots = 0;
4659 pCaps->MaxPShaderInstructionsExecuted = 0;
4660 pCaps->MaxPixelShader30InstructionSlots = 0;
4663 if(pCaps->VertexShaderVersion >= WINED3DVS_VERSION(2,0)) {
4664 /* OpenGL supports all the formats below, perhaps not always
4665 * without conversion, but it supports them.
4666 * Further GLSL doesn't seem to have an official unsigned type so
4667 * don't advertise it yet as I'm not sure how we handle it.
4668 * We might need to add some clamping in the shader engine to
4670 * TODO: WINED3DDTCAPS_USHORT2N, WINED3DDTCAPS_USHORT4N, WINED3DDTCAPS_UDEC3, WINED3DDTCAPS_DEC3N */
4671 pCaps->DeclTypes = WINED3DDTCAPS_UBYTE4 |
4672 WINED3DDTCAPS_UBYTE4N |
4673 WINED3DDTCAPS_SHORT2N |
4674 WINED3DDTCAPS_SHORT4N;
4675 if (gl_info->supported[ARB_HALF_FLOAT_VERTEX])
4677 pCaps->DeclTypes |= WINED3DDTCAPS_FLOAT16_2 |
4678 WINED3DDTCAPS_FLOAT16_4;
4681 pCaps->DeclTypes = 0;
4683 /* Set DirectDraw helper Caps */
4684 ckey_caps = WINEDDCKEYCAPS_DESTBLT |
4685 WINEDDCKEYCAPS_SRCBLT;
4686 fx_caps = WINEDDFXCAPS_BLTALPHA |
4687 WINEDDFXCAPS_BLTMIRRORLEFTRIGHT |
4688 WINEDDFXCAPS_BLTMIRRORUPDOWN |
4689 WINEDDFXCAPS_BLTROTATION90 |
4690 WINEDDFXCAPS_BLTSHRINKX |
4691 WINEDDFXCAPS_BLTSHRINKXN |
4692 WINEDDFXCAPS_BLTSHRINKY |
4693 WINEDDFXCAPS_BLTSHRINKXN |
4694 WINEDDFXCAPS_BLTSTRETCHX |
4695 WINEDDFXCAPS_BLTSTRETCHXN |
4696 WINEDDFXCAPS_BLTSTRETCHY |
4697 WINEDDFXCAPS_BLTSTRETCHYN;
4698 blit_caps = WINEDDCAPS_BLT |
4699 WINEDDCAPS_BLTCOLORFILL |
4700 WINEDDCAPS_BLTDEPTHFILL |
4701 WINEDDCAPS_BLTSTRETCH |
4702 WINEDDCAPS_CANBLTSYSMEM |
4703 WINEDDCAPS_CANCLIP |
4704 WINEDDCAPS_CANCLIPSTRETCHED |
4705 WINEDDCAPS_COLORKEY |
4706 WINEDDCAPS_COLORKEYHWASSIST |
4707 WINEDDCAPS_ALIGNBOUNDARYSRC;
4708 pal_caps = WINEDDPCAPS_8BIT |
4709 WINEDDPCAPS_PRIMARYSURFACE;
4711 /* Fill the ddraw caps structure */
4712 pCaps->DirectDrawCaps.Caps = WINEDDCAPS_GDI |
4713 WINEDDCAPS_PALETTE |
4715 pCaps->DirectDrawCaps.Caps2 = WINEDDCAPS2_CERTIFIED |
4716 WINEDDCAPS2_NOPAGELOCKREQUIRED |
4717 WINEDDCAPS2_PRIMARYGAMMA |
4718 WINEDDCAPS2_WIDESURFACES |
4719 WINEDDCAPS2_CANRENDERWINDOWED;
4720 pCaps->DirectDrawCaps.CKeyCaps = ckey_caps;
4721 pCaps->DirectDrawCaps.FXCaps = fx_caps;
4722 pCaps->DirectDrawCaps.PalCaps = pal_caps;
4723 pCaps->DirectDrawCaps.SVBCaps = blit_caps;
4724 pCaps->DirectDrawCaps.SVBCKeyCaps = ckey_caps;
4725 pCaps->DirectDrawCaps.SVBFXCaps = fx_caps;
4726 pCaps->DirectDrawCaps.VSBCaps = blit_caps;
4727 pCaps->DirectDrawCaps.VSBCKeyCaps = ckey_caps;
4728 pCaps->DirectDrawCaps.VSBFXCaps = fx_caps;
4729 pCaps->DirectDrawCaps.SSBCaps = blit_caps;
4730 pCaps->DirectDrawCaps.SSBCKeyCaps = ckey_caps;
4731 pCaps->DirectDrawCaps.SSBFXCaps = fx_caps;
4733 pCaps->DirectDrawCaps.ddsCaps = WINEDDSCAPS_ALPHA |
4734 WINEDDSCAPS_BACKBUFFER |
4736 WINEDDSCAPS_FRONTBUFFER |
4737 WINEDDSCAPS_OFFSCREENPLAIN |
4738 WINEDDSCAPS_PALETTE |
4739 WINEDDSCAPS_PRIMARYSURFACE |
4740 WINEDDSCAPS_SYSTEMMEMORY |
4741 WINEDDSCAPS_VIDEOMEMORY |
4742 WINEDDSCAPS_VISIBLE;
4743 pCaps->DirectDrawCaps.StrideAlign = DDRAW_PITCH_ALIGNMENT;
4745 /* Set D3D caps if OpenGL is available. */
4746 if (adapter->opengl)
4748 pCaps->DirectDrawCaps.ddsCaps |=WINEDDSCAPS_3DDEVICE |
4749 WINEDDSCAPS_MIPMAP |
4750 WINEDDSCAPS_TEXTURE |
4751 WINEDDSCAPS_ZBUFFER;
4752 pCaps->DirectDrawCaps.Caps |= WINEDDCAPS_3D;
4758 static HRESULT WINAPI IWineD3DImpl_CreateDevice(IWineD3D *iface, UINT adapter_idx, WINED3DDEVTYPE device_type,
4759 HWND focus_window, DWORD flags, IWineD3DDeviceParent *device_parent, IWineD3DDevice **device)
4761 IWineD3DImpl *This = (IWineD3DImpl *)iface;
4762 IWineD3DDeviceImpl *object;
4765 TRACE("iface %p, adapter_idx %u, device_type %#x, focus_window %p, flags %#x, device_parent %p, device %p.\n",
4766 iface, adapter_idx, device_type, focus_window, flags, device_parent, device);
4768 /* Validate the adapter number. If no adapters are available(no GL), ignore the adapter
4769 * number and create a device without a 3D adapter for 2D only operation. */
4770 if (IWineD3D_GetAdapterCount(iface) && adapter_idx >= IWineD3D_GetAdapterCount(iface))
4772 return WINED3DERR_INVALIDCALL;
4775 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
4778 ERR("Failed to allocate device memory.\n");
4779 return E_OUTOFMEMORY;
4782 hr = device_init(object, This, adapter_idx, device_type, focus_window, flags, device_parent);
4785 WARN("Failed to initialize device, hr %#x.\n", hr);
4786 HeapFree(GetProcessHeap(), 0, object);
4790 TRACE("Created device %p.\n", object);
4791 *device = (IWineD3DDevice *)object;
4793 IWineD3DDeviceParent_WineD3DDeviceCreated(device_parent, *device);
4798 static void * WINAPI IWineD3DImpl_GetParent(IWineD3D *iface)
4800 TRACE("iface %p.\n", iface);
4802 return ((IWineD3DImpl *)iface)->parent;
4805 static void WINE_GLAPI invalid_func(const void *data)
4807 ERR("Invalid vertex attribute function called\n");
4811 static void WINE_GLAPI invalid_texcoord_func(GLenum unit, const void *data)
4813 ERR("Invalid texcoord function called\n");
4817 /* Helper functions for providing vertex data to opengl. The arrays are initialized based on
4818 * the extension detection and are used in drawStridedSlow
4820 static void WINE_GLAPI position_d3dcolor(const void *data)
4822 DWORD pos = *((const DWORD *)data);
4824 FIXME("Add a test for fixed function position from d3dcolor type\n");
4825 glVertex4s(D3DCOLOR_B_R(pos),
4831 static void WINE_GLAPI position_float4(const void *data)
4833 const GLfloat *pos = data;
4835 if (pos[3] != 0.0f && pos[3] != 1.0f)
4837 float w = 1.0f / pos[3];
4839 glVertex4f(pos[0] * w, pos[1] * w, pos[2] * w, w);
4847 static void WINE_GLAPI diffuse_d3dcolor(const void *data)
4849 DWORD diffuseColor = *((const DWORD *)data);
4851 glColor4ub(D3DCOLOR_B_R(diffuseColor),
4852 D3DCOLOR_B_G(diffuseColor),
4853 D3DCOLOR_B_B(diffuseColor),
4854 D3DCOLOR_B_A(diffuseColor));
4857 static void WINE_GLAPI specular_d3dcolor(const void *data)
4859 DWORD specularColor = *((const DWORD *)data);
4860 GLbyte d[] = {D3DCOLOR_B_R(specularColor),
4861 D3DCOLOR_B_G(specularColor),
4862 D3DCOLOR_B_B(specularColor)};
4864 specular_func_3ubv(d);
4867 static void WINE_GLAPI warn_no_specular_func(const void *data)
4869 WARN("GL_EXT_secondary_color not supported\n");
4872 static void fillGLAttribFuncs(const struct wined3d_gl_info *gl_info)
4874 position_funcs[WINED3D_FFP_EMIT_FLOAT1] = invalid_func;
4875 position_funcs[WINED3D_FFP_EMIT_FLOAT2] = invalid_func;
4876 position_funcs[WINED3D_FFP_EMIT_FLOAT3] = (glAttribFunc)glVertex3fv;
4877 position_funcs[WINED3D_FFP_EMIT_FLOAT4] = position_float4;
4878 position_funcs[WINED3D_FFP_EMIT_D3DCOLOR] = position_d3dcolor;
4879 position_funcs[WINED3D_FFP_EMIT_UBYTE4] = invalid_func;
4880 position_funcs[WINED3D_FFP_EMIT_SHORT2] = invalid_func;
4881 position_funcs[WINED3D_FFP_EMIT_SHORT4] = (glAttribFunc)glVertex2sv;
4882 position_funcs[WINED3D_FFP_EMIT_UBYTE4N] = invalid_func;
4883 position_funcs[WINED3D_FFP_EMIT_SHORT2N] = invalid_func;
4884 position_funcs[WINED3D_FFP_EMIT_SHORT4N] = invalid_func;
4885 position_funcs[WINED3D_FFP_EMIT_USHORT2N] = invalid_func;
4886 position_funcs[WINED3D_FFP_EMIT_USHORT4N] = invalid_func;
4887 position_funcs[WINED3D_FFP_EMIT_UDEC3] = invalid_func;
4888 position_funcs[WINED3D_FFP_EMIT_DEC3N] = invalid_func;
4889 position_funcs[WINED3D_FFP_EMIT_FLOAT16_2] = invalid_func;
4890 position_funcs[WINED3D_FFP_EMIT_FLOAT16_4] = invalid_func;
4892 diffuse_funcs[WINED3D_FFP_EMIT_FLOAT1] = invalid_func;
4893 diffuse_funcs[WINED3D_FFP_EMIT_FLOAT2] = invalid_func;
4894 diffuse_funcs[WINED3D_FFP_EMIT_FLOAT3] = (glAttribFunc)glColor3fv;
4895 diffuse_funcs[WINED3D_FFP_EMIT_FLOAT4] = (glAttribFunc)glColor4fv;
4896 diffuse_funcs[WINED3D_FFP_EMIT_D3DCOLOR] = diffuse_d3dcolor;
4897 diffuse_funcs[WINED3D_FFP_EMIT_UBYTE4] = invalid_func;
4898 diffuse_funcs[WINED3D_FFP_EMIT_SHORT2] = invalid_func;
4899 diffuse_funcs[WINED3D_FFP_EMIT_SHORT4] = invalid_func;
4900 diffuse_funcs[WINED3D_FFP_EMIT_UBYTE4N] = (glAttribFunc)glColor4ubv;
4901 diffuse_funcs[WINED3D_FFP_EMIT_SHORT2N] = invalid_func;
4902 diffuse_funcs[WINED3D_FFP_EMIT_SHORT4N] = (glAttribFunc)glColor4sv;
4903 diffuse_funcs[WINED3D_FFP_EMIT_USHORT2N] = invalid_func;
4904 diffuse_funcs[WINED3D_FFP_EMIT_USHORT4N] = (glAttribFunc)glColor4usv;
4905 diffuse_funcs[WINED3D_FFP_EMIT_UDEC3] = invalid_func;
4906 diffuse_funcs[WINED3D_FFP_EMIT_DEC3N] = invalid_func;
4907 diffuse_funcs[WINED3D_FFP_EMIT_FLOAT16_2] = invalid_func;
4908 diffuse_funcs[WINED3D_FFP_EMIT_FLOAT16_4] = invalid_func;
4910 /* No 4 component entry points here */
4911 specular_funcs[WINED3D_FFP_EMIT_FLOAT1] = invalid_func;
4912 specular_funcs[WINED3D_FFP_EMIT_FLOAT2] = invalid_func;
4913 if (gl_info->supported[EXT_SECONDARY_COLOR])
4915 specular_funcs[WINED3D_FFP_EMIT_FLOAT3] = (glAttribFunc)GL_EXTCALL(glSecondaryColor3fvEXT);
4919 specular_funcs[WINED3D_FFP_EMIT_FLOAT3] = warn_no_specular_func;
4921 specular_funcs[WINED3D_FFP_EMIT_FLOAT4] = invalid_func;
4922 if (gl_info->supported[EXT_SECONDARY_COLOR])
4924 specular_func_3ubv = (glAttribFunc)GL_EXTCALL(glSecondaryColor3ubvEXT);
4925 specular_funcs[WINED3D_FFP_EMIT_D3DCOLOR] = specular_d3dcolor;
4929 specular_funcs[WINED3D_FFP_EMIT_D3DCOLOR] = warn_no_specular_func;
4931 specular_funcs[WINED3D_FFP_EMIT_UBYTE4] = invalid_func;
4932 specular_funcs[WINED3D_FFP_EMIT_SHORT2] = invalid_func;
4933 specular_funcs[WINED3D_FFP_EMIT_SHORT4] = invalid_func;
4934 specular_funcs[WINED3D_FFP_EMIT_UBYTE4N] = invalid_func;
4935 specular_funcs[WINED3D_FFP_EMIT_SHORT2N] = invalid_func;
4936 specular_funcs[WINED3D_FFP_EMIT_SHORT4N] = invalid_func;
4937 specular_funcs[WINED3D_FFP_EMIT_USHORT2N] = invalid_func;
4938 specular_funcs[WINED3D_FFP_EMIT_USHORT4N] = invalid_func;
4939 specular_funcs[WINED3D_FFP_EMIT_UDEC3] = invalid_func;
4940 specular_funcs[WINED3D_FFP_EMIT_DEC3N] = invalid_func;
4941 specular_funcs[WINED3D_FFP_EMIT_FLOAT16_2] = invalid_func;
4942 specular_funcs[WINED3D_FFP_EMIT_FLOAT16_4] = invalid_func;
4944 /* Only 3 component entry points here. Test how others behave. Float4 normals are used
4945 * by one of our tests, trying to pass it to the pixel shader, which fails on Windows.
4947 normal_funcs[WINED3D_FFP_EMIT_FLOAT1] = invalid_func;
4948 normal_funcs[WINED3D_FFP_EMIT_FLOAT2] = invalid_func;
4949 normal_funcs[WINED3D_FFP_EMIT_FLOAT3] = (glAttribFunc)glNormal3fv;
4950 normal_funcs[WINED3D_FFP_EMIT_FLOAT4] = (glAttribFunc)glNormal3fv; /* Just ignore the 4th value */
4951 normal_funcs[WINED3D_FFP_EMIT_D3DCOLOR] = invalid_func;
4952 normal_funcs[WINED3D_FFP_EMIT_UBYTE4] = invalid_func;
4953 normal_funcs[WINED3D_FFP_EMIT_SHORT2] = invalid_func;
4954 normal_funcs[WINED3D_FFP_EMIT_SHORT4] = invalid_func;
4955 normal_funcs[WINED3D_FFP_EMIT_UBYTE4N] = invalid_func;
4956 normal_funcs[WINED3D_FFP_EMIT_SHORT2N] = invalid_func;
4957 normal_funcs[WINED3D_FFP_EMIT_SHORT4N] = invalid_func;
4958 normal_funcs[WINED3D_FFP_EMIT_USHORT2N] = invalid_func;
4959 normal_funcs[WINED3D_FFP_EMIT_USHORT4N] = invalid_func;
4960 normal_funcs[WINED3D_FFP_EMIT_UDEC3] = invalid_func;
4961 normal_funcs[WINED3D_FFP_EMIT_DEC3N] = invalid_func;
4962 normal_funcs[WINED3D_FFP_EMIT_FLOAT16_2] = invalid_func;
4963 normal_funcs[WINED3D_FFP_EMIT_FLOAT16_4] = invalid_func;
4965 multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT1] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord1fvARB);
4966 multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT2] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord2fvARB);
4967 multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT3] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord3fvARB);
4968 multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT4] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord4fvARB);
4969 multi_texcoord_funcs[WINED3D_FFP_EMIT_D3DCOLOR] = invalid_texcoord_func;
4970 multi_texcoord_funcs[WINED3D_FFP_EMIT_UBYTE4] = invalid_texcoord_func;
4971 multi_texcoord_funcs[WINED3D_FFP_EMIT_SHORT2] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord2svARB);
4972 multi_texcoord_funcs[WINED3D_FFP_EMIT_SHORT4] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord4svARB);
4973 multi_texcoord_funcs[WINED3D_FFP_EMIT_UBYTE4N] = invalid_texcoord_func;
4974 multi_texcoord_funcs[WINED3D_FFP_EMIT_SHORT2N] = invalid_texcoord_func;
4975 multi_texcoord_funcs[WINED3D_FFP_EMIT_SHORT4N] = invalid_texcoord_func;
4976 multi_texcoord_funcs[WINED3D_FFP_EMIT_USHORT2N] = invalid_texcoord_func;
4977 multi_texcoord_funcs[WINED3D_FFP_EMIT_USHORT4N] = invalid_texcoord_func;
4978 multi_texcoord_funcs[WINED3D_FFP_EMIT_UDEC3] = invalid_texcoord_func;
4979 multi_texcoord_funcs[WINED3D_FFP_EMIT_DEC3N] = invalid_texcoord_func;
4980 if (gl_info->supported[NV_HALF_FLOAT])
4982 /* Not supported by ARB_HALF_FLOAT_VERTEX, so check for NV_HALF_FLOAT */
4983 multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT16_2] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord2hvNV);
4984 multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT16_4] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord4hvNV);
4986 multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT16_2] = invalid_texcoord_func;
4987 multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT16_4] = invalid_texcoord_func;
4991 /* Do not call while under the GL lock. */
4992 static BOOL InitAdapters(IWineD3DImpl *This)
4994 static HMODULE mod_gl;
4996 int ps_selected_mode, vs_selected_mode;
4998 /* No need to hold any lock. The calling library makes sure only one thread calls
4999 * wined3d simultaneously
5002 TRACE("Initializing adapters\n");
5005 #ifdef USE_WIN32_OPENGL
5006 #define USE_GL_FUNC(pfn) pfn = (void*)GetProcAddress(mod_gl, #pfn);
5007 mod_gl = LoadLibraryA("opengl32.dll");
5009 ERR("Can't load opengl32.dll!\n");
5013 #define USE_GL_FUNC(pfn) pfn = (void*)pwglGetProcAddress(#pfn);
5014 /* To bypass the opengl32 thunks load wglGetProcAddress from gdi32 (glXGetProcAddress wrapper) instead of opengl32's */
5015 mod_gl = GetModuleHandleA("gdi32.dll");
5019 /* Load WGL core functions from opengl32.dll */
5020 #define USE_WGL_FUNC(pfn) p##pfn = (void*)GetProcAddress(mod_gl, #pfn);
5024 if(!pwglGetProcAddress) {
5025 ERR("Unable to load wglGetProcAddress!\n");
5029 /* Dynamically load all GL core functions */
5033 /* Load glFinish and glFlush from opengl32.dll even if we're not using WIN32 opengl
5034 * otherwise because we have to use winex11.drv's override
5036 #ifdef USE_WIN32_OPENGL
5037 wglFinish = (void*)GetProcAddress(mod_gl, "glFinish");
5038 wglFlush = (void*)GetProcAddress(mod_gl, "glFlush");
5040 wglFinish = (void*)pwglGetProcAddress("wglFinish");
5041 wglFlush = (void*)pwglGetProcAddress("wglFlush");
5044 glEnableWINE = glEnable;
5045 glDisableWINE = glDisable;
5047 /* For now only one default adapter */
5049 struct wined3d_adapter *adapter = &This->adapters[0];
5050 const struct wined3d_gl_info *gl_info = &adapter->gl_info;
5051 struct wined3d_fake_gl_ctx fake_gl_ctx = {0};
5055 WineD3D_PixelFormat *cfgs;
5056 DISPLAY_DEVICEW DisplayDevice;
5059 TRACE("Initializing default adapter\n");
5060 adapter->ordinal = 0;
5061 adapter->monitorPoint.x = -1;
5062 adapter->monitorPoint.y = -1;
5064 if (!AllocateLocallyUniqueId(&adapter->luid))
5066 DWORD err = GetLastError();
5067 ERR("Failed to set adapter LUID (%#x).\n", err);
5070 TRACE("Allocated LUID %08x:%08x for adapter.\n",
5071 adapter->luid.HighPart, adapter->luid.LowPart);
5073 if (!WineD3D_CreateFakeGLContext(&fake_gl_ctx))
5075 ERR("Failed to get a gl context for default adapter\n");
5079 ret = IWineD3DImpl_FillGLCaps(adapter);
5081 ERR("Failed to initialize gl caps for default adapter\n");
5082 WineD3D_ReleaseFakeGLContext(&fake_gl_ctx);
5085 ret = initPixelFormats(&adapter->gl_info, adapter->driver_info.vendor);
5087 ERR("Failed to init gl formats\n");
5088 WineD3D_ReleaseFakeGLContext(&fake_gl_ctx);
5092 hdc = fake_gl_ctx.dc;
5094 adapter->TextureRam = adapter->driver_info.vidmem;
5095 adapter->UsedTextureRam = 0;
5096 TRACE("Emulating %dMB of texture ram\n", adapter->TextureRam/(1024*1024));
5098 /* Initialize the Adapter's DeviceName which is required for ChangeDisplaySettings and friends */
5099 DisplayDevice.cb = sizeof(DisplayDevice);
5100 EnumDisplayDevicesW(NULL, 0 /* Adapter 0 = iDevNum 0 */, &DisplayDevice, 0);
5101 TRACE("DeviceName: %s\n", debugstr_w(DisplayDevice.DeviceName));
5102 strcpyW(adapter->DeviceName, DisplayDevice.DeviceName);
5104 if (gl_info->supported[WGL_ARB_PIXEL_FORMAT])
5111 attribute = WGL_NUMBER_PIXEL_FORMATS_ARB;
5112 GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc, 0, 0, 1, &attribute, &adapter->nCfgs));
5114 adapter->cfgs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, adapter->nCfgs *sizeof(WineD3D_PixelFormat));
5115 cfgs = adapter->cfgs;
5116 attribs[nAttribs++] = WGL_RED_BITS_ARB;
5117 attribs[nAttribs++] = WGL_GREEN_BITS_ARB;
5118 attribs[nAttribs++] = WGL_BLUE_BITS_ARB;
5119 attribs[nAttribs++] = WGL_ALPHA_BITS_ARB;
5120 attribs[nAttribs++] = WGL_COLOR_BITS_ARB;
5121 attribs[nAttribs++] = WGL_DEPTH_BITS_ARB;
5122 attribs[nAttribs++] = WGL_STENCIL_BITS_ARB;
5123 attribs[nAttribs++] = WGL_DRAW_TO_WINDOW_ARB;
5124 attribs[nAttribs++] = WGL_PIXEL_TYPE_ARB;
5125 attribs[nAttribs++] = WGL_DOUBLE_BUFFER_ARB;
5126 attribs[nAttribs++] = WGL_AUX_BUFFERS_ARB;
5128 for (iPixelFormat=1; iPixelFormat <= adapter->nCfgs; ++iPixelFormat)
5130 res = GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc, iPixelFormat, 0, nAttribs, attribs, values));
5135 /* Cache the pixel format */
5136 cfgs->iPixelFormat = iPixelFormat;
5137 cfgs->redSize = values[0];
5138 cfgs->greenSize = values[1];
5139 cfgs->blueSize = values[2];
5140 cfgs->alphaSize = values[3];
5141 cfgs->colorSize = values[4];
5142 cfgs->depthSize = values[5];
5143 cfgs->stencilSize = values[6];
5144 cfgs->windowDrawable = values[7];
5145 cfgs->iPixelType = values[8];
5146 cfgs->doubleBuffer = values[9];
5147 cfgs->auxBuffers = values[10];
5149 cfgs->numSamples = 0;
5150 /* Check multisample support */
5151 if (gl_info->supported[ARB_MULTISAMPLE])
5153 int attrib[2] = {WGL_SAMPLE_BUFFERS_ARB, WGL_SAMPLES_ARB};
5155 if(GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc, iPixelFormat, 0, 2, attrib, value))) {
5156 /* value[0] = WGL_SAMPLE_BUFFERS_ARB which tells whether multisampling is supported.
5157 * value[1] = number of multi sample buffers*/
5159 cfgs->numSamples = value[1];
5163 TRACE("iPixelFormat=%d, iPixelType=%#x, doubleBuffer=%d, RGBA=%d/%d/%d/%d, "
5164 "depth=%d, stencil=%d, samples=%d, windowDrawable=%d\n",
5165 cfgs->iPixelFormat, cfgs->iPixelType, cfgs->doubleBuffer,
5166 cfgs->redSize, cfgs->greenSize, cfgs->blueSize, cfgs->alphaSize,
5167 cfgs->depthSize, cfgs->stencilSize, cfgs->numSamples, cfgs->windowDrawable);
5173 int nCfgs = DescribePixelFormat(hdc, 0, 0, 0);
5174 adapter->cfgs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, nCfgs*sizeof(WineD3D_PixelFormat));
5175 adapter->nCfgs = 0; /* We won't accept all formats e.g. software accelerated ones will be skipped */
5177 cfgs = adapter->cfgs;
5178 for(iPixelFormat=1; iPixelFormat<=nCfgs; iPixelFormat++)
5180 PIXELFORMATDESCRIPTOR ppfd;
5182 res = DescribePixelFormat(hdc, iPixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &ppfd);
5186 /* We only want HW acceleration using an OpenGL ICD driver.
5187 * PFD_GENERIC_FORMAT = slow opengl 1.1 gdi software rendering
5188 * PFD_GENERIC_ACCELERATED = partial hw acceleration using a MCD driver (e.g. 3dfx minigl)
5190 if(ppfd.dwFlags & (PFD_GENERIC_FORMAT | PFD_GENERIC_ACCELERATED))
5192 TRACE("Skipping iPixelFormat=%d because it isn't ICD accelerated\n", iPixelFormat);
5196 cfgs->iPixelFormat = iPixelFormat;
5197 cfgs->redSize = ppfd.cRedBits;
5198 cfgs->greenSize = ppfd.cGreenBits;
5199 cfgs->blueSize = ppfd.cBlueBits;
5200 cfgs->alphaSize = ppfd.cAlphaBits;
5201 cfgs->colorSize = ppfd.cColorBits;
5202 cfgs->depthSize = ppfd.cDepthBits;
5203 cfgs->stencilSize = ppfd.cStencilBits;
5204 cfgs->windowDrawable = (ppfd.dwFlags & PFD_DRAW_TO_WINDOW) ? 1 : 0;
5205 cfgs->iPixelType = (ppfd.iPixelType == PFD_TYPE_RGBA) ? WGL_TYPE_RGBA_ARB : WGL_TYPE_COLORINDEX_ARB;
5206 cfgs->doubleBuffer = (ppfd.dwFlags & PFD_DOUBLEBUFFER) ? 1 : 0;
5207 cfgs->auxBuffers = ppfd.cAuxBuffers;
5208 cfgs->numSamples = 0;
5210 TRACE("iPixelFormat=%d, iPixelType=%#x, doubleBuffer=%d, RGBA=%d/%d/%d/%d, "
5211 "depth=%d, stencil=%d, windowDrawable=%d\n",
5212 cfgs->iPixelFormat, cfgs->iPixelType, cfgs->doubleBuffer,
5213 cfgs->redSize, cfgs->greenSize, cfgs->blueSize, cfgs->alphaSize,
5214 cfgs->depthSize, cfgs->stencilSize, cfgs->windowDrawable);
5219 /* Yikes we haven't found any suitable formats. This should only happen in case of GDI software rendering which we can't use anyway as its 3D functionality is very, very limited */
5222 ERR("Disabling Direct3D because no hardware accelerated pixel formats have been found!\n");
5224 WineD3D_ReleaseFakeGLContext(&fake_gl_ctx);
5225 HeapFree(GetProcessHeap(), 0, adapter->cfgs);
5230 /* D16, D24X8 and D24S8 are common depth / depth+stencil formats. All drivers support them though this doesn't
5231 * mean that the format is offered in hardware. For instance Geforce8 cards don't have offer D16 in hardware
5232 * but just fake it using D24(X8?) which is fine. D3D also allows that.
5233 * Some display drivers (i915 on Linux) only report mixed depth+stencil formats like D24S8. MSDN clearly mentions
5234 * that only on lockable formats (e.g. D16_locked) the bit order is guaranteed and that on other formats the
5235 * driver is allowed to consume more bits EXCEPT for stencil bits.
5237 * Mark an adapter with this broken stencil behavior.
5239 adapter->brokenStencil = TRUE;
5240 for (i = 0, cfgs = adapter->cfgs; i < adapter->nCfgs; ++i)
5242 /* Nearly all drivers offer depth formats without stencil, only on i915 this if-statement won't be entered. */
5243 if(cfgs[i].depthSize && !cfgs[i].stencilSize) {
5244 adapter->brokenStencil = FALSE;
5249 WineD3D_ReleaseFakeGLContext(&fake_gl_ctx);
5251 select_shader_mode(&adapter->gl_info, &ps_selected_mode, &vs_selected_mode);
5252 fillGLAttribFuncs(&adapter->gl_info);
5253 adapter->opengl = TRUE;
5255 This->adapter_count = 1;
5256 TRACE("%u adapters successfully initialized\n", This->adapter_count);
5261 /* Initialize an adapter for ddraw-only memory counting */
5262 memset(This->adapters, 0, sizeof(This->adapters));
5263 This->adapters[0].ordinal = 0;
5264 This->adapters[0].opengl = FALSE;
5265 This->adapters[0].monitorPoint.x = -1;
5266 This->adapters[0].monitorPoint.y = -1;
5268 This->adapters[0].driver_info.name = "Display";
5269 This->adapters[0].driver_info.description = "WineD3D DirectDraw Emulation";
5270 if(wined3d_settings.emulated_textureram) {
5271 This->adapters[0].TextureRam = wined3d_settings.emulated_textureram;
5273 This->adapters[0].TextureRam = 8 * 1024 * 1024; /* This is plenty for a DDraw-only card */
5276 initPixelFormatsNoGL(&This->adapters[0].gl_info);
5278 This->adapter_count = 1;
5282 /**********************************************************
5283 * IWineD3D VTbl follows
5284 **********************************************************/
5286 static const struct IWineD3DVtbl IWineD3D_Vtbl =
5289 IWineD3DImpl_QueryInterface,
5290 IWineD3DImpl_AddRef,
5291 IWineD3DImpl_Release,
5293 IWineD3DImpl_GetParent,
5294 IWineD3DImpl_GetAdapterCount,
5295 IWineD3DImpl_RegisterSoftwareDevice,
5296 IWineD3DImpl_GetAdapterMonitor,
5297 IWineD3DImpl_GetAdapterModeCount,
5298 IWineD3DImpl_EnumAdapterModes,
5299 IWineD3DImpl_GetAdapterDisplayMode,
5300 IWineD3DImpl_GetAdapterIdentifier,
5301 IWineD3DImpl_CheckDeviceMultiSampleType,
5302 IWineD3DImpl_CheckDepthStencilMatch,
5303 IWineD3DImpl_CheckDeviceType,
5304 IWineD3DImpl_CheckDeviceFormat,
5305 IWineD3DImpl_CheckDeviceFormatConversion,
5306 IWineD3DImpl_GetDeviceCaps,
5307 IWineD3DImpl_CreateDevice
5310 static void STDMETHODCALLTYPE wined3d_null_wined3d_object_destroyed(void *parent) {}
5312 const struct wined3d_parent_ops wined3d_null_parent_ops =
5314 wined3d_null_wined3d_object_destroyed,
5317 /* Do not call while under the GL lock. */
5318 HRESULT wined3d_init(IWineD3DImpl *wined3d, UINT version, void *parent)
5320 wined3d->lpVtbl = &IWineD3D_Vtbl;
5321 wined3d->dxVersion = version;
5323 wined3d->parent = parent;
5325 if (!InitAdapters(wined3d))
5327 WARN("Failed to initialize adapters.\n");
5330 MESSAGE("Direct3D%u is not available without OpenGL.\n", version);