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_draw_buffers2", EXT_DRAW_BUFFERS2, 0 },
109 {"GL_EXT_fog_coord", EXT_FOG_COORD, 0 },
110 {"GL_EXT_framebuffer_blit", EXT_FRAMEBUFFER_BLIT, 0 },
111 {"GL_EXT_framebuffer_multisample", EXT_FRAMEBUFFER_MULTISAMPLE, 0 },
112 {"GL_EXT_framebuffer_object", EXT_FRAMEBUFFER_OBJECT, 0 },
113 {"GL_EXT_gpu_program_parameters", EXT_GPU_PROGRAM_PARAMETERS, 0 },
114 {"GL_EXT_gpu_shader4", EXT_GPU_SHADER4, 0 },
115 {"GL_EXT_packed_depth_stencil", EXT_PACKED_DEPTH_STENCIL, 0 },
116 {"GL_EXT_paletted_texture", EXT_PALETTED_TEXTURE, 0 },
117 {"GL_EXT_point_parameters", EXT_POINT_PARAMETERS, 0 },
118 {"GL_EXT_provoking_vertex", EXT_PROVOKING_VERTEX, 0 },
119 {"GL_EXT_secondary_color", EXT_SECONDARY_COLOR, 0 },
120 {"GL_EXT_stencil_two_side", EXT_STENCIL_TWO_SIDE, 0 },
121 {"GL_EXT_stencil_wrap", EXT_STENCIL_WRAP, 0 },
122 {"GL_EXT_texture3D", EXT_TEXTURE3D, MAKEDWORD_VERSION(1, 2) },
123 {"GL_EXT_texture_compression_rgtc", EXT_TEXTURE_COMPRESSION_RGTC, 0 },
124 {"GL_EXT_texture_compression_s3tc", EXT_TEXTURE_COMPRESSION_S3TC, 0 },
125 {"GL_EXT_texture_env_add", EXT_TEXTURE_ENV_ADD, 0 },
126 {"GL_EXT_texture_env_combine", EXT_TEXTURE_ENV_COMBINE, 0 },
127 {"GL_EXT_texture_env_dot3", EXT_TEXTURE_ENV_DOT3, 0 },
128 {"GL_EXT_texture_filter_anisotropic", EXT_TEXTURE_FILTER_ANISOTROPIC, 0 },
129 {"GL_EXT_texture_lod_bias", EXT_TEXTURE_LOD_BIAS, 0 },
130 {"GL_EXT_texture_sRGB", EXT_TEXTURE_SRGB, 0 },
131 {"GL_EXT_vertex_array_bgra", EXT_VERTEX_ARRAY_BGRA, 0 },
134 {"GL_NV_depth_clamp", NV_DEPTH_CLAMP, 0 },
135 {"GL_NV_fence", NV_FENCE, 0 },
136 {"GL_NV_fog_distance", NV_FOG_DISTANCE, 0 },
137 {"GL_NV_fragment_program", NV_FRAGMENT_PROGRAM, 0 },
138 {"GL_NV_fragment_program2", NV_FRAGMENT_PROGRAM2, 0 },
139 {"GL_NV_fragment_program_option", NV_FRAGMENT_PROGRAM_OPTION, 0 },
140 {"GL_NV_half_float", NV_HALF_FLOAT, 0 },
141 {"GL_NV_light_max_exponent", NV_LIGHT_MAX_EXPONENT, 0 },
142 {"GL_NV_point_sprite", NV_POINT_SPRITE, 0 },
143 {"GL_NV_register_combiners", NV_REGISTER_COMBINERS, 0 },
144 {"GL_NV_register_combiners2", NV_REGISTER_COMBINERS2, 0 },
145 {"GL_NV_texgen_reflection", NV_TEXGEN_REFLECTION, 0 },
146 {"GL_NV_texture_env_combine4", NV_TEXTURE_ENV_COMBINE4, 0 },
147 {"GL_NV_texture_shader", NV_TEXTURE_SHADER, 0 },
148 {"GL_NV_texture_shader2", NV_TEXTURE_SHADER2, 0 },
149 {"GL_NV_vertex_program", NV_VERTEX_PROGRAM, 0 },
150 {"GL_NV_vertex_program1_1", NV_VERTEX_PROGRAM1_1, 0 },
151 {"GL_NV_vertex_program2", NV_VERTEX_PROGRAM2, 0 },
152 {"GL_NV_vertex_program2_option", NV_VERTEX_PROGRAM2_OPTION, 0 },
153 {"GL_NV_vertex_program3", NV_VERTEX_PROGRAM3, 0 },
156 {"GL_SGIS_generate_mipmap", SGIS_GENERATE_MIPMAP, 0 },
159 /**********************************************************
160 * Utility functions follow
161 **********************************************************/
163 const struct min_lookup minMipLookup[] =
165 /* NONE POINT LINEAR */
166 {{GL_NEAREST, GL_NEAREST, GL_NEAREST}}, /* NONE */
167 {{GL_NEAREST, GL_NEAREST_MIPMAP_NEAREST, GL_NEAREST_MIPMAP_LINEAR}}, /* POINT*/
168 {{GL_LINEAR, GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR_MIPMAP_LINEAR}}, /* LINEAR */
171 const struct min_lookup minMipLookup_noFilter[] =
173 /* NONE POINT LINEAR */
174 {{GL_NEAREST, GL_NEAREST, GL_NEAREST}}, /* NONE */
175 {{GL_NEAREST, GL_NEAREST, GL_NEAREST}}, /* POINT */
176 {{GL_NEAREST, GL_NEAREST, GL_NEAREST}}, /* LINEAR */
179 const struct min_lookup minMipLookup_noMip[] =
181 /* NONE POINT LINEAR */
182 {{GL_NEAREST, GL_NEAREST, GL_NEAREST}}, /* NONE */
183 {{GL_NEAREST, GL_NEAREST, GL_NEAREST}}, /* POINT */
184 {{GL_LINEAR, GL_LINEAR, GL_LINEAR }}, /* LINEAR */
187 const GLenum magLookup[] =
189 /* NONE POINT LINEAR */
190 GL_NEAREST, GL_NEAREST, GL_LINEAR,
193 const GLenum magLookup_noFilter[] =
195 /* NONE POINT LINEAR */
196 GL_NEAREST, GL_NEAREST, GL_NEAREST,
199 /* drawStridedSlow attributes */
200 glAttribFunc position_funcs[WINED3D_FFP_EMIT_COUNT];
201 glAttribFunc diffuse_funcs[WINED3D_FFP_EMIT_COUNT];
202 glAttribFunc specular_func_3ubv;
203 glAttribFunc specular_funcs[WINED3D_FFP_EMIT_COUNT];
204 glAttribFunc normal_funcs[WINED3D_FFP_EMIT_COUNT];
205 glMultiTexCoordFunc multi_texcoord_funcs[WINED3D_FFP_EMIT_COUNT];
208 * Note: GL seems to trap if GetDeviceCaps is called before any HWND's created,
209 * i.e., there is no GL Context - Get a default rendering context to enable the
210 * function query some info from GL.
213 struct wined3d_fake_gl_ctx
219 HGLRC restore_gl_ctx;
222 static void WineD3D_ReleaseFakeGLContext(struct wined3d_fake_gl_ctx *ctx)
224 TRACE_(d3d_caps)("Destroying fake GL context.\n");
226 if (!pwglMakeCurrent(NULL, NULL))
228 ERR_(d3d_caps)("Failed to disable fake GL context.\n");
231 if (!pwglDeleteContext(ctx->gl_ctx))
233 DWORD err = GetLastError();
234 ERR("wglDeleteContext(%p) failed, last error %#x.\n", ctx->gl_ctx, err);
237 ReleaseDC(ctx->wnd, ctx->dc);
238 DestroyWindow(ctx->wnd);
240 if (ctx->restore_gl_ctx && !pwglMakeCurrent(ctx->restore_dc, ctx->restore_gl_ctx))
242 ERR_(d3d_caps)("Failed to restore previous GL context.\n");
246 /* Do not call while under the GL lock. */
247 static BOOL WineD3D_CreateFakeGLContext(struct wined3d_fake_gl_ctx *ctx)
249 PIXELFORMATDESCRIPTOR pfd;
252 TRACE("getting context...\n");
254 ctx->restore_dc = pwglGetCurrentDC();
255 ctx->restore_gl_ctx = pwglGetCurrentContext();
257 /* We need a fake window as a hdc retrieved using GetDC(0) can't be used for much GL purposes. */
258 ctx->wnd = CreateWindowA(WINED3D_OPENGL_WINDOW_CLASS_NAME, "WineD3D fake window",
259 WS_OVERLAPPEDWINDOW, 10, 10, 10, 10, NULL, NULL, NULL, NULL);
262 ERR_(d3d_caps)("Failed to create a window.\n");
266 ctx->dc = GetDC(ctx->wnd);
269 ERR_(d3d_caps)("Failed to get a DC.\n");
273 /* PixelFormat selection */
274 ZeroMemory(&pfd, sizeof(pfd));
275 pfd.nSize = sizeof(pfd);
277 pfd.dwFlags = PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER | PFD_DRAW_TO_WINDOW; /* PFD_GENERIC_ACCELERATED */
278 pfd.iPixelType = PFD_TYPE_RGBA;
280 pfd.iLayerType = PFD_MAIN_PLANE;
282 iPixelFormat = ChoosePixelFormat(ctx->dc, &pfd);
285 /* If this happens something is very wrong as ChoosePixelFormat barely fails. */
286 ERR_(d3d_caps)("Can't find a suitable iPixelFormat.\n");
289 DescribePixelFormat(ctx->dc, iPixelFormat, sizeof(pfd), &pfd);
290 SetPixelFormat(ctx->dc, iPixelFormat, &pfd);
292 /* Create a GL context. */
293 ctx->gl_ctx = pwglCreateContext(ctx->dc);
296 WARN_(d3d_caps)("Error creating default context for capabilities initialization.\n");
300 /* Make it the current GL context. */
301 if (!context_set_current(NULL))
303 ERR_(d3d_caps)("Failed to clear current D3D context.\n");
306 if (!pwglMakeCurrent(ctx->dc, ctx->gl_ctx))
308 ERR_(d3d_caps)("Failed to make fake GL context current.\n");
315 if (ctx->gl_ctx) pwglDeleteContext(ctx->gl_ctx);
317 if (ctx->dc) ReleaseDC(ctx->wnd, ctx->dc);
319 if (ctx->wnd) DestroyWindow(ctx->wnd);
321 if (ctx->restore_gl_ctx && !pwglMakeCurrent(ctx->restore_dc, ctx->restore_gl_ctx))
323 ERR_(d3d_caps)("Failed to restore previous GL context.\n");
329 /* Adjust the amount of used texture memory */
330 unsigned int WineD3DAdapterChangeGLRam(IWineD3DDeviceImpl *device, unsigned int glram)
332 struct wined3d_adapter *adapter = device->adapter;
334 adapter->UsedTextureRam += glram;
335 TRACE("Adjusted gl ram by %d to %d\n", glram, adapter->UsedTextureRam);
336 return adapter->UsedTextureRam;
339 static void wined3d_adapter_cleanup(struct wined3d_adapter *adapter)
341 HeapFree(GetProcessHeap(), 0, adapter->gl_info.formats);
342 HeapFree(GetProcessHeap(), 0, adapter->cfgs);
345 /**********************************************************
346 * IUnknown parts follows
347 **********************************************************/
349 static HRESULT WINAPI IWineD3DImpl_QueryInterface(IWineD3D *iface,REFIID riid,LPVOID *ppobj)
351 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
353 TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppobj);
354 if (IsEqualGUID(riid, &IID_IUnknown)
355 || IsEqualGUID(riid, &IID_IWineD3DBase)
356 || IsEqualGUID(riid, &IID_IWineD3DDevice)) {
357 IUnknown_AddRef(iface);
362 return E_NOINTERFACE;
365 static ULONG WINAPI IWineD3DImpl_AddRef(IWineD3D *iface) {
366 IWineD3DImpl *This = (IWineD3DImpl *)iface;
367 ULONG refCount = InterlockedIncrement(&This->ref);
369 TRACE("(%p) : AddRef increasing from %d\n", This, refCount - 1);
373 static ULONG WINAPI IWineD3DImpl_Release(IWineD3D *iface) {
374 IWineD3DImpl *This = (IWineD3DImpl *)iface;
376 TRACE("(%p) : Releasing from %d\n", This, This->ref);
377 ref = InterlockedDecrement(&This->ref);
381 for (i = 0; i < This->adapter_count; ++i)
383 wined3d_adapter_cleanup(&This->adapters[i]);
385 HeapFree(GetProcessHeap(), 0, This);
391 /**********************************************************
392 * IWineD3D parts follows
393 **********************************************************/
395 /* GL locking is done by the caller */
396 static inline BOOL test_arb_vs_offset_limit(const struct wined3d_gl_info *gl_info)
400 const char *testcode =
402 "PARAM C[66] = { program.env[0..65] };\n"
404 "PARAM zero = {0.0, 0.0, 0.0, 0.0};\n"
405 "ARL A0.x, zero.x;\n"
406 "MOV result.position, C[A0.x + 65];\n"
410 GL_EXTCALL(glGenProgramsARB(1, &prog));
412 ERR("Failed to create an ARB offset limit test program\n");
414 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, prog));
415 GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
416 strlen(testcode), testcode));
417 if(glGetError() != 0) {
418 TRACE("OpenGL implementation does not allow indirect addressing offsets > 63\n");
419 TRACE("error: %s\n", debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
421 } else TRACE("OpenGL implementation allows offsets > 63\n");
423 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, 0));
424 GL_EXTCALL(glDeleteProgramsARB(1, &prog));
425 checkGLcall("ARB vp offset limit test cleanup");
430 static DWORD ver_for_ext(GL_SupportedExt ext)
433 for (i = 0; i < (sizeof(EXTENSION_MAP) / sizeof(*EXTENSION_MAP)); ++i) {
434 if(EXTENSION_MAP[i].extension == ext) {
435 return EXTENSION_MAP[i].version;
441 static BOOL match_ati_r300_to_500(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
442 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
444 if (card_vendor != HW_VENDOR_ATI) return FALSE;
445 if (device == CARD_ATI_RADEON_9500) return TRUE;
446 if (device == CARD_ATI_RADEON_X700) return TRUE;
447 if (device == CARD_ATI_RADEON_X1600) return TRUE;
451 static BOOL match_geforce5(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
452 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
454 if (card_vendor == HW_VENDOR_NVIDIA)
456 if (device == CARD_NVIDIA_GEFORCEFX_5200 ||
457 device == CARD_NVIDIA_GEFORCEFX_5600 ||
458 device == CARD_NVIDIA_GEFORCEFX_5800)
466 static BOOL match_apple(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
467 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
469 /* MacOS has various specialities in the extensions it advertises. Some have to be loaded from
470 * the opengl 1.2+ core, while other extensions are advertised, but software emulated. So try to
471 * detect the Apple OpenGL implementation to apply some extension fixups afterwards.
473 * Detecting this isn't really easy. The vendor string doesn't mention Apple. Compile-time checks
474 * aren't sufficient either because a Linux binary may display on a macos X server via remote X11.
475 * So try to detect the GL implementation by looking at certain Apple extensions. Some extensions
476 * like client storage might be supported on other implementations too, but GL_APPLE_flush_render
477 * is specific to the Mac OS X window management, and GL_APPLE_ycbcr_422 is QuickTime specific. So
478 * the chance that other implementations support them is rather small since Win32 QuickTime uses
479 * DirectDraw, not OpenGL.
481 * This test has been moved into wined3d_guess_gl_vendor()
483 if (gl_vendor == GL_VENDOR_APPLE)
490 /* Context activation is done by the caller. */
491 static void test_pbo_functionality(struct wined3d_gl_info *gl_info)
493 /* Some OpenGL implementations, namely Apple's Geforce 8 driver, advertises PBOs,
494 * but glTexSubImage from a PBO fails miserably, with the first line repeated over
495 * all the texture. This function detects this bug by its symptom and disables PBOs
498 * The test uploads a 4x4 texture via the PBO in the "native" format GL_BGRA,
499 * GL_UNSIGNED_INT_8_8_8_8_REV. This format triggers the bug, and it is what we use
500 * for D3DFMT_A8R8G8B8. Then the texture is read back without any PBO and the data
501 * read back is compared to the original. If they are equal PBOs are assumed to work,
502 * otherwise the PBO extension is disabled. */
504 static const unsigned int pattern[] =
506 0x00000000, 0x000000ff, 0x0000ff00, 0x40ff0000,
507 0x80ffffff, 0x40ffff00, 0x00ff00ff, 0x0000ffff,
508 0x00ffff00, 0x00ff00ff, 0x0000ffff, 0x000000ff,
509 0x80ff00ff, 0x0000ffff, 0x00ff00ff, 0x40ff00ff
511 unsigned int check[sizeof(pattern) / sizeof(pattern[0])];
513 /* No PBO -> No point in testing them. */
514 if (!gl_info->supported[ARB_PIXEL_BUFFER_OBJECT]) return;
518 while (glGetError());
519 glGenTextures(1, &texture);
520 glBindTexture(GL_TEXTURE_2D, texture);
522 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
523 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 4, 4, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, 0);
524 checkGLcall("Specifying the PBO test texture");
526 GL_EXTCALL(glGenBuffersARB(1, &pbo));
527 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pbo));
528 GL_EXTCALL(glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, sizeof(pattern), pattern, GL_STREAM_DRAW_ARB));
529 checkGLcall("Specifying the PBO test pbo");
531 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL);
532 checkGLcall("Loading the PBO test texture");
534 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
537 wglFinish(); /* just to be sure */
539 memset(check, 0, sizeof(check));
541 glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, check);
542 checkGLcall("Reading back the PBO test texture");
544 glDeleteTextures(1, &texture);
545 GL_EXTCALL(glDeleteBuffersARB(1, &pbo));
546 checkGLcall("PBO test cleanup");
550 if (memcmp(check, pattern, sizeof(check)))
552 WARN_(d3d_caps)("PBO test failed, read back data doesn't match original.\n");
553 WARN_(d3d_caps)("Disabling PBOs. This may result in slower performance.\n");
554 gl_info->supported[ARB_PIXEL_BUFFER_OBJECT] = FALSE;
558 TRACE_(d3d_caps)("PBO test successful.\n");
562 static BOOL match_apple_intel(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
563 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
565 return (card_vendor == HW_VENDOR_INTEL) && (gl_vendor == GL_VENDOR_APPLE);
568 static BOOL match_apple_nonr500ati(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
569 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
571 if (gl_vendor != GL_VENDOR_APPLE) return FALSE;
572 if (card_vendor != HW_VENDOR_ATI) return FALSE;
573 if (device == CARD_ATI_RADEON_X1600) return FALSE;
577 static BOOL match_fglrx(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
578 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
580 return gl_vendor == GL_VENDOR_FGLRX;
584 static BOOL match_dx10_capable(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
585 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
587 /* DX9 cards support 40 single float varyings in hardware, most drivers report 32. ATI misreports
588 * 44 varyings. So assume that if we have more than 44 varyings we have a dx10 card.
589 * This detection is for the gl_ClipPos varying quirk. If a d3d9 card really supports more than 44
590 * varyings and we subtract one in dx9 shaders its not going to hurt us because the dx9 limit is
593 * dx10 cards usually have 64 varyings */
594 return gl_info->limits.glsl_varyings > 44;
597 /* A GL context is provided by the caller */
598 static BOOL match_allows_spec_alpha(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
599 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
604 if (!gl_info->supported[EXT_SECONDARY_COLOR]) return FALSE;
608 GL_EXTCALL(glSecondaryColorPointerEXT)(4, GL_UNSIGNED_BYTE, 4, data);
609 error = glGetError();
612 if(error == GL_NO_ERROR)
614 TRACE("GL Implementation accepts 4 component specular color pointers\n");
619 TRACE("GL implementation does not accept 4 component specular colors, error %s\n",
620 debug_glerror(error));
625 static BOOL match_apple_nvts(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
626 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
628 if (!match_apple(gl_info, gl_renderer, gl_vendor, card_vendor, device)) return FALSE;
629 return gl_info->supported[NV_TEXTURE_SHADER];
632 /* A GL context is provided by the caller */
633 static BOOL match_broken_nv_clip(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
634 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
639 const char *testcode =
641 "OPTION NV_vertex_program2;\n"
642 "MOV result.clip[0], 0.0;\n"
643 "MOV result.position, 0.0;\n"
646 if (!gl_info->supported[NV_VERTEX_PROGRAM2_OPTION]) return FALSE;
651 GL_EXTCALL(glGenProgramsARB(1, &prog));
654 ERR("Failed to create the NVvp clip test program\n");
658 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, prog));
659 GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
660 strlen(testcode), testcode));
661 glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &pos);
664 WARN("GL_NV_vertex_program2_option result.clip[] test failed\n");
665 TRACE("error: %s\n", debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
669 else TRACE("GL_NV_vertex_program2_option result.clip[] test passed\n");
671 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, 0));
672 GL_EXTCALL(glDeleteProgramsARB(1, &prog));
673 checkGLcall("GL_NV_vertex_program2_option result.clip[] test cleanup");
679 /* Context activation is done by the caller. */
680 static BOOL match_fbo_tex_update(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
681 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
683 char data[4 * 4 * 4];
687 if (wined3d_settings.offscreen_rendering_mode != ORM_FBO) return FALSE;
689 memset(data, 0xcc, sizeof(data));
693 glGenTextures(1, &tex);
694 glBindTexture(GL_TEXTURE_2D, tex);
695 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
696 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
697 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 4, 4, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL);
698 checkGLcall("glTexImage2D");
700 gl_info->fbo_ops.glGenFramebuffers(1, &fbo);
701 gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
702 gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0);
703 checkGLcall("glFramebufferTexture2D");
705 status = gl_info->fbo_ops.glCheckFramebufferStatus(GL_FRAMEBUFFER);
706 if (status != GL_FRAMEBUFFER_COMPLETE) ERR("FBO status %#x\n", status);
707 checkGLcall("glCheckFramebufferStatus");
709 memset(data, 0x11, sizeof(data));
710 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, data);
711 checkGLcall("glTexSubImage2D");
713 glClearColor(0.996f, 0.729f, 0.745f, 0.792f);
714 glClear(GL_COLOR_BUFFER_BIT);
715 checkGLcall("glClear");
717 glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, data);
718 checkGLcall("glGetTexImage");
720 gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
721 gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, 0);
722 glBindTexture(GL_TEXTURE_2D, 0);
723 checkGLcall("glBindTexture");
725 gl_info->fbo_ops.glDeleteFramebuffers(1, &fbo);
726 glDeleteTextures(1, &tex);
727 checkGLcall("glDeleteTextures");
731 return *(DWORD *)data == 0x11111111;
734 static void quirk_arb_constants(struct wined3d_gl_info *gl_info)
736 TRACE_(d3d_caps)("Using ARB vs constant limit(=%u) for GLSL.\n", gl_info->limits.arb_vs_native_constants);
737 gl_info->limits.glsl_vs_float_constants = gl_info->limits.arb_vs_native_constants;
738 TRACE_(d3d_caps)("Using ARB ps constant limit(=%u) for GLSL.\n", gl_info->limits.arb_ps_native_constants);
739 gl_info->limits.glsl_ps_float_constants = gl_info->limits.arb_ps_native_constants;
742 static void quirk_apple_glsl_constants(struct wined3d_gl_info *gl_info)
744 quirk_arb_constants(gl_info);
745 /* MacOS needs uniforms for relative addressing offsets. This can accumulate to quite a few uniforms.
746 * Beyond that the general uniform isn't optimal, so reserve a number of uniforms. 12 vec4's should
747 * allow 48 different offsets or other helper immediate values. */
748 TRACE_(d3d_caps)("Reserving 12 GLSL constants for compiler private use.\n");
749 gl_info->reserved_glsl_constants = max(gl_info->reserved_glsl_constants, 12);
752 /* fglrx crashes with a very bad kernel panic if GL_POINT_SPRITE_ARB is set to GL_COORD_REPLACE_ARB
753 * on more than one texture unit. This means that the d3d9 visual point size test will cause a
754 * kernel panic on any machine running fglrx 9.3(latest that supports r300 to r500 cards). This
755 * quirk only enables point sprites on the first texture unit. This keeps point sprites working in
756 * most games, but avoids the crash
758 * A more sophisticated way would be to find all units that need texture coordinates and enable
759 * point sprites for one if only one is found, and software emulate point sprites in drawStridedSlow
760 * if more than one unit needs texture coordinates(This requires software ffp and vertex shaders though)
762 * Note that disabling the extension entirely does not gain predictability because there is no point
763 * sprite capability flag in d3d, so the potential rendering bugs are the same if we disable the extension. */
764 static void quirk_one_point_sprite(struct wined3d_gl_info *gl_info)
766 if (gl_info->supported[ARB_POINT_SPRITE])
768 TRACE("Limiting point sprites to one texture unit.\n");
769 gl_info->limits.point_sprite_units = 1;
773 static void quirk_ati_dx9(struct wined3d_gl_info *gl_info)
775 quirk_arb_constants(gl_info);
777 /* MacOS advertises GL_ARB_texture_non_power_of_two on ATI r500 and earlier cards, although
778 * these cards only support GL_ARB_texture_rectangle(D3DPTEXTURECAPS_NONPOW2CONDITIONAL).
779 * If real NP2 textures are used, the driver falls back to software. We could just remove the
780 * extension and use GL_ARB_texture_rectangle instead, but texture_rectangle is inconventient
781 * due to the non-normalized texture coordinates. Thus set an internal extension flag,
782 * GL_WINE_normalized_texrect, which signals the code that it can use non power of two textures
783 * as per GL_ARB_texture_non_power_of_two, but has to stick to the texture_rectangle limits.
785 * fglrx doesn't advertise GL_ARB_texture_non_power_of_two, but it advertises opengl 2.0 which
786 * has this extension promoted to core. The extension loading code sets this extension supported
787 * due to that, so this code works on fglrx as well. */
788 if(gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO])
790 TRACE("GL_ARB_texture_non_power_of_two advertised on R500 or earlier card, removing.\n");
791 gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] = FALSE;
792 gl_info->supported[WINED3D_GL_NORMALIZED_TEXRECT] = TRUE;
795 /* fglrx has the same structural issues as the one described in quirk_apple_glsl_constants, although
796 * it is generally more efficient. Reserve just 8 constants. */
797 TRACE_(d3d_caps)("Reserving 8 GLSL constants for compiler private use.\n");
798 gl_info->reserved_glsl_constants = max(gl_info->reserved_glsl_constants, 8);
801 static void quirk_no_np2(struct wined3d_gl_info *gl_info)
803 /* The nVidia GeForceFX series reports OpenGL 2.0 capabilities with the latest drivers versions, but
804 * doesn't explicitly advertise the ARB_tex_npot extension in the GL extension string.
805 * This usually means that ARB_tex_npot is supported in hardware as long as the application is staying
806 * within the limits enforced by the ARB_texture_rectangle extension. This however is not true for the
807 * FX series, which instantly falls back to a slower software path as soon as ARB_tex_npot is used.
808 * We therefore completely remove ARB_tex_npot from the list of supported extensions.
810 * Note that wine_normalized_texrect can't be used in this case because internally it uses ARB_tex_npot,
811 * triggering the software fallback. There is not much we can do here apart from disabling the
812 * software-emulated extension and reenable ARB_tex_rect (which was previously disabled
813 * in IWineD3DImpl_FillGLCaps).
814 * This fixup removes performance problems on both the FX 5900 and FX 5700 (e.g. for framebuffer
815 * post-processing effects in the game "Max Payne 2").
816 * The behaviour can be verified through a simple test app attached in bugreport #14724. */
817 TRACE("GL_ARB_texture_non_power_of_two advertised through OpenGL 2.0 on NV FX card, removing.\n");
818 gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] = FALSE;
819 gl_info->supported[ARB_TEXTURE_RECTANGLE] = TRUE;
822 static void quirk_texcoord_w(struct wined3d_gl_info *gl_info)
824 /* The Intel GPUs on MacOS set the .w register of texcoords to 0.0 by default, which causes problems
825 * with fixed function fragment processing. Ideally this flag should be detected with a test shader
826 * and OpenGL feedback mode, but some GL implementations (MacOS ATI at least, probably all MacOS ones)
827 * do not like vertex shaders in feedback mode and return an error, even though it should be valid
828 * according to the spec.
830 * We don't want to enable this on all cards, as it adds an extra instruction per texcoord used. This
831 * makes the shader slower and eats instruction slots which should be available to the d3d app.
833 * ATI Radeon HD 2xxx cards on MacOS have the issue. Instead of checking for the buggy cards, blacklist
834 * all radeon cards on Macs and whitelist the good ones. That way we're prepared for the future. If
835 * this workaround is activated on cards that do not need it, it won't break things, just affect
836 * performance negatively. */
837 TRACE("Enabling vertex texture coord fixes in vertex shaders.\n");
838 gl_info->quirks |= WINED3D_QUIRK_SET_TEXCOORD_W;
841 static void quirk_clip_varying(struct wined3d_gl_info *gl_info)
843 gl_info->quirks |= WINED3D_QUIRK_GLSL_CLIP_VARYING;
846 static void quirk_allows_specular_alpha(struct wined3d_gl_info *gl_info)
848 gl_info->quirks |= WINED3D_QUIRK_ALLOWS_SPECULAR_ALPHA;
851 static void quirk_apple_nvts(struct wined3d_gl_info *gl_info)
853 gl_info->supported[NV_TEXTURE_SHADER] = FALSE;
854 gl_info->supported[NV_TEXTURE_SHADER2] = FALSE;
857 static void quirk_disable_nvvp_clip(struct wined3d_gl_info *gl_info)
859 gl_info->quirks |= WINED3D_QUIRK_NV_CLIP_BROKEN;
862 static void quirk_fbo_tex_update(struct wined3d_gl_info *gl_info)
864 gl_info->quirks |= WINED3D_QUIRK_FBO_TEX_UPDATE;
869 BOOL (*match)(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
870 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device);
871 void (*apply)(struct wined3d_gl_info *gl_info);
872 const char *description;
875 static const struct driver_quirk quirk_table[] =
878 match_ati_r300_to_500,
880 "ATI GLSL constant and normalized texrect quirk"
882 /* MacOS advertises more GLSL vertex shader uniforms than supported by the hardware, and if more are
883 * used it falls back to software. While the compiler can detect if the shader uses all declared
884 * uniforms, the optimization fails if the shader uses relative addressing. So any GLSL shader
885 * using relative addressing falls back to software.
887 * ARB vp gives the correct amount of uniforms, so use it instead of GLSL. */
890 quirk_apple_glsl_constants,
891 "Apple GLSL uniform override"
896 "Geforce 5 NP2 disable"
901 "Init texcoord .w for Apple Intel GPU driver"
904 match_apple_nonr500ati,
906 "Init texcoord .w for Apple ATI >= r600 GPU driver"
910 quirk_one_point_sprite,
911 "Fglrx point sprite crash workaround"
916 "Reserved varying for gl_ClipPos"
919 /* GL_EXT_secondary_color does not allow 4 component secondary colors, but most
920 * GL implementations accept it. The Mac GL is the only implementation known to
923 * If we can pass 4 component specular colors, do it, because (a) we don't have
924 * to screw around with the data, and (b) the D3D fixed function vertex pipeline
925 * passes specular alpha to the pixel shader if any is used. Otherwise the
926 * specular alpha is used to pass the fog coordinate, which we pass to opengl
927 * via GL_EXT_fog_coord.
929 match_allows_spec_alpha,
930 quirk_allows_specular_alpha,
931 "Allow specular alpha quirk"
934 /* The pixel formats provided by GL_NV_texture_shader are broken on OSX
939 "Apple NV_texture_shader disable"
942 match_broken_nv_clip,
943 quirk_disable_nvvp_clip,
944 "Apple NV_vertex_program clip bug quirk"
947 match_fbo_tex_update,
948 quirk_fbo_tex_update,
949 "FBO rebind for attachment updates"
953 /* Certain applications (Steam) complain if we report an outdated driver version. In general,
954 * reporting a driver version is moot because we are not the Windows driver, and we have different
955 * bugs, features, etc.
957 * The driver version has the form "x.y.z.w".
959 * "x" is the Windows version the driver is meant for:
966 * "y" is the maximum Direct3D version the driver supports.
967 * y -> d3d version mapping:
976 * "z" is the subversion number.
978 * "w" is the vendor specific driver build number.
981 struct driver_version_information
983 enum wined3d_display_driver driver;
984 enum wined3d_driver_model driver_model;
985 const char *driver_name; /* name of Windows driver */
986 WORD version; /* version word ('y'), contained in low word of DriverVersion.HighPart */
987 WORD subversion; /* subversion word ('z'), contained in high word of DriverVersion.LowPart */
988 WORD build; /* build number ('w'), contained in low word of DriverVersion.LowPart */
991 /* The driver version table contains driver information for different devices on several OS versions. */
992 static const struct driver_version_information driver_version_table[] =
995 * - Radeon HD2x00 (R600) and up supported by current drivers.
996 * - Radeon 9500 (R300) - X1*00 (R5xx) supported upto Catalyst 9.3 (Linux) and 10.2 (XP/Vista/Win7) */
997 {DRIVER_ATI_R300, DRIVER_MODEL_NT5X, "ati2dvag.dll", 14, 10, 6764},
998 {DRIVER_ATI_R600, DRIVER_MODEL_NT5X, "ati2dvag.dll", 14, 10, 8681},
999 {DRIVER_ATI_R300, DRIVER_MODEL_NT6X, "atiumdag.dll", 14, 10, 741 },
1000 {DRIVER_ATI_R600, DRIVER_MODEL_NT6X, "atiumdag.dll", 14, 10, 741 },
1003 * The drivers are unified but not all versions support all GPUs. At some point the 2k/xp
1004 * drivers used ialmrnt5.dll for GMA800/GMA900 but at some point the file was renamed to
1005 * igxprd32.dll but the GMA800 driver was never updated. */
1006 {DRIVER_INTEL_GMA800, DRIVER_MODEL_NT5X, "ialmrnt5.dll", 14, 10, 3889},
1007 {DRIVER_INTEL_GMA900, DRIVER_MODEL_NT5X, "igxprd32.dll", 14, 10, 4764},
1008 {DRIVER_INTEL_GMA950, DRIVER_MODEL_NT5X, "igxprd32.dll", 14, 10, 4926},
1009 {DRIVER_INTEL_GMA3000, DRIVER_MODEL_NT5X, "igxprd32.dll", 14, 10, 5218},
1010 {DRIVER_INTEL_GMA950, DRIVER_MODEL_NT6X, "igdumd32.dll", 14, 10, 1504},
1011 {DRIVER_INTEL_GMA3000, DRIVER_MODEL_NT6X, "igdumd32.dll", 15, 10, 1666},
1014 * - Geforce6 and newer cards are supported by the current driver (197.x) on XP-Win7
1015 * - GeforceFX support is up to 173.x on <= XP
1016 * - Geforce2MX/3/4 up to 96.x on <= XP
1017 * - TNT/Geforce1/2 up to 71.x on <= XP
1018 * All version numbers used below are from the Linux nvidia drivers. */
1019 {DRIVER_NVIDIA_TNT, DRIVER_MODEL_NT5X, "nv4_disp.dll", 14, 10, 7186},
1020 {DRIVER_NVIDIA_GEFORCE2MX, DRIVER_MODEL_NT5X, "nv4_disp.dll", 14, 10, 9371},
1021 {DRIVER_NVIDIA_GEFORCEFX, DRIVER_MODEL_NT5X, "nv4_disp.dll", 14, 11, 7516},
1022 {DRIVER_NVIDIA_GEFORCE6, DRIVER_MODEL_NT5X, "nv4_disp.dll", 15, 11, 9745},
1023 {DRIVER_NVIDIA_GEFORCE6, DRIVER_MODEL_NT6X, "nvd3dum.dll", 15, 11, 9745},
1026 struct gpu_description
1028 WORD vendor; /* reported PCI card vendor ID */
1029 WORD card; /* reported PCI card device ID */
1030 const char *description; /* Description of the card e.g. NVIDIA RIVA TNT */
1031 enum wined3d_display_driver driver;
1034 static const struct gpu_description gpu_description_table[] =
1037 {HW_VENDOR_NVIDIA, CARD_NVIDIA_RIVA_TNT, "NVIDIA RIVA TNT", DRIVER_NVIDIA_TNT },
1038 {HW_VENDOR_NVIDIA, CARD_NVIDIA_RIVA_TNT2, "NVIDIA RIVA TNT2/TNT2 Pro", DRIVER_NVIDIA_TNT },
1039 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE, "NVIDIA GeForce 256", DRIVER_NVIDIA_TNT },
1040 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE2, "NVIDIA GeForce2 GTS/GeForce2 Pro", DRIVER_NVIDIA_TNT },
1041 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE2_MX, "NVIDIA GeForce2 MX/MX 400", DRIVER_NVIDIA_GEFORCE2MX },
1042 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE3, "NVIDIA GeForce3", DRIVER_NVIDIA_GEFORCE2MX },
1043 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE4_MX, "NVIDIA GeForce4 MX 460", DRIVER_NVIDIA_GEFORCE2MX },
1044 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE4_TI4200, "NVIDIA GeForce4 Ti 4200", DRIVER_NVIDIA_GEFORCE2MX },
1045 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCEFX_5200, "NVIDIA GeForce FX 5200", DRIVER_NVIDIA_GEFORCEFX },
1046 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCEFX_5600, "NVIDIA GeForce FX 5600", DRIVER_NVIDIA_GEFORCEFX },
1047 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCEFX_5800, "NVIDIA GeForce FX 5800", DRIVER_NVIDIA_GEFORCEFX },
1048 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_6200, "NVIDIA GeForce 6200", DRIVER_NVIDIA_GEFORCE6 },
1049 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_6600GT, "NVIDIA GeForce 6600 GT", DRIVER_NVIDIA_GEFORCE6 },
1050 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_6800, "NVIDIA GeForce 6800", DRIVER_NVIDIA_GEFORCE6 },
1051 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7300, "NVIDIA GeForce Go 7300", DRIVER_NVIDIA_GEFORCE6 },
1052 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7400, "NVIDIA GeForce Go 7400", DRIVER_NVIDIA_GEFORCE6 },
1053 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7600, "NVIDIA GeForce 7600 GT", DRIVER_NVIDIA_GEFORCE6 },
1054 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7800GT, "NVIDIA GeForce 7800 GT", DRIVER_NVIDIA_GEFORCE6 },
1055 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8300GS, "NVIDIA GeForce 8300 GS", DRIVER_NVIDIA_GEFORCE6 },
1056 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8400GS, "NVIDIA GeForce 8400 GS", DRIVER_NVIDIA_GEFORCE6 },
1057 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8600GT, "NVIDIA GeForce 8600 GT", DRIVER_NVIDIA_GEFORCE6 },
1058 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8600MGT, "NVIDIA GeForce 8600M GT", DRIVER_NVIDIA_GEFORCE6 },
1059 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8800GTS, "NVIDIA GeForce 8800 GTS", DRIVER_NVIDIA_GEFORCE6 },
1060 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8800GTX, "NVIDIA GeForce 8800 GTX", DRIVER_NVIDIA_GEFORCE6 },
1061 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9200, "NVIDIA GeForce 9200", DRIVER_NVIDIA_GEFORCE6 },
1062 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9400GT, "NVIDIA GeForce 9400 GT", DRIVER_NVIDIA_GEFORCE6 },
1063 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9500GT, "NVIDIA GeForce 9500 GT", DRIVER_NVIDIA_GEFORCE6 },
1064 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9600GT, "NVIDIA GeForce 9600 GT", DRIVER_NVIDIA_GEFORCE6 },
1065 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9800GT, "NVIDIA GeForce 9800 GT", DRIVER_NVIDIA_GEFORCE6 },
1066 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_210, "NVIDIA GeForce 210", DRIVER_NVIDIA_GEFORCE6 },
1067 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT220, "NVIDIA GeForce GT 220", DRIVER_NVIDIA_GEFORCE6 },
1068 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT240, "NVIDIA GeForce GT 240", DRIVER_NVIDIA_GEFORCE6 },
1069 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX260, "NVIDIA GeForce GTX 260", DRIVER_NVIDIA_GEFORCE6 },
1070 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX275, "NVIDIA GeForce GTX 275", DRIVER_NVIDIA_GEFORCE6 },
1071 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX280, "NVIDIA GeForce GTX 280", DRIVER_NVIDIA_GEFORCE6 },
1072 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT325M, "NVIDIA GeForce GT 325M", DRIVER_NVIDIA_GEFORCE6 },
1073 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTS350M, "NVIDIA GeForce GTS 350M", DRIVER_NVIDIA_GEFORCE6 },
1074 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX460, "NVIDIA GeForce GTX 460", DRIVER_NVIDIA_GEFORCE6 },
1075 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX470, "NVIDIA GeForce GTX 470", DRIVER_NVIDIA_GEFORCE6 },
1076 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX480, "NVIDIA GeForce GTX 480", DRIVER_NVIDIA_GEFORCE6 },
1078 {HW_VENDOR_ATI, CARD_ATI_RADEON_9500, "ATI Radeon 9500", DRIVER_ATI_R300, },
1079 {HW_VENDOR_ATI, CARD_ATI_RADEON_X700, "ATI Radeon X700 SE", DRIVER_ATI_R300, },
1080 {HW_VENDOR_ATI, CARD_ATI_RADEON_X1600, "ATI Radeon X1600 Series", DRIVER_ATI_R300, },
1081 {HW_VENDOR_ATI, CARD_ATI_RADEON_HD2350, "ATI Mobility Radeon HD 2350", DRIVER_ATI_R600, },
1082 {HW_VENDOR_ATI, CARD_ATI_RADEON_HD2600, "ATI Mobility Radeon HD 2600", DRIVER_ATI_R600, },
1083 {HW_VENDOR_ATI, CARD_ATI_RADEON_HD2900, "ATI Radeon HD 2900 XT", DRIVER_ATI_R600, },
1084 {HW_VENDOR_ATI, CARD_ATI_RADEON_HD4350, "ATI Radeon HD 4350", DRIVER_ATI_R600, },
1085 {HW_VENDOR_ATI, CARD_ATI_RADEON_HD4600, "ATI Radeon HD 4600 Series", DRIVER_ATI_R600, },
1086 {HW_VENDOR_ATI, CARD_ATI_RADEON_HD4700, "ATI Radeon HD 4700 Series", DRIVER_ATI_R600, },
1087 {HW_VENDOR_ATI, CARD_ATI_RADEON_HD4800, "ATI Radeon HD 4800 Series", DRIVER_ATI_R600, },
1088 {HW_VENDOR_ATI, CARD_ATI_RADEON_HD5700, "ATI Radeon HD 5700 Series", DRIVER_ATI_R600, },
1089 {HW_VENDOR_ATI, CARD_ATI_RADEON_HD5800, "ATI Radeon HD 5800 Series", DRIVER_ATI_R600, },
1091 {HW_VENDOR_INTEL, CARD_INTEL_I830G, "Intel(R) 82830M Graphics Controller", DRIVER_INTEL_GMA800 },
1092 {HW_VENDOR_INTEL, CARD_INTEL_I855G, "Intel(R) 82852/82855 GM/GME Graphics Controller", DRIVER_INTEL_GMA800 },
1093 {HW_VENDOR_INTEL, CARD_INTEL_I865G, "Intel(R) 82865G Graphics Controller", DRIVER_INTEL_GMA800 },
1094 {HW_VENDOR_INTEL, CARD_INTEL_I915G, "Intel(R) 82915G/GV/910GL Express Chipset Family", DRIVER_INTEL_GMA900 },
1095 {HW_VENDOR_INTEL, CARD_INTEL_I915GM, "Mobile Intel(R) 915GM/GMS,910GML Express Chipset Family", DRIVER_INTEL_GMA900 },
1096 {HW_VENDOR_INTEL, CARD_INTEL_I945GM, "Mobile Intel(R) 945GM Express Chipset Family", DRIVER_INTEL_GMA950 },
1097 {HW_VENDOR_INTEL, CARD_INTEL_X3100, "Mobile Intel(R) 965 Express Chipset Family", DRIVER_INTEL_GMA3000 }
1099 /* TODO: Add information about legacy ATI hardware and other cards. */
1102 static const struct driver_version_information *get_driver_version_info(enum wined3d_display_driver driver,
1103 enum wined3d_driver_model driver_model)
1107 TRACE("Looking up version info for driver=%d driver_model=%d\n", driver, driver_model);
1108 for (i = 0; i < (sizeof(driver_version_table) / sizeof(driver_version_table[0])); i++)
1110 const struct driver_version_information *entry = &driver_version_table[i];
1112 if (entry->driver == driver && entry->driver_model == driver_model)
1114 TRACE_(d3d_caps)("Found driver '%s' version=%d subversion=%d build=%d\n",
1115 entry->driver_name, entry->version, entry->subversion, entry->build);
1123 static void init_driver_info(struct wined3d_driver_info *driver_info,
1124 enum wined3d_pci_vendor vendor, enum wined3d_pci_device device)
1126 OSVERSIONINFOW os_version;
1127 WORD driver_os_version;
1129 enum wined3d_display_driver driver = DRIVER_UNKNOWN;
1130 enum wined3d_driver_model driver_model;
1131 const struct driver_version_information *version_info;
1133 if (wined3d_settings.pci_vendor_id != PCI_VENDOR_NONE)
1135 TRACE_(d3d_caps)("Overriding PCI vendor ID with: %04x\n", wined3d_settings.pci_vendor_id);
1136 vendor = wined3d_settings.pci_vendor_id;
1138 driver_info->vendor = vendor;
1140 if (wined3d_settings.pci_device_id != PCI_DEVICE_NONE)
1142 TRACE_(d3d_caps)("Overriding PCI device ID with: %04x\n", wined3d_settings.pci_device_id);
1143 device = wined3d_settings.pci_device_id;
1145 driver_info->device = device;
1147 memset(&os_version, 0, sizeof(os_version));
1148 os_version.dwOSVersionInfoSize = sizeof(os_version);
1149 if (!GetVersionExW(&os_version))
1151 ERR("Failed to get OS version, reporting 2000/XP.\n");
1152 driver_os_version = 6;
1153 driver_model = DRIVER_MODEL_NT5X;
1157 TRACE("OS version %u.%u.\n", os_version.dwMajorVersion, os_version.dwMinorVersion);
1158 switch (os_version.dwMajorVersion)
1161 /* If needed we could distinguish between 9x and NT4, but this code won't make
1162 * sense for NT4 since it had no way to obtain this info through DirectDraw 3.0.
1164 driver_os_version = 4;
1165 driver_model = DRIVER_MODEL_WIN9X;
1169 driver_os_version = 6;
1170 driver_model = DRIVER_MODEL_NT5X;
1174 if (os_version.dwMinorVersion == 0)
1176 driver_os_version = 7;
1177 driver_model = DRIVER_MODEL_NT6X;
1181 if (os_version.dwMinorVersion > 1)
1183 FIXME("Unhandled OS version %u.%u, reporting Win 7.\n",
1184 os_version.dwMajorVersion, os_version.dwMinorVersion);
1186 driver_os_version = 8;
1187 driver_model = DRIVER_MODEL_NT6X;
1192 FIXME("Unhandled OS version %u.%u, reporting 2000/XP.\n",
1193 os_version.dwMajorVersion, os_version.dwMinorVersion);
1194 driver_os_version = 6;
1195 driver_model = DRIVER_MODEL_NT5X;
1200 /* When we reach this stage we always have a vendor or device id (it can be a default one).
1201 * This means that unless the ids are overriden, we will always find a GPU description. */
1202 for (i = 0; i < (sizeof(gpu_description_table) / sizeof(gpu_description_table[0])); i++)
1204 if (vendor == gpu_description_table[i].vendor && device == gpu_description_table[i].card)
1206 TRACE_(d3d_caps)("Found card %04x:%04x in driver DB.\n", vendor, device);
1208 driver_info->description = gpu_description_table[i].description;
1209 driver = gpu_description_table[i].driver;
1214 /* Try to obtain driver version information for the current Windows version. This fails in
1216 * - the gpu is not available on the currently selected OS version:
1217 * - Geforce GTX480 on Win98. When running applications in compatibility mode on Windows,
1218 * version information for the current Windows version is returned instead of faked info.
1219 * We do the same and assume the default Windows version to emulate is WinXP.
1221 * - Videocard is a Riva TNT but winver is set to win7 (there are no drivers for this beast)
1222 * For now return the XP driver info. Perhaps later on we should return VESA.
1224 * - the gpu is not in our database (can happen when the user overrides the vendor_id / device_id)
1225 * This could be an indication that our database is not up to date, so this should be fixed.
1227 version_info = get_driver_version_info(driver, driver_model);
1230 driver_info->name = version_info->driver_name;
1231 driver_info->version_high = MAKEDWORD_VERSION(driver_os_version, version_info->version);
1232 driver_info->version_low = MAKEDWORD_VERSION(version_info->subversion, version_info->build);
1236 version_info = get_driver_version_info(driver, DRIVER_MODEL_NT5X);
1239 driver_info->name = version_info->driver_name;
1240 driver_info->version_high = MAKEDWORD_VERSION(driver_os_version, version_info->version);
1241 driver_info->version_low = MAKEDWORD_VERSION(version_info->subversion, version_info->build);
1245 driver_info->description = "Direct3D HAL";
1246 driver_info->name = "Display";
1247 driver_info->version_high = MAKEDWORD_VERSION(driver_os_version, 15);
1248 driver_info->version_low = MAKEDWORD_VERSION(8, 6); /* Nvidia RIVA TNT, arbitrary */
1250 FIXME("Unable to find a driver/device info for vendor_id=%#x device_id=%#x for driver_model=%d\n",
1251 vendor, device, driver_model);
1255 TRACE_(d3d_caps)("Reporting (fake) driver version 0x%08x-0x%08x.\n",
1256 driver_info->version_high, driver_info->version_low);
1259 /* Context activation is done by the caller. */
1260 static void fixup_extensions(struct wined3d_gl_info *gl_info, const char *gl_renderer,
1261 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
1265 for (i = 0; i < (sizeof(quirk_table) / sizeof(*quirk_table)); ++i)
1267 if (!quirk_table[i].match(gl_info, gl_renderer, gl_vendor, card_vendor, device)) continue;
1268 TRACE_(d3d_caps)("Applying driver quirk \"%s\".\n", quirk_table[i].description);
1269 quirk_table[i].apply(gl_info);
1272 /* Find out if PBOs work as they are supposed to. */
1273 test_pbo_functionality(gl_info);
1276 static DWORD wined3d_parse_gl_version(const char *gl_version)
1278 const char *ptr = gl_version;
1282 if (major <= 0) ERR_(d3d_caps)("Invalid opengl major version: %d.\n", major);
1284 while (isdigit(*ptr)) ++ptr;
1285 if (*ptr++ != '.') ERR_(d3d_caps)("Invalid opengl version string: %s.\n", debugstr_a(gl_version));
1289 TRACE_(d3d_caps)("Found OpenGL version: %d.%d.\n", major, minor);
1291 return MAKEDWORD_VERSION(major, minor);
1294 static enum wined3d_gl_vendor wined3d_guess_gl_vendor(struct wined3d_gl_info *gl_info, const char *gl_vendor_string, const char *gl_renderer)
1297 /* MacOS has various specialities in the extensions it advertises. Some have to be loaded from
1298 * the opengl 1.2+ core, while other extensions are advertised, but software emulated. So try to
1299 * detect the Apple OpenGL implementation to apply some extension fixups afterwards.
1301 * Detecting this isn't really easy. The vendor string doesn't mention Apple. Compile-time checks
1302 * aren't sufficient either because a Linux binary may display on a macos X server via remote X11.
1303 * So try to detect the GL implementation by looking at certain Apple extensions. Some extensions
1304 * like client storage might be supported on other implementations too, but GL_APPLE_flush_render
1305 * is specific to the Mac OS X window management, and GL_APPLE_ycbcr_422 is QuickTime specific. So
1306 * the chance that other implementations support them is rather small since Win32 QuickTime uses
1307 * DirectDraw, not OpenGL. */
1308 if (gl_info->supported[APPLE_FENCE]
1309 && gl_info->supported[APPLE_CLIENT_STORAGE]
1310 && gl_info->supported[APPLE_FLUSH_RENDER]
1311 && gl_info->supported[APPLE_YCBCR_422])
1312 return GL_VENDOR_APPLE;
1314 if (strstr(gl_vendor_string, "NVIDIA"))
1315 return GL_VENDOR_NVIDIA;
1317 if (strstr(gl_vendor_string, "ATI"))
1318 return GL_VENDOR_FGLRX;
1320 if (strstr(gl_vendor_string, "Intel(R)")
1321 /* Intel switched from Intel(R) to Intel® recently, so just match Intel. */
1322 || strstr(gl_renderer, "Intel")
1323 || strstr(gl_vendor_string, "Intel Inc."))
1324 return GL_VENDOR_INTEL;
1326 if (strstr(gl_vendor_string, "Mesa")
1327 || strstr(gl_vendor_string, "Advanced Micro Devices, Inc.")
1328 || strstr(gl_vendor_string, "DRI R300 Project")
1329 || strstr(gl_vendor_string, "X.Org R300 Project")
1330 || strstr(gl_vendor_string, "Tungsten Graphics, Inc")
1331 || strstr(gl_vendor_string, "VMware, Inc.")
1332 || strstr(gl_renderer, "Mesa")
1333 || strstr(gl_renderer, "Gallium"))
1334 return GL_VENDOR_MESA;
1336 FIXME_(d3d_caps)("Received unrecognized GL_VENDOR %s. Returning GL_VENDOR_UNKNOWN.\n",
1337 debugstr_a(gl_vendor_string));
1339 return GL_VENDOR_UNKNOWN;
1342 static enum wined3d_pci_vendor wined3d_guess_card_vendor(const char *gl_vendor_string, const char *gl_renderer)
1344 if (strstr(gl_vendor_string, "NVIDIA"))
1345 return HW_VENDOR_NVIDIA;
1347 if (strstr(gl_vendor_string, "ATI")
1348 || strstr(gl_vendor_string, "Advanced Micro Devices, Inc.")
1349 || strstr(gl_vendor_string, "X.Org R300 Project")
1350 || strstr(gl_renderer, "R100")
1351 || strstr(gl_renderer, "R200")
1352 || strstr(gl_renderer, "R300")
1353 || strstr(gl_renderer, "R600")
1354 || strstr(gl_renderer, "R700"))
1355 return HW_VENDOR_ATI;
1357 if (strstr(gl_vendor_string, "Intel(R)")
1358 /* Intel switched from Intel(R) to Intel® recently, so just match Intel. */
1359 || strstr(gl_renderer, "Intel")
1360 || strstr(gl_vendor_string, "Intel Inc."))
1361 return HW_VENDOR_INTEL;
1363 if (strstr(gl_vendor_string, "Mesa")
1364 || strstr(gl_vendor_string, "Tungsten Graphics, Inc")
1365 || strstr(gl_vendor_string, "VMware, Inc."))
1366 return HW_VENDOR_SOFTWARE;
1368 FIXME_(d3d_caps)("Received unrecognized GL_VENDOR %s. Returning HW_VENDOR_NVIDIA.\n", debugstr_a(gl_vendor_string));
1370 return HW_VENDOR_NVIDIA;
1375 static enum wined3d_pci_device select_card_nvidia_binary(const struct wined3d_gl_info *gl_info,
1376 const char *gl_renderer, unsigned int *vidmem)
1378 if (WINE_D3D10_CAPABLE(gl_info))
1380 /* Geforce 400 - highend */
1381 if (strstr(gl_renderer, "GTX 480"))
1384 return CARD_NVIDIA_GEFORCE_GTX480;
1387 /* Geforce 400 - midend high */
1388 if (strstr(gl_renderer, "GTX 470"))
1391 return CARD_NVIDIA_GEFORCE_GTX470;
1394 /* Geforce 400 - midend */
1395 if (strstr(gl_renderer, "GTX 460"))
1397 *vidmem = 768; /* 1024MB model also available */
1398 return CARD_NVIDIA_GEFORCE_GTX460;
1401 /* Geforce 300 highend mobile */
1402 if (strstr(gl_renderer, "GTS 350M")
1403 || strstr(gl_renderer, "GTS 360M"))
1406 return CARD_NVIDIA_GEFORCE_GTS350M;
1409 /* Geforce 300 midend mobile (Geforce GT 325M/330M use the same core) */
1410 if (strstr(gl_renderer, "GT 325M")
1411 || strstr(gl_renderer, "GT 330M"))
1414 return CARD_NVIDIA_GEFORCE_GT325M;
1417 /* Geforce 200 - highend */
1418 if (strstr(gl_renderer, "GTX 280")
1419 || strstr(gl_renderer, "GTX 285")
1420 || strstr(gl_renderer, "GTX 295"))
1423 return CARD_NVIDIA_GEFORCE_GTX280;
1426 /* Geforce 200 - midend high */
1427 if (strstr(gl_renderer, "GTX 275"))
1430 return CARD_NVIDIA_GEFORCE_GTX275;
1433 /* Geforce 200 - midend */
1434 if (strstr(gl_renderer, "GTX 260"))
1437 return CARD_NVIDIA_GEFORCE_GTX260;
1439 /* Geforce 200 - midend */
1440 if (strstr(gl_renderer, "GT 240"))
1443 return CARD_NVIDIA_GEFORCE_GT240;
1446 /* Geforce 200 lowend */
1447 if (strstr(gl_renderer, "GT 220"))
1449 *vidmem = 512; /* The GT 220 has 512-1024MB */
1450 return CARD_NVIDIA_GEFORCE_GT220;
1452 /* Geforce 200 lowend (Geforce 305/310 use the same core) */
1453 if (strstr(gl_renderer, "Geforce 210")
1454 || strstr(gl_renderer, "G 210")
1455 || strstr(gl_renderer, "Geforce 305")
1456 || strstr(gl_renderer, "Geforce 310"))
1459 return CARD_NVIDIA_GEFORCE_210;
1462 /* Geforce9 - highend / Geforce 200 - midend (GTS 150/250 are based on the same core) */
1463 if (strstr(gl_renderer, "9800")
1464 || strstr(gl_renderer, "GTS 150")
1465 || strstr(gl_renderer, "GTS 250"))
1468 return CARD_NVIDIA_GEFORCE_9800GT;
1471 /* Geforce9 - midend (GT 140 uses the same core as the 9600GT) */
1472 if (strstr(gl_renderer, "9600")
1473 || strstr(gl_renderer, "GT 140"))
1475 *vidmem = 384; /* The 9600GSO has 384MB, the 9600GT has 512-1024MB */
1476 return CARD_NVIDIA_GEFORCE_9600GT;
1479 /* Geforce9 - midend low / Geforce 200 - low */
1480 if (strstr(gl_renderer, "9500")
1481 || strstr(gl_renderer, "GT 120")
1482 || strstr(gl_renderer, "GT 130"))
1484 *vidmem = 256; /* The 9500GT has 256-1024MB */
1485 return CARD_NVIDIA_GEFORCE_9500GT;
1488 /* Geforce9 - lowend */
1489 if (strstr(gl_renderer, "9400"))
1491 *vidmem = 256; /* The 9400GT has 256-1024MB */
1492 return CARD_NVIDIA_GEFORCE_9400GT;
1495 /* Geforce9 - lowend low */
1496 if (strstr(gl_renderer, "9100")
1497 || strstr(gl_renderer, "9200")
1498 || strstr(gl_renderer, "9300")
1499 || strstr(gl_renderer, "G 100"))
1501 *vidmem = 256; /* The 9100-9300 cards have 256MB */
1502 return CARD_NVIDIA_GEFORCE_9200;
1505 /* Geforce8 - highend high*/
1506 if (strstr(gl_renderer, "8800 GTX"))
1509 return CARD_NVIDIA_GEFORCE_8800GTX;
1512 /* Geforce8 - highend */
1513 if (strstr(gl_renderer, "8800"))
1515 *vidmem = 320; /* The 8800GTS uses 320MB, a 8800GTX can have 768MB */
1516 return CARD_NVIDIA_GEFORCE_8800GTS;
1519 /* Geforce8 - midend mobile */
1520 if (strstr(gl_renderer, "8600 M"))
1523 return CARD_NVIDIA_GEFORCE_8600MGT;
1526 /* Geforce8 - midend */
1527 if (strstr(gl_renderer, "8600")
1528 || strstr(gl_renderer, "8700"))
1531 return CARD_NVIDIA_GEFORCE_8600GT;
1534 /* Geforce8 - mid-lowend */
1535 if (strstr(gl_renderer, "8400")
1536 || strstr(gl_renderer, "8500"))
1538 *vidmem = 128; /* 128-256MB for a 8400, 256-512MB for a 8500 */
1539 return CARD_NVIDIA_GEFORCE_8400GS;
1542 /* Geforce8 - lowend */
1543 if (strstr(gl_renderer, "8100")
1544 || strstr(gl_renderer, "8200")
1545 || strstr(gl_renderer, "8300"))
1547 *vidmem = 128; /* 128-256MB for a 8300 */
1548 return CARD_NVIDIA_GEFORCE_8300GS;
1551 /* Geforce8-compatible fall back if the GPU is not in the list yet */
1553 return CARD_NVIDIA_GEFORCE_8300GS;
1556 /* Both the GeforceFX, 6xxx and 7xxx series support D3D9. The last two types have more
1557 * shader capabilities, so we use the shader capabilities to distinguish between FX and 6xxx/7xxx.
1559 if (WINE_D3D9_CAPABLE(gl_info) && gl_info->supported[NV_VERTEX_PROGRAM3])
1561 /* Geforce7 - highend */
1562 if (strstr(gl_renderer, "7800")
1563 || strstr(gl_renderer, "7900")
1564 || strstr(gl_renderer, "7950")
1565 || strstr(gl_renderer, "Quadro FX 4")
1566 || strstr(gl_renderer, "Quadro FX 5"))
1568 *vidmem = 256; /* A 7800GT uses 256MB while highend 7900 cards can use 512MB */
1569 return CARD_NVIDIA_GEFORCE_7800GT;
1572 /* Geforce7 midend */
1573 if (strstr(gl_renderer, "7600")
1574 || strstr(gl_renderer, "7700"))
1576 *vidmem = 256; /* The 7600 uses 256-512MB */
1577 return CARD_NVIDIA_GEFORCE_7600;
1580 /* Geforce7 lower medium */
1581 if (strstr(gl_renderer, "7400"))
1583 *vidmem = 256; /* The 7400 uses 256-512MB */
1584 return CARD_NVIDIA_GEFORCE_7400;
1587 /* Geforce7 lowend */
1588 if (strstr(gl_renderer, "7300"))
1590 *vidmem = 256; /* Mac Pros with this card have 256 MB */
1591 return CARD_NVIDIA_GEFORCE_7300;
1594 /* Geforce6 highend */
1595 if (strstr(gl_renderer, "6800"))
1597 *vidmem = 128; /* The 6800 uses 128-256MB, the 7600 uses 256-512MB */
1598 return CARD_NVIDIA_GEFORCE_6800;
1601 /* Geforce6 - midend */
1602 if (strstr(gl_renderer, "6600")
1603 || strstr(gl_renderer, "6610")
1604 || strstr(gl_renderer, "6700"))
1606 *vidmem = 128; /* A 6600GT has 128-256MB */
1607 return CARD_NVIDIA_GEFORCE_6600GT;
1610 /* Geforce6/7 lowend */
1612 return CARD_NVIDIA_GEFORCE_6200; /* Geforce 6100/6150/6200/7300/7400/7500 */
1615 if (WINE_D3D9_CAPABLE(gl_info))
1617 /* GeforceFX - highend */
1618 if (strstr(gl_renderer, "5800")
1619 || strstr(gl_renderer, "5900")
1620 || strstr(gl_renderer, "5950")
1621 || strstr(gl_renderer, "Quadro FX"))
1623 *vidmem = 256; /* 5800-5900 cards use 256MB */
1624 return CARD_NVIDIA_GEFORCEFX_5800;
1627 /* GeforceFX - midend */
1628 if (strstr(gl_renderer, "5600")
1629 || strstr(gl_renderer, "5650")
1630 || strstr(gl_renderer, "5700")
1631 || strstr(gl_renderer, "5750"))
1633 *vidmem = 128; /* A 5600 uses 128-256MB */
1634 return CARD_NVIDIA_GEFORCEFX_5600;
1637 /* GeforceFX - lowend */
1638 *vidmem = 64; /* Normal FX5200 cards use 64-256MB; laptop (non-standard) can have less */
1639 return CARD_NVIDIA_GEFORCEFX_5200; /* GeforceFX 5100/5200/5250/5300/5500 */
1642 if (WINE_D3D8_CAPABLE(gl_info))
1644 if (strstr(gl_renderer, "GeForce4 Ti") || strstr(gl_renderer, "Quadro4"))
1646 *vidmem = 64; /* Geforce4 Ti cards have 64-128MB */
1647 return CARD_NVIDIA_GEFORCE4_TI4200; /* Geforce4 Ti4200/Ti4400/Ti4600/Ti4800, Quadro4 */
1650 *vidmem = 64; /* Geforce3 cards have 64-128MB */
1651 return CARD_NVIDIA_GEFORCE3; /* Geforce3 standard/Ti200/Ti500, Quadro DCC */
1654 if (WINE_D3D7_CAPABLE(gl_info))
1656 if (strstr(gl_renderer, "GeForce4 MX"))
1658 /* Most Geforce4MX GPUs have at least 64MB of memory, some
1659 * early models had 32MB but most have 64MB or even 128MB. */
1661 return CARD_NVIDIA_GEFORCE4_MX; /* MX420/MX440/MX460/MX4000 */
1664 if (strstr(gl_renderer, "GeForce2 MX") || strstr(gl_renderer, "Quadro2 MXR"))
1666 *vidmem = 32; /* Geforce2MX GPUs have 32-64MB of video memory */
1667 return CARD_NVIDIA_GEFORCE2_MX; /* Geforce2 standard/MX100/MX200/MX400, Quadro2 MXR */
1670 if (strstr(gl_renderer, "GeForce2") || strstr(gl_renderer, "Quadro2"))
1672 *vidmem = 32; /* Geforce2 GPUs have 32-64MB of video memory */
1673 return CARD_NVIDIA_GEFORCE2; /* Geforce2 GTS/Pro/Ti/Ultra, Quadro2 */
1676 /* Most Geforce1 cards have 32MB, there are also some rare 16
1677 * and 64MB (Dell) models. */
1679 return CARD_NVIDIA_GEFORCE; /* Geforce 256/DDR, Quadro */
1682 if (strstr(gl_renderer, "TNT2"))
1684 *vidmem = 32; /* Most TNT2 boards have 32MB, though there are 16MB boards too */
1685 return CARD_NVIDIA_RIVA_TNT2; /* Riva TNT2 standard/M64/Pro/Ultra */
1688 *vidmem = 16; /* Most TNT boards have 16MB, some rare models have 8MB */
1689 return CARD_NVIDIA_RIVA_TNT; /* Riva TNT, Vanta */
1693 static enum wined3d_pci_device select_card_ati_binary(const struct wined3d_gl_info *gl_info,
1694 const char *gl_renderer, unsigned int *vidmem)
1696 /* See http://developer.amd.com/drivers/pc_vendor_id/Pages/default.aspx
1698 * Beware: renderer string do not match exact card model,
1699 * eg HD 4800 is returned for multiple cards, even for RV790 based ones. */
1700 if (WINE_D3D10_CAPABLE(gl_info))
1702 /* Radeon EG CYPRESS XT / PRO HD5800 - highend */
1703 if (strstr(gl_renderer, "HD 5800") /* Radeon EG CYPRESS HD58xx generic renderer string */
1704 || strstr(gl_renderer, "HD 5850") /* Radeon EG CYPRESS XT */
1705 || strstr(gl_renderer, "HD 5870")) /* Radeon EG CYPRESS PRO */
1707 *vidmem = 1024; /* note: HD58xx cards use 1024MB */
1708 return CARD_ATI_RADEON_HD5800;
1711 /* Radeon EG JUNIPER XT / LE HD5700 - midend */
1712 if (strstr(gl_renderer, "HD 5700") /* Radeon EG JUNIPER HD57xx generic renderer string */
1713 || strstr(gl_renderer, "HD 5750") /* Radeon EG JUNIPER LE */
1714 || strstr(gl_renderer, "HD 5770")) /* Radeon EG JUNIPER XT */
1716 *vidmem = 512; /* note: HD5770 cards use 1024MB and HD5750 cards use 512MB or 1024MB */
1717 return CARD_ATI_RADEON_HD5700;
1720 /* Radeon R7xx HD4800 - highend */
1721 if (strstr(gl_renderer, "HD 4800") /* Radeon RV7xx HD48xx generic renderer string */
1722 || strstr(gl_renderer, "HD 4830") /* Radeon RV770 */
1723 || strstr(gl_renderer, "HD 4850") /* Radeon RV770 */
1724 || strstr(gl_renderer, "HD 4870") /* Radeon RV770 */
1725 || strstr(gl_renderer, "HD 4890")) /* Radeon RV790 */
1727 *vidmem = 512; /* note: HD4890 cards use 1024MB */
1728 return CARD_ATI_RADEON_HD4800;
1731 /* Radeon R740 HD4700 - midend */
1732 if (strstr(gl_renderer, "HD 4700") /* Radeon RV770 */
1733 || strstr(gl_renderer, "HD 4770")) /* Radeon RV740 */
1736 return CARD_ATI_RADEON_HD4700;
1739 /* Radeon R730 HD4600 - midend */
1740 if (strstr(gl_renderer, "HD 4600") /* Radeon RV730 */
1741 || strstr(gl_renderer, "HD 4650") /* Radeon RV730 */
1742 || strstr(gl_renderer, "HD 4670")) /* Radeon RV730 */
1745 return CARD_ATI_RADEON_HD4600;
1748 /* Radeon R710 HD4500/HD4350 - lowend */
1749 if (strstr(gl_renderer, "HD 4350") /* Radeon RV710 */
1750 || strstr(gl_renderer, "HD 4550")) /* Radeon RV710 */
1753 return CARD_ATI_RADEON_HD4350;
1756 /* Radeon R6xx HD2900/HD3800 - highend */
1757 if (strstr(gl_renderer, "HD 2900")
1758 || strstr(gl_renderer, "HD 3870")
1759 || strstr(gl_renderer, "HD 3850"))
1761 *vidmem = 512; /* HD2900/HD3800 uses 256-1024MB */
1762 return CARD_ATI_RADEON_HD2900;
1765 /* Radeon R6xx HD2600/HD3600 - midend; HD3830 is China-only midend */
1766 if (strstr(gl_renderer, "HD 2600")
1767 || strstr(gl_renderer, "HD 3830")
1768 || strstr(gl_renderer, "HD 3690")
1769 || strstr(gl_renderer, "HD 3650"))
1771 *vidmem = 256; /* HD2600/HD3600 uses 256-512MB */
1772 return CARD_ATI_RADEON_HD2600;
1775 /* Radeon R6xx HD2350/HD2400/HD3400 - lowend
1776 * Note HD2300=DX9, HD2350=DX10 */
1777 if (strstr(gl_renderer, "HD 2350")
1778 || strstr(gl_renderer, "HD 2400")
1779 || strstr(gl_renderer, "HD 3470")
1780 || strstr(gl_renderer, "HD 3450")
1781 || strstr(gl_renderer, "HD 3430")
1782 || strstr(gl_renderer, "HD 3400"))
1784 *vidmem = 256; /* HD2350/2400 use 256MB, HD34xx use 256-512MB */
1785 return CARD_ATI_RADEON_HD2350;
1788 /* Radeon R6xx/R7xx integrated */
1789 if (strstr(gl_renderer, "HD 3100")
1790 || strstr(gl_renderer, "HD 3200")
1791 || strstr(gl_renderer, "HD 3300"))
1793 *vidmem = 128; /* 128MB */
1794 return CARD_ATI_RADEON_HD3200;
1797 /* Default for when no GPU has been found */
1798 *vidmem = 128; /* 128MB */
1799 return CARD_ATI_RADEON_HD3200;
1802 if (WINE_D3D8_CAPABLE(gl_info))
1805 if (strstr(gl_renderer, "X1600")
1806 || strstr(gl_renderer, "X1650")
1807 || strstr(gl_renderer, "X1800")
1808 || strstr(gl_renderer, "X1900")
1809 || strstr(gl_renderer, "X1950"))
1811 *vidmem = 128; /* X1600 uses 128-256MB, >=X1800 uses 256MB */
1812 return CARD_ATI_RADEON_X1600;
1815 /* Radeon R4xx + X1300/X1400/X1450/X1550/X2300/X2500/HD2300 (lowend R5xx)
1816 * Note X2300/X2500/HD2300 are R5xx GPUs with a 2xxx naming but they are still DX9-only */
1817 if (strstr(gl_renderer, "X700")
1818 || strstr(gl_renderer, "X800")
1819 || strstr(gl_renderer, "X850")
1820 || strstr(gl_renderer, "X1300")
1821 || strstr(gl_renderer, "X1400")
1822 || strstr(gl_renderer, "X1450")
1823 || strstr(gl_renderer, "X1550")
1824 || strstr(gl_renderer, "X2300")
1825 || strstr(gl_renderer, "X2500")
1826 || strstr(gl_renderer, "HD 2300")
1829 *vidmem = 128; /* x700/x8*0 use 128-256MB, >=x1300 128-512MB */
1830 return CARD_ATI_RADEON_X700;
1833 /* Radeon Xpress Series - onboard, DX9b, Shader 2.0, 300-400MHz */
1834 if (strstr(gl_renderer, "Radeon Xpress"))
1836 *vidmem = 64; /* Shared RAM, BIOS configurable, 64-256M */
1837 return CARD_ATI_RADEON_XPRESS_200M;
1841 *vidmem = 64; /* Radeon 9500 uses 64MB, higher models use up to 256MB */
1842 return CARD_ATI_RADEON_9500; /* Radeon 9500/9550/9600/9700/9800/X300/X550/X600 */
1845 if (WINE_D3D8_CAPABLE(gl_info))
1847 *vidmem = 64; /* 8500/9000 cards use mostly 64MB, though there are 32MB and 128MB models */
1848 return CARD_ATI_RADEON_8500; /* Radeon 8500/9000/9100/9200/9300 */
1851 if (WINE_D3D7_CAPABLE(gl_info))
1853 *vidmem = 32; /* There are models with up to 64MB */
1854 return CARD_ATI_RADEON_7200; /* Radeon 7000/7100/7200/7500 */
1857 *vidmem = 16; /* There are 16-32MB models */
1858 return CARD_ATI_RAGE_128PRO;
1862 static enum wined3d_pci_device select_card_intel_binary(const struct wined3d_gl_info *gl_info,
1863 const char *gl_renderer, unsigned int *vidmem)
1865 if (strstr(gl_renderer, "X3100"))
1867 /* MacOS calls the card GMA X3100, otherwise known as GM965/GL960 */
1869 return CARD_INTEL_X3100;
1872 if (strstr(gl_renderer, "GMA 950") || strstr(gl_renderer, "945GM"))
1874 /* MacOS calls the card GMA 950, but everywhere else the PCI ID is named 945GM */
1876 return CARD_INTEL_I945GM;
1879 if (strstr(gl_renderer, "915GM")) return CARD_INTEL_I915GM;
1880 if (strstr(gl_renderer, "915G")) return CARD_INTEL_I915G;
1881 if (strstr(gl_renderer, "865G")) return CARD_INTEL_I865G;
1882 if (strstr(gl_renderer, "855G")) return CARD_INTEL_I855G;
1883 if (strstr(gl_renderer, "830G")) return CARD_INTEL_I830G;
1884 return CARD_INTEL_I915G;
1888 static enum wined3d_pci_device select_card_ati_mesa(const struct wined3d_gl_info *gl_info,
1889 const char *gl_renderer, unsigned int *vidmem)
1891 /* See http://developer.amd.com/drivers/pc_vendor_id/Pages/default.aspx
1893 * Beware: renderer string do not match exact card model,
1894 * eg HD 4800 is returned for multiple cards, even for RV790 based ones. */
1895 if (strstr(gl_renderer, "Gallium"))
1897 /* Radeon R7xx HD4800 - highend */
1898 if (strstr(gl_renderer, "R700") /* Radeon R7xx HD48xx generic renderer string */
1899 || strstr(gl_renderer, "RV770") /* Radeon RV770 */
1900 || strstr(gl_renderer, "RV790")) /* Radeon RV790 */
1902 *vidmem = 512; /* note: HD4890 cards use 1024MB */
1903 return CARD_ATI_RADEON_HD4800;
1906 /* Radeon R740 HD4700 - midend */
1907 if (strstr(gl_renderer, "RV740")) /* Radeon RV740 */
1910 return CARD_ATI_RADEON_HD4700;
1913 /* Radeon R730 HD4600 - midend */
1914 if (strstr(gl_renderer, "RV730")) /* Radeon RV730 */
1917 return CARD_ATI_RADEON_HD4600;
1920 /* Radeon R710 HD4500/HD4350 - lowend */
1921 if (strstr(gl_renderer, "RV710")) /* Radeon RV710 */
1924 return CARD_ATI_RADEON_HD4350;
1927 /* Radeon R6xx HD2900/HD3800 - highend */
1928 if (strstr(gl_renderer, "R600")
1929 || strstr(gl_renderer, "RV670")
1930 || strstr(gl_renderer, "R680"))
1932 *vidmem = 512; /* HD2900/HD3800 uses 256-1024MB */
1933 return CARD_ATI_RADEON_HD2900;
1936 /* Radeon R6xx HD2600/HD3600 - midend; HD3830 is China-only midend */
1937 if (strstr(gl_renderer, "RV630")
1938 || strstr(gl_renderer, "RV635"))
1940 *vidmem = 256; /* HD2600/HD3600 uses 256-512MB */
1941 return CARD_ATI_RADEON_HD2600;
1944 /* Radeon R6xx HD2350/HD2400/HD3400 - lowend */
1945 if (strstr(gl_renderer, "RV610")
1946 || strstr(gl_renderer, "RV620"))
1948 *vidmem = 256; /* HD2350/2400 use 256MB, HD34xx use 256-512MB */
1949 return CARD_ATI_RADEON_HD2350;
1952 /* Radeon R6xx/R7xx integrated */
1953 if (strstr(gl_renderer, "RS780")
1954 || strstr(gl_renderer, "RS880"))
1956 *vidmem = 128; /* 128MB */
1957 return CARD_ATI_RADEON_HD3200;
1961 if (strstr(gl_renderer, "RV530")
1962 || strstr(gl_renderer, "RV535")
1963 || strstr(gl_renderer, "RV560")
1964 || strstr(gl_renderer, "R520")
1965 || strstr(gl_renderer, "RV570")
1966 || strstr(gl_renderer, "R580"))
1968 *vidmem = 128; /* X1600 uses 128-256MB, >=X1800 uses 256MB */
1969 return CARD_ATI_RADEON_X1600;
1972 /* Radeon R4xx + X1300/X1400/X1450/X1550/X2300 (lowend R5xx) */
1973 if (strstr(gl_renderer, "R410")
1974 || strstr(gl_renderer, "R420")
1975 || strstr(gl_renderer, "R423")
1976 || strstr(gl_renderer, "R430")
1977 || strstr(gl_renderer, "R480")
1978 || strstr(gl_renderer, "R481")
1979 || strstr(gl_renderer, "RV410")
1980 || strstr(gl_renderer, "RV515")
1981 || strstr(gl_renderer, "RV516"))
1983 *vidmem = 128; /* x700/x8*0 use 128-256MB, >=x1300 128-512MB */
1984 return CARD_ATI_RADEON_X700;
1987 /* Radeon Xpress Series - onboard, DX9b, Shader 2.0, 300-400MHz */
1988 if (strstr(gl_renderer, "RS400")
1989 || strstr(gl_renderer, "RS480")
1990 || strstr(gl_renderer, "RS482")
1991 || strstr(gl_renderer, "RS485")
1992 || strstr(gl_renderer, "RS600")
1993 || strstr(gl_renderer, "RS690")
1994 || strstr(gl_renderer, "RS740"))
1996 *vidmem = 64; /* Shared RAM, BIOS configurable, 64-256M */
1997 return CARD_ATI_RADEON_XPRESS_200M;
2001 if (strstr(gl_renderer, "R300")
2002 || strstr(gl_renderer, "RV350")
2003 || strstr(gl_renderer, "RV351")
2004 || strstr(gl_renderer, "RV360")
2005 || strstr(gl_renderer, "RV370")
2006 || strstr(gl_renderer, "R350")
2007 || strstr(gl_renderer, "R360"))
2009 *vidmem = 64; /* Radeon 9500 uses 64MB, higher models use up to 256MB */
2010 return CARD_ATI_RADEON_9500; /* Radeon 9500/9550/9600/9700/9800/X300/X550/X600 */
2014 if (WINE_D3D9_CAPABLE(gl_info))
2016 /* Radeon R7xx HD4800 - highend */
2017 if (strstr(gl_renderer, "(R700") /* Radeon R7xx HD48xx generic renderer string */
2018 || strstr(gl_renderer, "(RV770") /* Radeon RV770 */
2019 || strstr(gl_renderer, "(RV790")) /* Radeon RV790 */
2021 *vidmem = 512; /* note: HD4890 cards use 1024MB */
2022 return CARD_ATI_RADEON_HD4800;
2025 /* Radeon R740 HD4700 - midend */
2026 if (strstr(gl_renderer, "(RV740")) /* Radeon RV740 */
2029 return CARD_ATI_RADEON_HD4700;
2032 /* Radeon R730 HD4600 - midend */
2033 if (strstr(gl_renderer, "(RV730")) /* Radeon RV730 */
2036 return CARD_ATI_RADEON_HD4600;
2039 /* Radeon R710 HD4500/HD4350 - lowend */
2040 if (strstr(gl_renderer, "(RV710")) /* Radeon RV710 */
2043 return CARD_ATI_RADEON_HD4350;
2046 /* Radeon R6xx HD2900/HD3800 - highend */
2047 if (strstr(gl_renderer, "(R600")
2048 || strstr(gl_renderer, "(RV670")
2049 || strstr(gl_renderer, "(R680"))
2051 *vidmem = 512; /* HD2900/HD3800 uses 256-1024MB */
2052 return CARD_ATI_RADEON_HD2900;
2055 /* Radeon R6xx HD2600/HD3600 - midend; HD3830 is China-only midend */
2056 if (strstr(gl_renderer, "(RV630")
2057 || strstr(gl_renderer, "(RV635"))
2059 *vidmem = 256; /* HD2600/HD3600 uses 256-512MB */
2060 return CARD_ATI_RADEON_HD2600;
2063 /* Radeon R6xx HD2300/HD2400/HD3400 - lowend */
2064 if (strstr(gl_renderer, "(RV610")
2065 || strstr(gl_renderer, "(RV620"))
2067 *vidmem = 256; /* HD2350/2400 use 256MB, HD34xx use 256-512MB */
2068 return CARD_ATI_RADEON_HD2350;
2071 /* Radeon R6xx/R7xx integrated */
2072 if (strstr(gl_renderer, "(RS780")
2073 || strstr(gl_renderer, "(RS880"))
2075 *vidmem = 128; /* 128MB */
2076 return CARD_ATI_RADEON_HD3200;
2080 if (WINE_D3D8_CAPABLE(gl_info))
2082 *vidmem = 64; /* 8500/9000 cards use mostly 64MB, though there are 32MB and 128MB models */
2083 return CARD_ATI_RADEON_8500; /* Radeon 8500/9000/9100/9200/9300 */
2086 if (WINE_D3D7_CAPABLE(gl_info))
2088 *vidmem = 32; /* There are models with up to 64MB */
2089 return CARD_ATI_RADEON_7200; /* Radeon 7000/7100/7200/7500 */
2092 *vidmem = 16; /* There are 16-32MB models */
2093 return CARD_ATI_RAGE_128PRO;
2097 static enum wined3d_pci_device select_card_nvidia_mesa(const struct wined3d_gl_info *gl_info,
2098 const char *gl_renderer, unsigned int *vidmem)
2100 FIXME_(d3d_caps)("Card selection not handled for Mesa Nouveau driver\n");
2101 if (WINE_D3D9_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCEFX_5600;
2102 if (WINE_D3D8_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCE3;
2103 if (WINE_D3D7_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCE;
2104 if (WINE_D3D6_CAPABLE(gl_info)) return CARD_NVIDIA_RIVA_TNT;
2105 return CARD_NVIDIA_RIVA_128;
2108 static enum wined3d_pci_device select_card_intel_mesa(const struct wined3d_gl_info *gl_info,
2109 const char *gl_renderer, unsigned int *vidmem)
2111 FIXME_(d3d_caps)("Card selection not handled for Mesa Intel driver\n");
2112 return CARD_INTEL_I915G;
2116 struct vendor_card_selection
2118 enum wined3d_gl_vendor gl_vendor;
2119 enum wined3d_pci_vendor card_vendor;
2120 const char *description; /* Description of the card selector i.e. Apple OS/X Intel */
2121 enum wined3d_pci_device (*select_card)(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
2122 unsigned int *vidmem );
2125 static const struct vendor_card_selection vendor_card_select_table[] =
2127 {GL_VENDOR_NVIDIA, HW_VENDOR_NVIDIA, "Nvidia binary driver", select_card_nvidia_binary},
2128 {GL_VENDOR_APPLE, HW_VENDOR_NVIDIA, "Apple OSX NVidia binary driver", select_card_nvidia_binary},
2129 {GL_VENDOR_APPLE, HW_VENDOR_ATI, "Apple OSX AMD/ATI binary driver", select_card_ati_binary},
2130 {GL_VENDOR_APPLE, HW_VENDOR_INTEL, "Apple OSX Intel binary driver", select_card_intel_binary},
2131 {GL_VENDOR_FGLRX, HW_VENDOR_ATI, "AMD/ATI binary driver", select_card_ati_binary},
2132 {GL_VENDOR_MESA, HW_VENDOR_ATI, "Mesa AMD/ATI driver", select_card_ati_mesa},
2133 {GL_VENDOR_MESA, HW_VENDOR_NVIDIA, "Mesa Nouveau driver", select_card_nvidia_mesa},
2134 {GL_VENDOR_MESA, HW_VENDOR_INTEL, "Mesa Intel driver", select_card_intel_mesa},
2135 {GL_VENDOR_INTEL, HW_VENDOR_INTEL, "Mesa Intel driver", select_card_intel_mesa}
2139 static enum wined3d_pci_device wined3d_guess_card(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
2140 enum wined3d_gl_vendor *gl_vendor, enum wined3d_pci_vendor *card_vendor, unsigned int *vidmem)
2142 /* Above is a list of Nvidia and ATI GPUs. Both vendors have dozens of
2143 * different GPUs with roughly the same features. In most cases GPUs from a
2144 * certain family differ in clockspeeds, the amount of video memory and the
2145 * number of shader pipelines.
2147 * A Direct3D device object contains the PCI id (vendor + device) of the
2148 * videocard which is used for rendering. Various applications use this
2149 * information to get a rough estimation of the features of the card and
2150 * some might use it for enabling 3d effects only on certain types of
2151 * videocards. In some cases games might even use it to work around bugs
2152 * which happen on certain videocards/driver combinations. The problem is
2153 * that OpenGL only exposes a rendering string containing the name of the
2154 * videocard and not the PCI id.
2156 * Various games depend on the PCI id, so somehow we need to provide one.
2157 * A simple option is to parse the renderer string and translate this to
2158 * the right PCI id. This is a lot of work because there are more than 200
2159 * GPUs just for Nvidia. Various cards share the same renderer string, so
2160 * the amount of code might be 'small' but there are quite a number of
2161 * exceptions which would make this a pain to maintain. Another way would
2162 * be to query the PCI id from the operating system (assuming this is the
2163 * videocard which is used for rendering which is not always the case).
2164 * This would work but it is not very portable. Second it would not work
2165 * well in, let's say, a remote X situation in which the amount of 3d
2166 * features which can be used is limited.
2168 * As said most games only use the PCI id to get an indication of the
2169 * capabilities of the card. It doesn't really matter if the given id is
2170 * the correct one if we return the id of a card with similar 3d features.
2172 * The code below checks the OpenGL capabilities of a videocard and matches
2173 * that to a certain level of Direct3D functionality. Once a card passes
2174 * the Direct3D9 check, we know that the card (in case of Nvidia) is at
2175 * least a GeforceFX. To give a better estimate we do a basic check on the
2176 * renderer string but if that won't pass we return a default card. This
2177 * way is better than maintaining a full card database as even without a
2178 * full database we can return a card with similar features. Second the
2179 * size of the database can be made quite small because when you know what
2180 * type of 3d functionality a card has, you know to which GPU family the
2181 * GPU must belong. Because of this you only have to check a small part of
2182 * the renderer string to distinguishes between different models from that
2185 * The code also selects a default amount of video memory which we will
2186 * use for an estimation of the amount of free texture memory. In case of
2187 * real D3D the amount of texture memory includes video memory and system
2188 * memory (to be specific AGP memory or in case of PCIE TurboCache /
2189 * HyperMemory). We don't know how much system memory can be addressed by
2190 * the system but we can make a reasonable estimation about the amount of
2191 * video memory. If the value is slightly wrong it doesn't matter as we
2192 * didn't include AGP-like memory which makes the amount of addressable
2193 * memory higher and second OpenGL isn't that critical it moves to system
2194 * memory behind our backs if really needed. Note that the amount of video
2195 * memory can be overruled using a registry setting. */
2199 for (i = 0; i < (sizeof(vendor_card_select_table) / sizeof(*vendor_card_select_table)); ++i)
2201 if ((vendor_card_select_table[i].gl_vendor != *gl_vendor)
2202 || (vendor_card_select_table[i].card_vendor != *card_vendor))
2204 TRACE_(d3d_caps)("Applying card_selector \"%s\".\n", vendor_card_select_table[i].description);
2205 return vendor_card_select_table[i].select_card(gl_info, gl_renderer, vidmem);
2208 FIXME_(d3d_caps)("No card selector available for GL vendor %d and card vendor %04x.\n",
2209 *gl_vendor, *card_vendor);
2211 /* Default to generic Nvidia hardware based on the supported OpenGL extensions. The choice
2212 * for Nvidia was because the hardware and drivers they make are of good quality. This makes
2213 * them a good generic choice. */
2214 *card_vendor = HW_VENDOR_NVIDIA;
2215 if (WINE_D3D9_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCEFX_5600;
2216 if (WINE_D3D8_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCE3;
2217 if (WINE_D3D7_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCE;
2218 if (WINE_D3D6_CAPABLE(gl_info)) return CARD_NVIDIA_RIVA_TNT;
2219 return CARD_NVIDIA_RIVA_128;
2222 static const struct fragment_pipeline *select_fragment_implementation(struct wined3d_adapter *adapter)
2224 const struct wined3d_gl_info *gl_info = &adapter->gl_info;
2225 int vs_selected_mode, ps_selected_mode;
2227 select_shader_mode(gl_info, &ps_selected_mode, &vs_selected_mode);
2228 if ((ps_selected_mode == SHADER_ARB || ps_selected_mode == SHADER_GLSL)
2229 && gl_info->supported[ARB_FRAGMENT_PROGRAM]) return &arbfp_fragment_pipeline;
2230 else if (ps_selected_mode == SHADER_ATI) return &atifs_fragment_pipeline;
2231 else if (gl_info->supported[NV_REGISTER_COMBINERS]
2232 && gl_info->supported[NV_TEXTURE_SHADER2]) return &nvts_fragment_pipeline;
2233 else if (gl_info->supported[NV_REGISTER_COMBINERS]) return &nvrc_fragment_pipeline;
2234 else return &ffp_fragment_pipeline;
2237 static const shader_backend_t *select_shader_backend(struct wined3d_adapter *adapter)
2239 int vs_selected_mode, ps_selected_mode;
2241 select_shader_mode(&adapter->gl_info, &ps_selected_mode, &vs_selected_mode);
2242 if (vs_selected_mode == SHADER_GLSL || ps_selected_mode == SHADER_GLSL) return &glsl_shader_backend;
2243 if (vs_selected_mode == SHADER_ARB || ps_selected_mode == SHADER_ARB) return &arb_program_shader_backend;
2244 return &none_shader_backend;
2247 static const struct blit_shader *select_blit_implementation(struct wined3d_adapter *adapter)
2249 const struct wined3d_gl_info *gl_info = &adapter->gl_info;
2250 int vs_selected_mode, ps_selected_mode;
2252 select_shader_mode(gl_info, &ps_selected_mode, &vs_selected_mode);
2253 if ((ps_selected_mode == SHADER_ARB || ps_selected_mode == SHADER_GLSL)
2254 && gl_info->supported[ARB_FRAGMENT_PROGRAM]) return &arbfp_blit;
2255 else return &ffp_blit;
2258 /* Context activation is done by the caller. */
2259 static BOOL IWineD3DImpl_FillGLCaps(struct wined3d_adapter *adapter)
2261 struct wined3d_driver_info *driver_info = &adapter->driver_info;
2262 struct wined3d_gl_info *gl_info = &adapter->gl_info;
2263 const char *GL_Extensions = NULL;
2264 const char *WGL_Extensions = NULL;
2265 const char *gl_vendor_str, *gl_renderer_str, *gl_version_str;
2266 struct fragment_caps fragment_caps;
2267 enum wined3d_gl_vendor gl_vendor;
2268 enum wined3d_pci_vendor card_vendor;
2269 enum wined3d_pci_device device;
2271 GLfloat gl_floatv[2];
2274 unsigned int vidmem=0;
2278 TRACE_(d3d_caps)("(%p)\n", gl_info);
2282 gl_renderer_str = (const char *)glGetString(GL_RENDERER);
2283 TRACE_(d3d_caps)("GL_RENDERER: %s.\n", debugstr_a(gl_renderer_str));
2284 if (!gl_renderer_str)
2287 ERR_(d3d_caps)("Received a NULL GL_RENDERER.\n");
2291 gl_vendor_str = (const char *)glGetString(GL_VENDOR);
2292 TRACE_(d3d_caps)("GL_VENDOR: %s.\n", debugstr_a(gl_vendor_str));
2296 ERR_(d3d_caps)("Received a NULL GL_VENDOR.\n");
2300 /* Parse the GL_VERSION field into major and minor information */
2301 gl_version_str = (const char *)glGetString(GL_VERSION);
2302 TRACE_(d3d_caps)("GL_VERSION: %s.\n", debugstr_a(gl_version_str));
2303 if (!gl_version_str)
2306 ERR_(d3d_caps)("Received a NULL GL_VERSION.\n");
2309 gl_version = wined3d_parse_gl_version(gl_version_str);
2312 * Initialize openGL extension related variables
2313 * with Default values
2315 memset(gl_info->supported, 0, sizeof(gl_info->supported));
2316 gl_info->limits.blends = 1;
2317 gl_info->limits.buffers = 1;
2318 gl_info->limits.textures = 1;
2319 gl_info->limits.fragment_samplers = 1;
2320 gl_info->limits.vertex_samplers = 0;
2321 gl_info->limits.combined_samplers = gl_info->limits.fragment_samplers + gl_info->limits.vertex_samplers;
2322 gl_info->limits.sampler_stages = 1;
2323 gl_info->limits.glsl_vs_float_constants = 0;
2324 gl_info->limits.glsl_ps_float_constants = 0;
2325 gl_info->limits.arb_vs_float_constants = 0;
2326 gl_info->limits.arb_vs_native_constants = 0;
2327 gl_info->limits.arb_vs_instructions = 0;
2328 gl_info->limits.arb_vs_temps = 0;
2329 gl_info->limits.arb_ps_float_constants = 0;
2330 gl_info->limits.arb_ps_local_constants = 0;
2331 gl_info->limits.arb_ps_instructions = 0;
2332 gl_info->limits.arb_ps_temps = 0;
2334 /* Retrieve opengl defaults */
2335 glGetIntegerv(GL_MAX_CLIP_PLANES, &gl_max);
2336 gl_info->limits.clipplanes = min(WINED3DMAXUSERCLIPPLANES, gl_max);
2337 TRACE_(d3d_caps)("ClipPlanes support - num Planes=%d\n", gl_max);
2339 glGetIntegerv(GL_MAX_LIGHTS, &gl_max);
2340 gl_info->limits.lights = gl_max;
2341 TRACE_(d3d_caps)("Lights support - max lights=%d\n", gl_max);
2343 glGetIntegerv(GL_MAX_TEXTURE_SIZE, &gl_max);
2344 gl_info->limits.texture_size = gl_max;
2345 TRACE_(d3d_caps)("Maximum texture size support - max texture size=%d\n", gl_max);
2347 glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, gl_floatv);
2348 gl_info->limits.pointsize_min = gl_floatv[0];
2349 gl_info->limits.pointsize_max = gl_floatv[1];
2350 TRACE_(d3d_caps)("Maximum point size support - max point size=%f\n", gl_floatv[1]);
2352 /* Parse the gl supported features, in theory enabling parts of our code appropriately. */
2353 GL_Extensions = (const char *)glGetString(GL_EXTENSIONS);
2357 ERR_(d3d_caps)("Received a NULL GL_EXTENSIONS.\n");
2363 TRACE_(d3d_caps)("GL_Extensions reported:\n");
2365 gl_info->supported[WINED3D_GL_EXT_NONE] = TRUE;
2367 while (*GL_Extensions)
2371 while (isspace(*GL_Extensions)) ++GL_Extensions;
2372 start = GL_Extensions;
2373 while (!isspace(*GL_Extensions) && *GL_Extensions) ++GL_Extensions;
2375 len = GL_Extensions - start;
2378 TRACE_(d3d_caps)("- %s\n", debugstr_an(start, len));
2380 for (i = 0; i < (sizeof(EXTENSION_MAP) / sizeof(*EXTENSION_MAP)); ++i)
2382 if (len == strlen(EXTENSION_MAP[i].extension_string)
2383 && !memcmp(start, EXTENSION_MAP[i].extension_string, len))
2385 TRACE_(d3d_caps)(" FOUND: %s support.\n", EXTENSION_MAP[i].extension_string);
2386 gl_info->supported[EXTENSION_MAP[i].extension] = TRUE;
2392 /* Now work out what GL support this card really has */
2393 #define USE_GL_FUNC(type, pfn, ext, replace) \
2395 DWORD ver = ver_for_ext(ext); \
2396 if (gl_info->supported[ext]) gl_info->pfn = (type)pwglGetProcAddress(#pfn); \
2397 else if (ver && ver <= gl_version) gl_info->pfn = (type)pwglGetProcAddress(#replace); \
2398 else gl_info->pfn = NULL; \
2403 #define USE_GL_FUNC(type, pfn, ext, replace) gl_info->pfn = (type)pwglGetProcAddress(#pfn);
2409 /* Now mark all the extensions supported which are included in the opengl core version. Do this *after*
2410 * loading the functions, otherwise the code above will load the extension entry points instead of the
2411 * core functions, which may not work. */
2412 for (i = 0; i < (sizeof(EXTENSION_MAP) / sizeof(*EXTENSION_MAP)); ++i)
2414 if (!gl_info->supported[EXTENSION_MAP[i].extension]
2415 && EXTENSION_MAP[i].version <= gl_version && EXTENSION_MAP[i].version)
2417 TRACE_(d3d_caps)(" GL CORE: %s support.\n", EXTENSION_MAP[i].extension_string);
2418 gl_info->supported[EXTENSION_MAP[i].extension] = TRUE;
2422 if (gl_version >= MAKEDWORD_VERSION(2, 0)) gl_info->supported[WINED3D_GL_VERSION_2_0] = TRUE;
2424 if (gl_info->supported[APPLE_FENCE])
2426 /* GL_NV_fence and GL_APPLE_fence provide the same functionality basically.
2427 * The apple extension interacts with some other apple exts. Disable the NV
2428 * extension if the apple one is support to prevent confusion in other parts
2430 gl_info->supported[NV_FENCE] = FALSE;
2432 if (gl_info->supported[APPLE_FLOAT_PIXELS])
2434 /* GL_APPLE_float_pixels == GL_ARB_texture_float + GL_ARB_half_float_pixel
2436 * The enums are the same:
2437 * GL_RGBA16F_ARB = GL_RGBA_FLOAT16_APPLE = 0x881A
2438 * GL_RGB16F_ARB = GL_RGB_FLOAT16_APPLE = 0x881B
2439 * GL_RGBA32F_ARB = GL_RGBA_FLOAT32_APPLE = 0x8814
2440 * GL_RGB32F_ARB = GL_RGB_FLOAT32_APPLE = 0x8815
2441 * GL_HALF_FLOAT_ARB = GL_HALF_APPLE = 0x140B
2443 if (!gl_info->supported[ARB_TEXTURE_FLOAT])
2445 TRACE_(d3d_caps)(" IMPLIED: GL_ARB_texture_float support(from GL_APPLE_float_pixels.\n");
2446 gl_info->supported[ARB_TEXTURE_FLOAT] = TRUE;
2448 if (!gl_info->supported[ARB_HALF_FLOAT_PIXEL])
2450 TRACE_(d3d_caps)(" IMPLIED: GL_ARB_half_float_pixel support(from GL_APPLE_float_pixels.\n");
2451 gl_info->supported[ARB_HALF_FLOAT_PIXEL] = TRUE;
2454 if (gl_info->supported[ARB_MAP_BUFFER_RANGE])
2456 /* GL_ARB_map_buffer_range and GL_APPLE_flush_buffer_range provide the same
2457 * functionality. Prefer the ARB extension */
2458 gl_info->supported[APPLE_FLUSH_BUFFER_RANGE] = FALSE;
2460 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
2462 TRACE_(d3d_caps)(" IMPLIED: NVIDIA (NV) Texture Gen Reflection support.\n");
2463 gl_info->supported[NV_TEXGEN_REFLECTION] = TRUE;
2465 if (!gl_info->supported[ARB_DEPTH_CLAMP] && gl_info->supported[NV_DEPTH_CLAMP])
2467 TRACE_(d3d_caps)(" IMPLIED: ARB_depth_clamp support (by NV_depth_clamp).\n");
2468 gl_info->supported[ARB_DEPTH_CLAMP] = TRUE;
2470 if (!gl_info->supported[ARB_VERTEX_ARRAY_BGRA] && gl_info->supported[EXT_VERTEX_ARRAY_BGRA])
2472 TRACE_(d3d_caps)(" IMPLIED: ARB_vertex_array_bgra support (by EXT_vertex_array_bgra).\n");
2473 gl_info->supported[ARB_VERTEX_ARRAY_BGRA] = TRUE;
2475 if (!gl_info->supported[ARB_TEXTURE_COMPRESSION_RGTC] && gl_info->supported[EXT_TEXTURE_COMPRESSION_RGTC])
2477 TRACE_(d3d_caps)(" IMPLIED: ARB_texture_compression_rgtc support (by EXT_texture_compression_rgtc).\n");
2478 gl_info->supported[ARB_TEXTURE_COMPRESSION_RGTC] = TRUE;
2480 if (gl_info->supported[NV_TEXTURE_SHADER2])
2482 if (gl_info->supported[NV_REGISTER_COMBINERS])
2484 /* Also disable ATI_FRAGMENT_SHADER if register combiners and texture_shader2
2485 * are supported. The nv extensions provide the same functionality as the
2486 * ATI one, and a bit more(signed pixelformats). */
2487 gl_info->supported[ATI_FRAGMENT_SHADER] = FALSE;
2491 if (gl_info->supported[NV_REGISTER_COMBINERS])
2493 glGetIntegerv(GL_MAX_GENERAL_COMBINERS_NV, &gl_max);
2494 gl_info->limits.general_combiners = gl_max;
2495 TRACE_(d3d_caps)("Max general combiners: %d.\n", gl_max);
2497 if (gl_info->supported[ARB_DRAW_BUFFERS])
2499 glGetIntegerv(GL_MAX_DRAW_BUFFERS_ARB, &gl_max);
2500 gl_info->limits.buffers = gl_max;
2501 TRACE_(d3d_caps)("Max draw buffers: %u.\n", gl_max);
2503 if (gl_info->supported[ARB_MULTITEXTURE])
2505 glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &gl_max);
2506 gl_info->limits.textures = min(MAX_TEXTURES, gl_max);
2507 TRACE_(d3d_caps)("Max textures: %d.\n", gl_info->limits.textures);
2509 if (gl_info->supported[ARB_FRAGMENT_PROGRAM])
2512 glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS_ARB, &tmp);
2513 gl_info->limits.fragment_samplers = min(MAX_FRAGMENT_SAMPLERS, tmp);
2517 gl_info->limits.fragment_samplers = max(gl_info->limits.fragment_samplers, gl_max);
2519 TRACE_(d3d_caps)("Max fragment samplers: %d.\n", gl_info->limits.fragment_samplers);
2521 if (gl_info->supported[ARB_VERTEX_SHADER])
2524 glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB, &tmp);
2525 gl_info->limits.vertex_samplers = tmp;
2526 glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB, &tmp);
2527 gl_info->limits.combined_samplers = tmp;
2529 /* Loading GLSL sampler uniforms is much simpler if we can assume that the sampler setup
2530 * is known at shader link time. In a vertex shader + pixel shader combination this isn't
2531 * an issue because then the sampler setup only depends on the two shaders. If a pixel
2532 * shader is used with fixed function vertex processing we're fine too because fixed function
2533 * vertex processing doesn't use any samplers. If fixed function fragment processing is
2534 * used we have to make sure that all vertex sampler setups are valid together with all
2535 * possible fixed function fragment processing setups. This is true if vsamplers + MAX_TEXTURES
2536 * <= max_samplers. This is true on all d3d9 cards that support vtf(gf 6 and gf7 cards).
2537 * dx9 radeon cards do not support vertex texture fetch. DX10 cards have 128 samplers, and
2538 * dx9 is limited to 8 fixed function texture stages and 4 vertex samplers. DX10 does not have
2539 * a fixed function pipeline anymore.
2541 * So this is just a check to check that our assumption holds true. If not, write a warning
2542 * and reduce the number of vertex samplers or probably disable vertex texture fetch. */
2543 if (gl_info->limits.vertex_samplers && gl_info->limits.combined_samplers < 12
2544 && MAX_TEXTURES + gl_info->limits.vertex_samplers > gl_info->limits.combined_samplers)
2546 FIXME("OpenGL implementation supports %u vertex samplers and %u total samplers.\n",
2547 gl_info->limits.vertex_samplers, gl_info->limits.combined_samplers);
2548 FIXME("Expected vertex samplers + MAX_TEXTURES(=8) > combined_samplers.\n");
2549 if (gl_info->limits.combined_samplers > MAX_TEXTURES)
2550 gl_info->limits.vertex_samplers = gl_info->limits.combined_samplers - MAX_TEXTURES;
2552 gl_info->limits.vertex_samplers = 0;
2557 gl_info->limits.combined_samplers = gl_info->limits.fragment_samplers;
2559 TRACE_(d3d_caps)("Max vertex samplers: %u.\n", gl_info->limits.vertex_samplers);
2560 TRACE_(d3d_caps)("Max combined samplers: %u.\n", gl_info->limits.combined_samplers);
2562 if (gl_info->supported[ARB_VERTEX_BLEND])
2564 glGetIntegerv(GL_MAX_VERTEX_UNITS_ARB, &gl_max);
2565 gl_info->limits.blends = gl_max;
2566 TRACE_(d3d_caps)("Max blends: %u.\n", gl_info->limits.blends);
2568 if (gl_info->supported[EXT_TEXTURE3D])
2570 glGetIntegerv(GL_MAX_3D_TEXTURE_SIZE_EXT, &gl_max);
2571 gl_info->limits.texture3d_size = gl_max;
2572 TRACE_(d3d_caps)("Max texture3D size: %d.\n", gl_info->limits.texture3d_size);
2574 if (gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC])
2576 glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &gl_max);
2577 gl_info->limits.anisotropy = gl_max;
2578 TRACE_(d3d_caps)("Max anisotropy: %d.\n", gl_info->limits.anisotropy);
2580 if (gl_info->supported[ARB_FRAGMENT_PROGRAM])
2582 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max));
2583 gl_info->limits.arb_ps_float_constants = gl_max;
2584 TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM float constants: %d.\n", gl_info->limits.arb_ps_float_constants);
2585 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB, &gl_max));
2586 gl_info->limits.arb_ps_native_constants = gl_max;
2587 TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM native float constants: %d.\n",
2588 gl_info->limits.arb_ps_native_constants);
2589 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, &gl_max));
2590 gl_info->limits.arb_ps_temps = gl_max;
2591 TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM native temporaries: %d.\n", gl_info->limits.arb_ps_temps);
2592 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, &gl_max));
2593 gl_info->limits.arb_ps_instructions = gl_max;
2594 TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM native instructions: %d.\n", gl_info->limits.arb_ps_instructions);
2595 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB, &gl_max));
2596 gl_info->limits.arb_ps_local_constants = gl_max;
2597 TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM local parameters: %d.\n", gl_info->limits.arb_ps_instructions);
2599 if (gl_info->supported[ARB_VERTEX_PROGRAM])
2601 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max));
2602 gl_info->limits.arb_vs_float_constants = gl_max;
2603 TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM float constants: %d.\n", gl_info->limits.arb_vs_float_constants);
2604 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB, &gl_max));
2605 gl_info->limits.arb_vs_native_constants = gl_max;
2606 TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM native float constants: %d.\n",
2607 gl_info->limits.arb_vs_native_constants);
2608 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, &gl_max));
2609 gl_info->limits.arb_vs_temps = gl_max;
2610 TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM native temporaries: %d.\n", gl_info->limits.arb_vs_temps);
2611 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, &gl_max));
2612 gl_info->limits.arb_vs_instructions = gl_max;
2613 TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM native instructions: %d.\n", gl_info->limits.arb_vs_instructions);
2615 if (test_arb_vs_offset_limit(gl_info)) gl_info->quirks |= WINED3D_QUIRK_ARB_VS_OFFSET_LIMIT;
2617 if (gl_info->supported[ARB_VERTEX_SHADER])
2619 glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB, &gl_max);
2620 gl_info->limits.glsl_vs_float_constants = gl_max / 4;
2621 TRACE_(d3d_caps)("Max ARB_VERTEX_SHADER float constants: %u.\n", gl_info->limits.glsl_vs_float_constants);
2623 if (gl_info->supported[ARB_FRAGMENT_SHADER])
2625 glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB, &gl_max);
2626 gl_info->limits.glsl_ps_float_constants = gl_max / 4;
2627 TRACE_(d3d_caps)("Max ARB_FRAGMENT_SHADER float constants: %u.\n", gl_info->limits.glsl_ps_float_constants);
2628 glGetIntegerv(GL_MAX_VARYING_FLOATS_ARB, &gl_max);
2629 gl_info->limits.glsl_varyings = gl_max;
2630 TRACE_(d3d_caps)("Max GLSL varyings: %u (%u 4 component varyings).\n", gl_max, gl_max / 4);
2632 if (gl_info->supported[ARB_SHADING_LANGUAGE_100])
2634 const char *str = (const char *)glGetString(GL_SHADING_LANGUAGE_VERSION_ARB);
2635 unsigned int major, minor;
2637 TRACE_(d3d_caps)("GLSL version string: %s.\n", debugstr_a(str));
2639 /* The format of the GLSL version string is "major.minor[.release] [vendor info]". */
2640 sscanf(str, "%u.%u", &major, &minor);
2641 gl_info->glsl_version = MAKEDWORD_VERSION(major, minor);
2643 if (gl_info->supported[NV_LIGHT_MAX_EXPONENT])
2645 glGetFloatv(GL_MAX_SHININESS_NV, &gl_info->limits.shininess);
2649 gl_info->limits.shininess = 128.0f;
2651 if (gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO])
2653 /* If we have full NP2 texture support, disable
2654 * GL_ARB_texture_rectangle because we will never use it.
2655 * This saves a few redundant glDisable calls. */
2656 gl_info->supported[ARB_TEXTURE_RECTANGLE] = FALSE;
2658 if (gl_info->supported[ATI_FRAGMENT_SHADER])
2660 /* Disable NV_register_combiners and fragment shader if this is supported.
2661 * generally the NV extensions are preferred over the ATI ones, and this
2662 * extension is disabled if register_combiners and texture_shader2 are both
2663 * supported. So we reach this place only if we have incomplete NV dxlevel 8
2664 * fragment processing support. */
2665 gl_info->supported[NV_REGISTER_COMBINERS] = FALSE;
2666 gl_info->supported[NV_REGISTER_COMBINERS2] = FALSE;
2667 gl_info->supported[NV_TEXTURE_SHADER] = FALSE;
2668 gl_info->supported[NV_TEXTURE_SHADER2] = FALSE;
2670 if (gl_info->supported[NV_HALF_FLOAT])
2672 /* GL_ARB_half_float_vertex is a subset of GL_NV_half_float. */
2673 gl_info->supported[ARB_HALF_FLOAT_VERTEX] = TRUE;
2675 if (gl_info->supported[ARB_POINT_SPRITE])
2677 gl_info->limits.point_sprite_units = gl_info->limits.textures;
2681 gl_info->limits.point_sprite_units = 0;
2683 checkGLcall("extension detection");
2687 adapter->fragment_pipe = select_fragment_implementation(adapter);
2688 adapter->shader_backend = select_shader_backend(adapter);
2689 adapter->blitter = select_blit_implementation(adapter);
2691 adapter->fragment_pipe->get_caps(gl_info, &fragment_caps);
2692 gl_info->limits.texture_stages = fragment_caps.MaxTextureBlendStages;
2693 TRACE_(d3d_caps)("Max texture stages: %u.\n", gl_info->limits.texture_stages);
2695 /* In some cases the number of texture stages can be larger than the number
2696 * of samplers. The GF4 for example can use only 2 samplers (no fragment
2697 * shaders), but 8 texture stages (register combiners). */
2698 gl_info->limits.sampler_stages = max(gl_info->limits.fragment_samplers, gl_info->limits.texture_stages);
2700 if (gl_info->supported[ARB_FRAMEBUFFER_OBJECT])
2702 gl_info->fbo_ops.glIsRenderbuffer = gl_info->glIsRenderbuffer;
2703 gl_info->fbo_ops.glBindRenderbuffer = gl_info->glBindRenderbuffer;
2704 gl_info->fbo_ops.glDeleteRenderbuffers = gl_info->glDeleteRenderbuffers;
2705 gl_info->fbo_ops.glGenRenderbuffers = gl_info->glGenRenderbuffers;
2706 gl_info->fbo_ops.glRenderbufferStorage = gl_info->glRenderbufferStorage;
2707 gl_info->fbo_ops.glRenderbufferStorageMultisample = gl_info->glRenderbufferStorageMultisample;
2708 gl_info->fbo_ops.glGetRenderbufferParameteriv = gl_info->glGetRenderbufferParameteriv;
2709 gl_info->fbo_ops.glIsFramebuffer = gl_info->glIsFramebuffer;
2710 gl_info->fbo_ops.glBindFramebuffer = gl_info->glBindFramebuffer;
2711 gl_info->fbo_ops.glDeleteFramebuffers = gl_info->glDeleteFramebuffers;
2712 gl_info->fbo_ops.glGenFramebuffers = gl_info->glGenFramebuffers;
2713 gl_info->fbo_ops.glCheckFramebufferStatus = gl_info->glCheckFramebufferStatus;
2714 gl_info->fbo_ops.glFramebufferTexture1D = gl_info->glFramebufferTexture1D;
2715 gl_info->fbo_ops.glFramebufferTexture2D = gl_info->glFramebufferTexture2D;
2716 gl_info->fbo_ops.glFramebufferTexture3D = gl_info->glFramebufferTexture3D;
2717 gl_info->fbo_ops.glFramebufferRenderbuffer = gl_info->glFramebufferRenderbuffer;
2718 gl_info->fbo_ops.glGetFramebufferAttachmentParameteriv = gl_info->glGetFramebufferAttachmentParameteriv;
2719 gl_info->fbo_ops.glBlitFramebuffer = gl_info->glBlitFramebuffer;
2720 gl_info->fbo_ops.glGenerateMipmap = gl_info->glGenerateMipmap;
2724 if (gl_info->supported[EXT_FRAMEBUFFER_OBJECT])
2726 gl_info->fbo_ops.glIsRenderbuffer = gl_info->glIsRenderbufferEXT;
2727 gl_info->fbo_ops.glBindRenderbuffer = gl_info->glBindRenderbufferEXT;
2728 gl_info->fbo_ops.glDeleteRenderbuffers = gl_info->glDeleteRenderbuffersEXT;
2729 gl_info->fbo_ops.glGenRenderbuffers = gl_info->glGenRenderbuffersEXT;
2730 gl_info->fbo_ops.glRenderbufferStorage = gl_info->glRenderbufferStorageEXT;
2731 gl_info->fbo_ops.glGetRenderbufferParameteriv = gl_info->glGetRenderbufferParameterivEXT;
2732 gl_info->fbo_ops.glIsFramebuffer = gl_info->glIsFramebufferEXT;
2733 gl_info->fbo_ops.glBindFramebuffer = gl_info->glBindFramebufferEXT;
2734 gl_info->fbo_ops.glDeleteFramebuffers = gl_info->glDeleteFramebuffersEXT;
2735 gl_info->fbo_ops.glGenFramebuffers = gl_info->glGenFramebuffersEXT;
2736 gl_info->fbo_ops.glCheckFramebufferStatus = gl_info->glCheckFramebufferStatusEXT;
2737 gl_info->fbo_ops.glFramebufferTexture1D = gl_info->glFramebufferTexture1DEXT;
2738 gl_info->fbo_ops.glFramebufferTexture2D = gl_info->glFramebufferTexture2DEXT;
2739 gl_info->fbo_ops.glFramebufferTexture3D = gl_info->glFramebufferTexture3DEXT;
2740 gl_info->fbo_ops.glFramebufferRenderbuffer = gl_info->glFramebufferRenderbufferEXT;
2741 gl_info->fbo_ops.glGetFramebufferAttachmentParameteriv = gl_info->glGetFramebufferAttachmentParameterivEXT;
2742 gl_info->fbo_ops.glGenerateMipmap = gl_info->glGenerateMipmapEXT;
2744 else if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
2746 WARN_(d3d_caps)("Framebuffer objects not supported, falling back to backbuffer offscreen rendering mode.\n");
2747 wined3d_settings.offscreen_rendering_mode = ORM_BACKBUFFER;
2749 if (gl_info->supported[EXT_FRAMEBUFFER_BLIT])
2751 gl_info->fbo_ops.glBlitFramebuffer = gl_info->glBlitFramebufferEXT;
2753 if (gl_info->supported[EXT_FRAMEBUFFER_MULTISAMPLE])
2755 gl_info->fbo_ops.glRenderbufferStorageMultisample = gl_info->glRenderbufferStorageMultisampleEXT;
2759 /* MRTs are currently only supported when FBOs are used. */
2760 if (wined3d_settings.offscreen_rendering_mode != ORM_FBO)
2762 gl_info->limits.buffers = 1;
2765 gl_vendor = wined3d_guess_gl_vendor(gl_info, gl_vendor_str, gl_renderer_str);
2766 card_vendor = wined3d_guess_card_vendor(gl_vendor_str, gl_renderer_str);
2767 TRACE_(d3d_caps)("found GL_VENDOR (%s)->(0x%04x/0x%04x)\n", debugstr_a(gl_vendor_str), gl_vendor, card_vendor);
2769 device = wined3d_guess_card(gl_info, gl_renderer_str, &gl_vendor, &card_vendor, &vidmem);
2770 TRACE_(d3d_caps)("FOUND (fake) card: 0x%x (vendor id), 0x%x (device id)\n", card_vendor, device);
2772 /* If we have an estimate use it, else default to 64MB; */
2774 gl_info->vidmem = vidmem*1024*1024; /* convert from MBs to bytes */
2776 gl_info->vidmem = WINE_DEFAULT_VIDMEM;
2778 gl_info->wrap_lookup[WINED3DTADDRESS_WRAP - WINED3DTADDRESS_WRAP] = GL_REPEAT;
2779 gl_info->wrap_lookup[WINED3DTADDRESS_MIRROR - WINED3DTADDRESS_WRAP] =
2780 gl_info->supported[ARB_TEXTURE_MIRRORED_REPEAT] ? GL_MIRRORED_REPEAT_ARB : GL_REPEAT;
2781 gl_info->wrap_lookup[WINED3DTADDRESS_CLAMP - WINED3DTADDRESS_WRAP] = GL_CLAMP_TO_EDGE;
2782 gl_info->wrap_lookup[WINED3DTADDRESS_BORDER - WINED3DTADDRESS_WRAP] =
2783 gl_info->supported[ARB_TEXTURE_BORDER_CLAMP] ? GL_CLAMP_TO_BORDER_ARB : GL_REPEAT;
2784 gl_info->wrap_lookup[WINED3DTADDRESS_MIRRORONCE - WINED3DTADDRESS_WRAP] =
2785 gl_info->supported[ATI_TEXTURE_MIRROR_ONCE] ? GL_MIRROR_CLAMP_TO_EDGE_ATI : GL_REPEAT;
2787 /* Make sure there's an active HDC else the WGL extensions will fail */
2788 hdc = pwglGetCurrentDC();
2790 /* Not all GL drivers might offer WGL extensions e.g. VirtualBox */
2791 if(GL_EXTCALL(wglGetExtensionsStringARB))
2792 WGL_Extensions = GL_EXTCALL(wglGetExtensionsStringARB(hdc));
2794 if (NULL == WGL_Extensions) {
2795 ERR(" WGL_Extensions returns NULL\n");
2797 TRACE_(d3d_caps)("WGL_Extensions reported:\n");
2798 while (*WGL_Extensions != 0x00) {
2802 while (isspace(*WGL_Extensions)) WGL_Extensions++;
2803 Start = WGL_Extensions;
2804 while (!isspace(*WGL_Extensions) && *WGL_Extensions != 0x00) {
2808 len = WGL_Extensions - Start;
2809 if (len == 0 || len >= sizeof(ThisExtn))
2812 memcpy(ThisExtn, Start, len);
2813 ThisExtn[len] = '\0';
2814 TRACE_(d3d_caps)("- %s\n", debugstr_a(ThisExtn));
2816 if (!strcmp(ThisExtn, "WGL_ARB_pixel_format")) {
2817 gl_info->supported[WGL_ARB_PIXEL_FORMAT] = TRUE;
2818 TRACE_(d3d_caps)("FOUND: WGL_ARB_pixel_format support\n");
2820 if (!strcmp(ThisExtn, "WGL_WINE_pixel_format_passthrough")) {
2821 gl_info->supported[WGL_WINE_PIXEL_FORMAT_PASSTHROUGH] = TRUE;
2822 TRACE_(d3d_caps)("FOUND: WGL_WINE_pixel_format_passthrough support\n");
2828 fixup_extensions(gl_info, gl_renderer_str, gl_vendor, card_vendor, device);
2829 init_driver_info(driver_info, card_vendor, device);
2830 add_gl_compat_wrappers(gl_info);
2835 /**********************************************************
2836 * IWineD3D implementation follows
2837 **********************************************************/
2839 static UINT WINAPI IWineD3DImpl_GetAdapterCount (IWineD3D *iface) {
2840 IWineD3DImpl *This = (IWineD3DImpl *)iface;
2842 TRACE_(d3d_caps)("(%p): Reporting %u adapters\n", This, This->adapter_count);
2844 return This->adapter_count;
2847 static HRESULT WINAPI IWineD3DImpl_RegisterSoftwareDevice(IWineD3D *iface, void *init_function)
2849 FIXME("iface %p, init_function %p stub!\n", iface, init_function);
2854 static HMONITOR WINAPI IWineD3DImpl_GetAdapterMonitor(IWineD3D *iface, UINT Adapter) {
2855 IWineD3DImpl *This = (IWineD3DImpl *)iface;
2857 TRACE_(d3d_caps)("(%p)->(%d)\n", This, Adapter);
2859 if (Adapter >= IWineD3DImpl_GetAdapterCount(iface)) {
2863 return MonitorFromPoint(This->adapters[Adapter].monitorPoint, MONITOR_DEFAULTTOPRIMARY);
2866 /* FIXME: GetAdapterModeCount and EnumAdapterModes currently only returns modes
2867 of the same bpp but different resolutions */
2869 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */
2870 static UINT WINAPI IWineD3DImpl_GetAdapterModeCount(IWineD3D *iface, UINT Adapter, enum wined3d_format_id format_id)
2872 IWineD3DImpl *This = (IWineD3DImpl *)iface;
2874 TRACE_(d3d_caps)("iface %p, adapter %u, format_id: %s.\n", iface, Adapter, debug_d3dformat(format_id));
2876 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
2880 /* TODO: Store modes per adapter and read it from the adapter structure */
2883 const struct wined3d_format *format = wined3d_get_format(&This->adapters[Adapter].gl_info, format_id);
2884 UINT format_bits = format->byte_count * CHAR_BIT;
2889 memset(&mode, 0, sizeof(mode));
2890 mode.dmSize = sizeof(mode);
2892 while (EnumDisplaySettingsExW(NULL, j, &mode, 0))
2896 if (format_id == WINED3DFMT_UNKNOWN)
2898 /* This is for D3D8, do not enumerate P8 here */
2899 if (mode.dmBitsPerPel == 32 || mode.dmBitsPerPel == 16) ++i;
2901 else if (mode.dmBitsPerPel == format_bits)
2907 TRACE_(d3d_caps)("(%p}->(Adapter: %d) => %d (out of %d)\n", This, Adapter, i, j);
2910 FIXME_(d3d_caps)("Adapter not primary display\n");
2915 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */
2916 static HRESULT WINAPI IWineD3DImpl_EnumAdapterModes(IWineD3D *iface, UINT Adapter,
2917 enum wined3d_format_id format_id, UINT Mode, WINED3DDISPLAYMODE *pMode)
2919 IWineD3DImpl *This = (IWineD3DImpl *)iface;
2921 TRACE_(d3d_caps)("iface %p, adapter_idx %u, format %s, mode_idx %u, mode %p.\n",
2922 iface, Adapter, debug_d3dformat(format_id), Mode, pMode);
2924 /* Validate the parameters as much as possible */
2925 if (!pMode || Adapter >= IWineD3DImpl_GetAdapterCount(iface)
2926 || Mode >= IWineD3DImpl_GetAdapterModeCount(iface, Adapter, format_id))
2928 return WINED3DERR_INVALIDCALL;
2931 /* TODO: Store modes per adapter and read it from the adapter structure */
2934 const struct wined3d_format *format = wined3d_get_format(&This->adapters[Adapter].gl_info, format_id);
2935 UINT format_bits = format->byte_count * CHAR_BIT;
2941 ZeroMemory(&DevModeW, sizeof(DevModeW));
2942 DevModeW.dmSize = sizeof(DevModeW);
2944 /* If we are filtering to a specific format (D3D9), then need to skip
2945 all unrelated modes, but if mode is irrelevant (D3D8), then we can
2946 just count through the ones with valid bit depths */
2947 while ((i<=Mode) && EnumDisplaySettingsExW(NULL, j++, &DevModeW, 0))
2949 if (format_id == WINED3DFMT_UNKNOWN)
2951 /* This is for D3D8, do not enumerate P8 here */
2952 if (DevModeW.dmBitsPerPel == 32 || DevModeW.dmBitsPerPel == 16) ++i;
2954 else if (DevModeW.dmBitsPerPel == format_bits)
2962 TRACE_(d3d_caps)("No modes found for format (%x - %s)\n", format_id, debug_d3dformat(format_id));
2963 return WINED3DERR_INVALIDCALL;
2967 /* Now get the display mode via the calculated index */
2968 if (EnumDisplaySettingsExW(NULL, ModeIdx, &DevModeW, 0)) {
2969 pMode->Width = DevModeW.dmPelsWidth;
2970 pMode->Height = DevModeW.dmPelsHeight;
2971 pMode->RefreshRate = DEFAULT_REFRESH_RATE;
2972 if (DevModeW.dmFields & DM_DISPLAYFREQUENCY)
2973 pMode->RefreshRate = DevModeW.dmDisplayFrequency;
2975 if (format_id == WINED3DFMT_UNKNOWN)
2976 pMode->Format = pixelformat_for_depth(DevModeW.dmBitsPerPel);
2978 pMode->Format = format_id;
2982 TRACE_(d3d_caps)("Requested mode out of range %d\n", Mode);
2983 return WINED3DERR_INVALIDCALL;
2986 TRACE_(d3d_caps)("W %d H %d rr %d fmt (%x - %s) bpp %u\n", pMode->Width, pMode->Height,
2987 pMode->RefreshRate, pMode->Format, debug_d3dformat(pMode->Format),
2988 DevModeW.dmBitsPerPel);
2993 FIXME_(d3d_caps)("Adapter not primary display\n");
2999 static HRESULT WINAPI IWineD3DImpl_GetAdapterDisplayMode(IWineD3D *iface, UINT Adapter, WINED3DDISPLAYMODE *pMode)
3001 TRACE("iface %p, adapter_idx %u, display_mode %p.\n", iface, Adapter, pMode);
3003 if (NULL == pMode ||
3004 Adapter >= IWineD3D_GetAdapterCount(iface)) {
3005 return WINED3DERR_INVALIDCALL;
3008 if (Adapter == 0) { /* Display */
3012 ZeroMemory(&DevModeW, sizeof(DevModeW));
3013 DevModeW.dmSize = sizeof(DevModeW);
3015 EnumDisplaySettingsExW(NULL, ENUM_CURRENT_SETTINGS, &DevModeW, 0);
3016 pMode->Width = DevModeW.dmPelsWidth;
3017 pMode->Height = DevModeW.dmPelsHeight;
3018 bpp = DevModeW.dmBitsPerPel;
3019 pMode->RefreshRate = DEFAULT_REFRESH_RATE;
3020 if (DevModeW.dmFields&DM_DISPLAYFREQUENCY)
3022 pMode->RefreshRate = DevModeW.dmDisplayFrequency;
3025 pMode->Format = pixelformat_for_depth(bpp);
3027 FIXME_(d3d_caps)("Adapter not primary display\n");
3030 TRACE_(d3d_caps)("returning w:%d, h:%d, ref:%d, fmt:%s\n", pMode->Width,
3031 pMode->Height, pMode->RefreshRate, debug_d3dformat(pMode->Format));
3035 /* NOTE: due to structure differences between dx8 and dx9 D3DADAPTER_IDENTIFIER,
3036 and fields being inserted in the middle, a new structure is used in place */
3037 static HRESULT WINAPI IWineD3DImpl_GetAdapterIdentifier(IWineD3D *iface, UINT Adapter, DWORD Flags,
3038 WINED3DADAPTER_IDENTIFIER* pIdentifier) {
3039 IWineD3DImpl *This = (IWineD3DImpl *)iface;
3040 struct wined3d_adapter *adapter;
3043 TRACE_(d3d_caps)("(%p}->(Adapter: %d, Flags: %x, pId=%p)\n", This, Adapter, Flags, pIdentifier);
3045 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
3046 return WINED3DERR_INVALIDCALL;
3049 adapter = &This->adapters[Adapter];
3051 /* Return the information requested */
3052 TRACE_(d3d_caps)("device/Vendor Name and Version detection using FillGLCaps\n");
3054 if (pIdentifier->driver_size)
3056 const char *name = adapter->driver_info.name;
3057 len = min(strlen(name), pIdentifier->driver_size - 1);
3058 memcpy(pIdentifier->driver, name, len);
3059 pIdentifier->driver[len] = '\0';
3062 if (pIdentifier->description_size)
3064 const char *description = adapter->driver_info.description;
3065 len = min(strlen(description), pIdentifier->description_size - 1);
3066 memcpy(pIdentifier->description, description, len);
3067 pIdentifier->description[len] = '\0';
3070 /* Note that d3d8 doesn't supply a device name. */
3071 if (pIdentifier->device_name_size)
3073 static const char *device_name = "\\\\.\\DISPLAY1"; /* FIXME: May depend on desktop? */
3075 len = strlen(device_name);
3076 if (len >= pIdentifier->device_name_size)
3078 ERR("Device name size too small.\n");
3079 return WINED3DERR_INVALIDCALL;
3082 memcpy(pIdentifier->device_name, device_name, len);
3083 pIdentifier->device_name[len] = '\0';
3086 pIdentifier->driver_version.u.HighPart = adapter->driver_info.version_high;
3087 pIdentifier->driver_version.u.LowPart = adapter->driver_info.version_low;
3088 pIdentifier->vendor_id = adapter->driver_info.vendor;
3089 pIdentifier->device_id = adapter->driver_info.device;
3090 pIdentifier->subsystem_id = 0;
3091 pIdentifier->revision = 0;
3092 memcpy(&pIdentifier->device_identifier, &IID_D3DDEVICE_D3DUID, sizeof(pIdentifier->device_identifier));
3093 pIdentifier->whql_level = (Flags & WINED3DENUM_NO_WHQL_LEVEL) ? 0 : 1;
3094 memcpy(&pIdentifier->adapter_luid, &adapter->luid, sizeof(pIdentifier->adapter_luid));
3095 pIdentifier->video_memory = adapter->TextureRam;
3100 static BOOL IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(const struct wined3d_gl_info *gl_info,
3101 const WineD3D_PixelFormat *cfg, const struct wined3d_format *format)
3103 short redSize, greenSize, blueSize, alphaSize, colorBits;
3108 /* Float formats need FBOs. If FBOs are used this function isn't called */
3109 if (format->Flags & WINED3DFMT_FLAG_FLOAT) return FALSE;
3111 if(cfg->iPixelType == WGL_TYPE_RGBA_ARB) { /* Integer RGBA formats */
3112 if (!getColorBits(format, &redSize, &greenSize, &blueSize, &alphaSize, &colorBits))
3114 ERR("Unable to check compatibility for format %s.\n", debug_d3dformat(format->id));
3118 if(cfg->redSize < redSize)
3121 if(cfg->greenSize < greenSize)
3124 if(cfg->blueSize < blueSize)
3127 if(cfg->alphaSize < alphaSize)
3133 /* Probably a RGBA_float or color index mode */
3137 static BOOL IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(const struct wined3d_gl_info *gl_info,
3138 const WineD3D_PixelFormat *cfg, const struct wined3d_format *format)
3140 short depthSize, stencilSize;
3141 BOOL lockable = FALSE;
3146 if (!getDepthStencilBits(format, &depthSize, &stencilSize))
3148 ERR("Unable to check compatibility for format %s.\n", debug_d3dformat(format->id));
3152 /* Float formats need FBOs. If FBOs are used this function isn't called */
3153 if (format->Flags & WINED3DFMT_FLAG_FLOAT) return FALSE;
3155 if ((format->id == WINED3DFMT_D16_LOCKABLE) || (format->id == WINED3DFMT_D32_FLOAT))
3158 /* On some modern cards like the Geforce8/9 GLX doesn't offer some dephthstencil formats which D3D9 reports.
3159 * We can safely report 'compatible' formats (e.g. D24 can be used for D16) as long as we aren't dealing with
3160 * a lockable format. This also helps D3D <= 7 as they expect D16 which isn't offered without this on Geforce8 cards. */
3161 if(!(cfg->depthSize == depthSize || (!lockable && cfg->depthSize > depthSize)))
3164 /* Some cards like Intel i915 ones only offer D24S8 but lots of games also need a format without stencil, so
3165 * allow more stencil bits than requested. */
3166 if(cfg->stencilSize < stencilSize)
3172 static HRESULT WINAPI IWineD3DImpl_CheckDepthStencilMatch(IWineD3D *iface,
3173 UINT Adapter, WINED3DDEVTYPE DeviceType, enum wined3d_format_id AdapterFormat,
3174 enum wined3d_format_id RenderTargetFormat, enum wined3d_format_id DepthStencilFormat)
3176 IWineD3DImpl *This = (IWineD3DImpl *)iface;
3178 const WineD3D_PixelFormat *cfgs;
3179 const struct wined3d_adapter *adapter;
3180 const struct wined3d_format *rt_format;
3181 const struct wined3d_format *ds_format;
3184 WARN_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, DevType:(%x,%s), AdptFmt:(%x,%s), RendrTgtFmt:(%x,%s), DepthStencilFmt:(%x,%s))\n",
3186 DeviceType, debug_d3ddevicetype(DeviceType),
3187 AdapterFormat, debug_d3dformat(AdapterFormat),
3188 RenderTargetFormat, debug_d3dformat(RenderTargetFormat),
3189 DepthStencilFormat, debug_d3dformat(DepthStencilFormat));
3191 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
3192 TRACE("(%p) Failed: Atapter (%u) higher than supported adapters (%u) returning WINED3DERR_INVALIDCALL\n", This, Adapter, IWineD3D_GetAdapterCount(iface));
3193 return WINED3DERR_INVALIDCALL;
3196 adapter = &This->adapters[Adapter];
3197 rt_format = wined3d_get_format(&adapter->gl_info, RenderTargetFormat);
3198 ds_format = wined3d_get_format(&adapter->gl_info, DepthStencilFormat);
3199 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
3201 if ((rt_format->Flags & WINED3DFMT_FLAG_RENDERTARGET)
3202 && (ds_format->Flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL)))
3204 TRACE_(d3d_caps)("(%p) : Formats matched\n", This);
3210 cfgs = adapter->cfgs;
3211 nCfgs = adapter->nCfgs;
3212 for (it = 0; it < nCfgs; ++it)
3214 if (IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&adapter->gl_info, &cfgs[it], rt_format))
3216 if (IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&adapter->gl_info, &cfgs[it], ds_format))
3218 TRACE_(d3d_caps)("(%p) : Formats matched\n", This);
3224 WARN_(d3d_caps)("unsupported format pair: %s and %s\n", debug_d3dformat(RenderTargetFormat), debug_d3dformat(DepthStencilFormat));
3226 return WINED3DERR_NOTAVAILABLE;
3229 static HRESULT WINAPI IWineD3DImpl_CheckDeviceMultiSampleType(IWineD3D *iface, UINT Adapter,
3230 WINED3DDEVTYPE DeviceType, enum wined3d_format_id SurfaceFormat, BOOL Windowed,
3231 WINED3DMULTISAMPLE_TYPE MultiSampleType, DWORD *pQualityLevels)
3233 IWineD3DImpl *This = (IWineD3DImpl *)iface;
3234 const struct wined3d_adapter *adapter;
3235 const struct wined3d_format *format;
3237 TRACE_(d3d_caps)("(%p)-> (Adptr:%d, DevType:(%x,%s), SurfFmt:(%x,%s), Win?%d, MultiSamp:%x, pQual:%p)\n",
3240 DeviceType, debug_d3ddevicetype(DeviceType),
3241 SurfaceFormat, debug_d3dformat(SurfaceFormat),
3246 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
3247 return WINED3DERR_INVALIDCALL;
3250 /* TODO: handle Windowed, add more quality levels */
3252 if (WINED3DMULTISAMPLE_NONE == MultiSampleType) {
3253 if(pQualityLevels) *pQualityLevels = 1;
3257 /* By default multisampling is disabled right now as it causes issues
3258 * on some Nvidia driver versions and it doesn't work well in combination
3260 if(!wined3d_settings.allow_multisampling)
3261 return WINED3DERR_NOTAVAILABLE;
3263 adapter = &This->adapters[Adapter];
3264 format = wined3d_get_format(&adapter->gl_info, SurfaceFormat);
3265 if (!format) return WINED3DERR_INVALIDCALL;
3267 if (format->Flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL))
3270 const WineD3D_PixelFormat *cfgs;
3272 cfgs = adapter->cfgs;
3273 nCfgs = adapter->nCfgs;
3274 for(i=0; i<nCfgs; i++) {
3275 if(cfgs[i].numSamples != MultiSampleType)
3278 if (!IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&adapter->gl_info, &cfgs[i], format))
3281 TRACE("Found iPixelFormat=%d to support MultiSampleType=%d for format %s\n", cfgs[i].iPixelFormat, MultiSampleType, debug_d3dformat(SurfaceFormat));
3284 *pQualityLevels = 1; /* Guess at a value! */
3288 else if (format->Flags & WINED3DFMT_FLAG_RENDERTARGET)
3290 short redSize, greenSize, blueSize, alphaSize, colorBits;
3292 const WineD3D_PixelFormat *cfgs;
3294 if (!getColorBits(format, &redSize, &greenSize, &blueSize, &alphaSize, &colorBits))
3296 ERR("Unable to color bits for format %#x, can't check multisampling capability!\n", SurfaceFormat);
3297 return WINED3DERR_NOTAVAILABLE;
3300 cfgs = adapter->cfgs;
3301 nCfgs = adapter->nCfgs;
3302 for(i=0; i<nCfgs; i++) {
3303 if(cfgs[i].numSamples != MultiSampleType)
3305 if(cfgs[i].redSize != redSize)
3307 if(cfgs[i].greenSize != greenSize)
3309 if(cfgs[i].blueSize != blueSize)
3311 /* Not all drivers report alpha-less formats since they use 32-bit anyway, so accept alpha even if we didn't ask for it. */
3312 if(alphaSize && cfgs[i].alphaSize != alphaSize)
3314 if (cfgs[i].colorSize != (format->byte_count << 3))
3317 TRACE("Found iPixelFormat=%d to support MultiSampleType=%d for format %s\n", cfgs[i].iPixelFormat, MultiSampleType, debug_d3dformat(SurfaceFormat));
3320 *pQualityLevels = 1; /* Guess at a value! */
3324 return WINED3DERR_NOTAVAILABLE;
3327 /* Check if we support bumpmapping for a format */
3328 static BOOL CheckBumpMapCapability(struct wined3d_adapter *adapter, const struct wined3d_format *format)
3330 /* Ask the fixed function pipeline implementation if it can deal
3331 * with the conversion. If we've got a GL extension giving native
3332 * support this will be an identity conversion. */
3333 return (format->Flags & WINED3DFMT_FLAG_BUMPMAP)
3334 && adapter->fragment_pipe->color_fixup_supported(format->color_fixup);
3337 /* Check if the given DisplayFormat + DepthStencilFormat combination is valid for the Adapter */
3338 static BOOL CheckDepthStencilCapability(struct wined3d_adapter *adapter,
3339 const struct wined3d_format *display_format, const struct wined3d_format *ds_format)
3343 /* Only allow depth/stencil formats */
3344 if (!(ds_format->depth_size || ds_format->stencil_size)) return FALSE;
3346 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
3348 /* With FBOs WGL limitations do not apply, but the format needs to be FBO attachable */
3349 if (ds_format->Flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL)) return TRUE;
3353 /* Walk through all WGL pixel formats to find a match */
3354 for (it = 0; it < adapter->nCfgs; ++it)
3356 WineD3D_PixelFormat *cfg = &adapter->cfgs[it];
3357 if (IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&adapter->gl_info, cfg, display_format))
3359 if (IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&adapter->gl_info, cfg, ds_format))
3370 static BOOL CheckFilterCapability(struct wined3d_adapter *adapter, const struct wined3d_format *format)
3372 /* The flags entry of a format contains the filtering capability */
3373 if (format->Flags & WINED3DFMT_FLAG_FILTERING) return TRUE;
3378 /* Check the render target capabilities of a format */
3379 static BOOL CheckRenderTargetCapability(struct wined3d_adapter *adapter,
3380 const struct wined3d_format *adapter_format, const struct wined3d_format *check_format)
3382 /* Filter out non-RT formats */
3383 if (!(check_format->Flags & WINED3DFMT_FLAG_RENDERTARGET)) return FALSE;
3384 if (wined3d_settings.offscreen_rendering_mode == ORM_BACKBUFFER)
3386 WineD3D_PixelFormat *cfgs = adapter->cfgs;
3388 short AdapterRed, AdapterGreen, AdapterBlue, AdapterAlpha, AdapterTotalSize;
3389 short CheckRed, CheckGreen, CheckBlue, CheckAlpha, CheckTotalSize;
3391 getColorBits(adapter_format, &AdapterRed, &AdapterGreen, &AdapterBlue, &AdapterAlpha, &AdapterTotalSize);
3392 getColorBits(check_format, &CheckRed, &CheckGreen, &CheckBlue, &CheckAlpha, &CheckTotalSize);
3394 /* In backbuffer mode the front and backbuffer share the same WGL pixelformat.
3395 * The format must match in RGB, alpha is allowed to be different. (Only the backbuffer can have alpha) */
3396 if(!((AdapterRed == CheckRed) && (AdapterGreen == CheckGreen) && (AdapterBlue == CheckBlue))) {
3397 TRACE_(d3d_caps)("[FAILED]\n");
3401 /* Check if there is a WGL pixel format matching the requirements, the format should also be window
3402 * drawable (not offscreen; e.g. Nvidia offers R5G6B5 for pbuffers even when X is running at 24bit) */
3403 for (it = 0; it < adapter->nCfgs; ++it)
3405 if (cfgs[it].windowDrawable && IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&adapter->gl_info,
3406 &cfgs[it], check_format))
3408 TRACE_(d3d_caps)("Pixel format %d is compatible with format %s.\n",
3409 cfgs[it].iPixelFormat, debug_d3dformat(check_format->id));
3414 else if(wined3d_settings.offscreen_rendering_mode == ORM_FBO)
3416 /* For now return TRUE for FBOs until we have some proper checks.
3417 * Note that this function will only be called when the format is around for texturing. */
3423 static BOOL CheckSrgbReadCapability(struct wined3d_adapter *adapter, const struct wined3d_format *format)
3425 return adapter->gl_info.supported[EXT_TEXTURE_SRGB] && (format->Flags & WINED3DFMT_FLAG_SRGB_READ);
3428 static BOOL CheckSrgbWriteCapability(struct wined3d_adapter *adapter, const struct wined3d_format *format)
3430 /* Only offer SRGB writing on X8R8G8B8/A8R8G8B8 when we use ARB or GLSL shaders as we are
3431 * doing the color fixup in shaders.
3432 * Note Windows drivers (at least on the Geforce 8800) also offer this on R5G6B5. */
3433 if (format->Flags & WINED3DFMT_FLAG_SRGB_WRITE)
3435 int vs_selected_mode;
3436 int ps_selected_mode;
3437 select_shader_mode(&adapter->gl_info, &ps_selected_mode, &vs_selected_mode);
3439 if((ps_selected_mode == SHADER_ARB) || (ps_selected_mode == SHADER_GLSL)) {
3440 TRACE_(d3d_caps)("[OK]\n");
3445 TRACE_(d3d_caps)("[FAILED] - sRGB writes not supported by format %s.\n", debug_d3dformat(format->id));
3449 /* Check if a format support blending in combination with pixel shaders */
3450 static BOOL CheckPostPixelShaderBlendingCapability(struct wined3d_adapter *adapter,
3451 const struct wined3d_format *format)
3453 /* The flags entry of a format contains the post pixel shader blending capability */
3454 if (format->Flags & WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING) return TRUE;
3459 static BOOL CheckWrapAndMipCapability(struct wined3d_adapter *adapter, const struct wined3d_format *format)
3461 /* OpenGL supports mipmapping on all formats basically. Wrapping is unsupported,
3462 * but we have to report mipmapping so we cannot reject this flag. Tests show that
3463 * windows reports WRAPANDMIP on unfilterable surfaces as well, apparently to show
3464 * that wrapping is supported. The lack of filtering will sort out the mipmapping
3465 * capability anyway.
3467 * For now lets report this on all formats, but in the future we may want to
3468 * restrict it to some should games need that
3473 /* Check if a texture format is supported on the given adapter */
3474 static BOOL CheckTextureCapability(struct wined3d_adapter *adapter, const struct wined3d_format *format)
3476 const struct wined3d_gl_info *gl_info = &adapter->gl_info;
3481 * supported: RGB(A) formats
3483 case WINED3DFMT_B8G8R8_UNORM: /* Enable for dx7, blacklisted for 8 and 9 above */
3484 case WINED3DFMT_B8G8R8A8_UNORM:
3485 case WINED3DFMT_B8G8R8X8_UNORM:
3486 case WINED3DFMT_B5G6R5_UNORM:
3487 case WINED3DFMT_B5G5R5X1_UNORM:
3488 case WINED3DFMT_B5G5R5A1_UNORM:
3489 case WINED3DFMT_B4G4R4A4_UNORM:
3490 case WINED3DFMT_A8_UNORM:
3491 case WINED3DFMT_B4G4R4X4_UNORM:
3492 case WINED3DFMT_R8G8B8A8_UNORM:
3493 case WINED3DFMT_R8G8B8X8_UNORM:
3494 case WINED3DFMT_B10G10R10A2_UNORM:
3495 case WINED3DFMT_R10G10B10A2_UNORM:
3496 case WINED3DFMT_R16G16_UNORM:
3497 TRACE_(d3d_caps)("[OK]\n");
3500 case WINED3DFMT_B2G3R3_UNORM:
3501 TRACE_(d3d_caps)("[FAILED] - Not supported on Windows\n");
3505 * Not supported: Palettized
3506 * Only some Geforce/Voodoo3/G400 cards offer 8-bit textures in case of <=Direct3D7.
3507 * Since it is not widely available, don't offer it. Further no Windows driver offers
3508 * WINED3DFMT_P8_UINT_A8_NORM, so don't offer it either.
3510 case WINED3DFMT_P8_UINT:
3511 case WINED3DFMT_P8_UINT_A8_UNORM:
3515 * Supported: (Alpha)-Luminance
3517 case WINED3DFMT_L8_UNORM:
3518 case WINED3DFMT_L8A8_UNORM:
3519 case WINED3DFMT_L16_UNORM:
3520 TRACE_(d3d_caps)("[OK]\n");
3523 /* Not supported on Windows, thus disabled */
3524 case WINED3DFMT_L4A4_UNORM:
3525 TRACE_(d3d_caps)("[FAILED] - not supported on windows\n");
3529 * Supported: Depth/Stencil formats
3531 case WINED3DFMT_D16_LOCKABLE:
3532 case WINED3DFMT_D16_UNORM:
3533 case WINED3DFMT_S1_UINT_D15_UNORM:
3534 case WINED3DFMT_X8D24_UNORM:
3535 case WINED3DFMT_S4X4_UINT_D24_UNORM:
3536 case WINED3DFMT_D24_UNORM_S8_UINT:
3537 case WINED3DFMT_S8_UINT_D24_FLOAT:
3538 case WINED3DFMT_D32_UNORM:
3539 case WINED3DFMT_D32_FLOAT:
3543 * Not supported everywhere(depends on GL_ATI_envmap_bumpmap or
3544 * GL_NV_texture_shader). Emulated by shaders
3546 case WINED3DFMT_R8G8_SNORM:
3547 case WINED3DFMT_R8G8_SNORM_L8X8_UNORM:
3548 case WINED3DFMT_R5G5_SNORM_L6_UNORM:
3549 case WINED3DFMT_R8G8B8A8_SNORM:
3550 case WINED3DFMT_R16G16_SNORM:
3551 /* Ask the shader backend if it can deal with the conversion. If
3552 * we've got a GL extension giving native support this will be an
3553 * identity conversion. */
3554 if (adapter->shader_backend->shader_color_fixup_supported(format->color_fixup))
3556 TRACE_(d3d_caps)("[OK]\n");
3559 TRACE_(d3d_caps)("[FAILED]\n");
3562 case WINED3DFMT_DXT1:
3563 case WINED3DFMT_DXT2:
3564 case WINED3DFMT_DXT3:
3565 case WINED3DFMT_DXT4:
3566 case WINED3DFMT_DXT5:
3567 if (gl_info->supported[EXT_TEXTURE_COMPRESSION_S3TC])
3569 TRACE_(d3d_caps)("[OK]\n");
3572 TRACE_(d3d_caps)("[FAILED]\n");
3577 * Odd formats - not supported
3579 case WINED3DFMT_VERTEXDATA:
3580 case WINED3DFMT_R16_UINT:
3581 case WINED3DFMT_R32_UINT:
3582 case WINED3DFMT_R16G16B16A16_SNORM:
3583 case WINED3DFMT_R10G10B10_SNORM_A2_UNORM:
3584 case WINED3DFMT_R10G11B11_SNORM:
3585 TRACE_(d3d_caps)("[FAILED]\n"); /* Enable when implemented */
3589 * WINED3DFMT_R8G8_SNORM_Cx: Not supported right now
3591 case WINED3DFMT_R8G8_SNORM_Cx:
3592 TRACE_(d3d_caps)("[FAILED]\n"); /* Enable when implemented */
3596 case WINED3DFMT_UYVY:
3597 case WINED3DFMT_YUY2:
3598 if (gl_info->supported[APPLE_YCBCR_422])
3600 TRACE_(d3d_caps)("[OK]\n");
3603 TRACE_(d3d_caps)("[FAILED]\n");
3605 case WINED3DFMT_YV12:
3606 TRACE_(d3d_caps)("[FAILED]\n");
3610 case WINED3DFMT_R16G16B16A16_UNORM:
3611 case WINED3DFMT_B2G3R3A8_UNORM:
3612 TRACE_(d3d_caps)("[FAILED]\n"); /* Enable when implemented */
3615 /* Floating point formats */
3616 case WINED3DFMT_R16_FLOAT:
3617 case WINED3DFMT_R16G16_FLOAT:
3618 case WINED3DFMT_R16G16B16A16_FLOAT:
3619 if (gl_info->supported[ARB_TEXTURE_FLOAT] && gl_info->supported[ARB_HALF_FLOAT_PIXEL])
3621 TRACE_(d3d_caps)("[OK]\n");
3624 TRACE_(d3d_caps)("[FAILED]\n");
3627 case WINED3DFMT_R32_FLOAT:
3628 case WINED3DFMT_R32G32_FLOAT:
3629 case WINED3DFMT_R32G32B32A32_FLOAT:
3630 if (gl_info->supported[ARB_TEXTURE_FLOAT])
3632 TRACE_(d3d_caps)("[OK]\n");
3635 TRACE_(d3d_caps)("[FAILED]\n");
3638 /* ATI instancing hack: Although ATI cards do not support Shader Model 3.0, they support
3639 * instancing. To query if the card supports instancing CheckDeviceFormat with the special format
3640 * MAKEFOURCC('I','N','S','T') is used. Should a (broken) app check for this provide a proper return value.
3641 * We can do instancing with all shader versions, but we need vertex shaders.
3643 * Additionally applications have to set the D3DRS_POINTSIZE render state to MAKEFOURCC('I','N','S','T') once
3644 * to enable instancing. WineD3D doesn't need that and just ignores it.
3646 * With Shader Model 3.0 capable cards Instancing 'just works' in Windows.
3648 case WINED3DFMT_INST:
3649 TRACE("ATI Instancing check hack\n");
3650 if (gl_info->supported[ARB_VERTEX_PROGRAM] || gl_info->supported[ARB_VERTEX_SHADER])
3652 TRACE_(d3d_caps)("[OK]\n");
3655 TRACE_(d3d_caps)("[FAILED]\n");
3658 /* Some weird FOURCC formats */
3659 case WINED3DFMT_R8G8_B8G8:
3660 case WINED3DFMT_G8R8_G8B8:
3661 case WINED3DFMT_MULTI2_ARGB8:
3662 TRACE_(d3d_caps)("[FAILED]\n");
3665 /* Vendor specific formats */
3666 case WINED3DFMT_ATI2N:
3667 if (gl_info->supported[ATI_TEXTURE_COMPRESSION_3DC]
3668 || gl_info->supported[ARB_TEXTURE_COMPRESSION_RGTC])
3670 if (adapter->shader_backend->shader_color_fixup_supported(format->color_fixup)
3671 && adapter->fragment_pipe->color_fixup_supported(format->color_fixup))
3673 TRACE_(d3d_caps)("[OK]\n");
3677 TRACE_(d3d_caps)("[OK]\n");
3680 TRACE_(d3d_caps)("[FAILED]\n");
3683 case WINED3DFMT_NVHU:
3684 case WINED3DFMT_NVHS:
3685 /* These formats seem to be similar to the HILO formats in GL_NV_texture_shader. NVHU
3686 * is said to be GL_UNSIGNED_HILO16, NVHS GL_SIGNED_HILO16. Rumours say that d3d computes
3687 * a 3rd channel similarly to D3DFMT_CxV8U8(So NVHS could be called D3DFMT_CxV16U16).
3688 * ATI refused to support formats which can easilly be emulated with pixel shaders, so
3689 * Applications have to deal with not having NVHS and NVHU.
3691 TRACE_(d3d_caps)("[FAILED]\n");
3694 case WINED3DFMT_UNKNOWN:
3698 ERR("Unhandled format %s.\n", debug_d3dformat(format->id));
3704 static BOOL CheckSurfaceCapability(struct wined3d_adapter *adapter,
3705 const struct wined3d_format *adapter_format,
3706 const struct wined3d_format *check_format,
3707 WINED3DSURFTYPE SurfaceType)
3709 if (SurfaceType == SURFACE_GDI)
3711 switch (check_format->id)
3713 case WINED3DFMT_B8G8R8_UNORM:
3714 case WINED3DFMT_B8G8R8A8_UNORM:
3715 case WINED3DFMT_B8G8R8X8_UNORM:
3716 case WINED3DFMT_B5G6R5_UNORM:
3717 case WINED3DFMT_B5G5R5X1_UNORM:
3718 case WINED3DFMT_B5G5R5A1_UNORM:
3719 case WINED3DFMT_B4G4R4A4_UNORM:
3720 case WINED3DFMT_B2G3R3_UNORM:
3721 case WINED3DFMT_A8_UNORM:
3722 case WINED3DFMT_B2G3R3A8_UNORM:
3723 case WINED3DFMT_B4G4R4X4_UNORM:
3724 case WINED3DFMT_R10G10B10A2_UNORM:
3725 case WINED3DFMT_R8G8B8A8_UNORM:
3726 case WINED3DFMT_R8G8B8X8_UNORM:
3727 case WINED3DFMT_R16G16_UNORM:
3728 case WINED3DFMT_B10G10R10A2_UNORM:
3729 case WINED3DFMT_R16G16B16A16_UNORM:
3730 case WINED3DFMT_P8_UINT:
3731 TRACE_(d3d_caps)("[OK]\n");
3734 TRACE_(d3d_caps)("[FAILED] - not available on GDI surfaces\n");
3739 /* All format that are supported for textures are supported for surfaces as well */
3740 if (CheckTextureCapability(adapter, check_format)) return TRUE;
3741 /* All depth stencil formats are supported on surfaces */
3742 if (CheckDepthStencilCapability(adapter, adapter_format, check_format)) return TRUE;
3744 /* If opengl can't process the format natively, the blitter may be able to convert it */
3745 if (adapter->blitter->blit_supported(&adapter->gl_info, BLIT_OP_BLIT,
3746 NULL, WINED3DPOOL_DEFAULT, 0, check_format,
3747 NULL, WINED3DPOOL_DEFAULT, 0, adapter_format))
3749 TRACE_(d3d_caps)("[OK]\n");
3753 /* Reject other formats */
3754 TRACE_(d3d_caps)("[FAILED]\n");
3758 static BOOL CheckVertexTextureCapability(struct wined3d_adapter *adapter,
3759 const struct wined3d_format *format)
3761 return adapter->gl_info.limits.vertex_samplers && (format->Flags & WINED3DFMT_FLAG_VTF);
3764 static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
3765 enum wined3d_format_id AdapterFormat, DWORD Usage, WINED3DRESOURCETYPE RType,
3766 enum wined3d_format_id CheckFormat, WINED3DSURFTYPE SurfaceType)
3768 IWineD3DImpl *This = (IWineD3DImpl *)iface;
3769 struct wined3d_adapter *adapter = &This->adapters[Adapter];
3770 const struct wined3d_gl_info *gl_info = &adapter->gl_info;
3771 const struct wined3d_format *format = wined3d_get_format(gl_info, CheckFormat);
3772 const struct wined3d_format *adapter_format = wined3d_get_format(gl_info, AdapterFormat);
3773 DWORD UsageCaps = 0;
3775 TRACE_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, DevType:(%u,%s), AdptFmt:(%u,%s), Use:(%u,%s,%s), ResTyp:(%x,%s), CheckFmt:(%u,%s))\n",
3778 DeviceType, debug_d3ddevicetype(DeviceType),
3779 AdapterFormat, debug_d3dformat(AdapterFormat),
3780 Usage, debug_d3dusage(Usage), debug_d3dusagequery(Usage),
3781 RType, debug_d3dresourcetype(RType),
3782 CheckFormat, debug_d3dformat(CheckFormat));
3784 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
3785 return WINED3DERR_INVALIDCALL;
3790 case WINED3DRTYPE_CUBETEXTURE:
3791 /* Cubetexture allows:
3792 * - WINED3DUSAGE_AUTOGENMIPMAP
3793 * - WINED3DUSAGE_DEPTHSTENCIL
3794 * - WINED3DUSAGE_DYNAMIC
3795 * - WINED3DUSAGE_NONSECURE (d3d9ex)
3796 * - WINED3DUSAGE_RENDERTARGET
3797 * - WINED3DUSAGE_SOFTWAREPROCESSING
3798 * - WINED3DUSAGE_QUERY_WRAPANDMIP
3800 if (SurfaceType != SURFACE_OPENGL)
3802 TRACE_(d3d_caps)("[FAILED]\n");
3803 return WINED3DERR_NOTAVAILABLE;
3806 if (!gl_info->supported[ARB_TEXTURE_CUBE_MAP])
3808 TRACE_(d3d_caps)("[FAILED] - No cube texture support\n");
3809 return WINED3DERR_NOTAVAILABLE;
3812 if (!CheckTextureCapability(adapter, format))
3814 TRACE_(d3d_caps)("[FAILED] - Cube texture format not supported\n");
3815 return WINED3DERR_NOTAVAILABLE;
3818 if (Usage & WINED3DUSAGE_AUTOGENMIPMAP)
3820 if (!gl_info->supported[SGIS_GENERATE_MIPMAP])
3821 /* When autogenmipmap isn't around continue and return
3822 * WINED3DOK_NOAUTOGEN instead of D3D_OK. */
3823 TRACE_(d3d_caps)("[FAILED] - No autogenmipmap support, but continuing\n");
3825 UsageCaps |= WINED3DUSAGE_AUTOGENMIPMAP;
3828 /* Always report dynamic locking. */
3829 if (Usage & WINED3DUSAGE_DYNAMIC)
3830 UsageCaps |= WINED3DUSAGE_DYNAMIC;
3832 if (Usage & WINED3DUSAGE_RENDERTARGET)
3834 if (!CheckRenderTargetCapability(adapter, adapter_format, format))
3836 TRACE_(d3d_caps)("[FAILED] - No rendertarget support\n");
3837 return WINED3DERR_NOTAVAILABLE;
3839 UsageCaps |= WINED3DUSAGE_RENDERTARGET;
3842 /* Always report software processing. */
3843 if (Usage & WINED3DUSAGE_SOFTWAREPROCESSING)
3844 UsageCaps |= WINED3DUSAGE_SOFTWAREPROCESSING;
3846 if (Usage & WINED3DUSAGE_QUERY_FILTER)
3848 if (!CheckFilterCapability(adapter, format))
3850 TRACE_(d3d_caps)("[FAILED] - No query filter support\n");
3851 return WINED3DERR_NOTAVAILABLE;
3853 UsageCaps |= WINED3DUSAGE_QUERY_FILTER;
3856 if (Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING)
3858 if (!CheckPostPixelShaderBlendingCapability(adapter, format))
3860 TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
3861 return WINED3DERR_NOTAVAILABLE;
3863 UsageCaps |= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
3866 if (Usage & WINED3DUSAGE_QUERY_SRGBREAD)
3868 if (!CheckSrgbReadCapability(adapter, format))
3870 TRACE_(d3d_caps)("[FAILED] - No query srgbread support\n");
3871 return WINED3DERR_NOTAVAILABLE;
3873 UsageCaps |= WINED3DUSAGE_QUERY_SRGBREAD;
3876 if (Usage & WINED3DUSAGE_QUERY_SRGBWRITE)
3878 if (!CheckSrgbWriteCapability(adapter, format))
3880 TRACE_(d3d_caps)("[FAILED] - No query srgbwrite support\n");
3881 return WINED3DERR_NOTAVAILABLE;
3883 UsageCaps |= WINED3DUSAGE_QUERY_SRGBWRITE;
3886 if (Usage & WINED3DUSAGE_QUERY_VERTEXTEXTURE)
3888 if (!CheckVertexTextureCapability(adapter, format))
3890 TRACE_(d3d_caps)("[FAILED] - No query vertextexture support\n");
3891 return WINED3DERR_NOTAVAILABLE;
3893 UsageCaps |= WINED3DUSAGE_QUERY_VERTEXTEXTURE;
3896 if (Usage & WINED3DUSAGE_QUERY_WRAPANDMIP)
3898 if (!CheckWrapAndMipCapability(adapter, format))
3900 TRACE_(d3d_caps)("[FAILED] - No wrapping and mipmapping support\n");
3901 return WINED3DERR_NOTAVAILABLE;
3903 UsageCaps |= WINED3DUSAGE_QUERY_WRAPANDMIP;
3907 case WINED3DRTYPE_SURFACE:
3909 * - WINED3DUSAGE_DEPTHSTENCIL
3910 * - WINED3DUSAGE_NONSECURE (d3d9ex)
3911 * - WINED3DUSAGE_RENDERTARGET
3913 if (!CheckSurfaceCapability(adapter, adapter_format, format, SurfaceType))
3915 TRACE_(d3d_caps)("[FAILED] - Not supported for plain surfaces\n");
3916 return WINED3DERR_NOTAVAILABLE;
3919 if (Usage & WINED3DUSAGE_DEPTHSTENCIL)
3921 if (!CheckDepthStencilCapability(adapter, adapter_format, format))
3923 TRACE_(d3d_caps)("[FAILED] - No depthstencil support\n");
3924 return WINED3DERR_NOTAVAILABLE;
3926 UsageCaps |= WINED3DUSAGE_DEPTHSTENCIL;
3929 if (Usage & WINED3DUSAGE_RENDERTARGET)
3931 if (!CheckRenderTargetCapability(adapter, adapter_format, format))
3933 TRACE_(d3d_caps)("[FAILED] - No rendertarget support\n");
3934 return WINED3DERR_NOTAVAILABLE;
3936 UsageCaps |= WINED3DUSAGE_RENDERTARGET;
3939 if (Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING)
3941 if (!CheckPostPixelShaderBlendingCapability(adapter, format))
3943 TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
3944 return WINED3DERR_NOTAVAILABLE;
3946 UsageCaps |= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
3950 case WINED3DRTYPE_TEXTURE:
3952 * - WINED3DUSAGE_AUTOGENMIPMAP
3953 * - WINED3DUSAGE_DEPTHSTENCIL
3954 * - WINED3DUSAGE_DMAP
3955 * - WINED3DUSAGE_DYNAMIC
3956 * - WINED3DUSAGE_NONSECURE (d3d9ex)
3957 * - WINED3DUSAGE_RENDERTARGET
3958 * - WINED3DUSAGE_SOFTWAREPROCESSING
3959 * - WINED3DUSAGE_TEXTAPI (d3d9ex)
3960 * - WINED3DUSAGE_QUERY_WRAPANDMIP
3962 if (SurfaceType != SURFACE_OPENGL)
3964 TRACE_(d3d_caps)("[FAILED]\n");
3965 return WINED3DERR_NOTAVAILABLE;
3968 if (!CheckTextureCapability(adapter, format))
3970 TRACE_(d3d_caps)("[FAILED] - Texture format not supported\n");
3971 return WINED3DERR_NOTAVAILABLE;
3974 if (Usage & WINED3DUSAGE_AUTOGENMIPMAP)
3976 if (!gl_info->supported[SGIS_GENERATE_MIPMAP])
3977 /* When autogenmipmap isn't around continue and return
3978 * WINED3DOK_NOAUTOGEN instead of D3D_OK. */
3979 TRACE_(d3d_caps)("[FAILED] - No autogenmipmap support, but continuing\n");
3981 UsageCaps |= WINED3DUSAGE_AUTOGENMIPMAP;
3984 /* Always report dynamic locking. */
3985 if (Usage & WINED3DUSAGE_DYNAMIC)
3986 UsageCaps |= WINED3DUSAGE_DYNAMIC;
3988 if (Usage & WINED3DUSAGE_RENDERTARGET)
3990 if (!CheckRenderTargetCapability(adapter, adapter_format, format))
3992 TRACE_(d3d_caps)("[FAILED] - No rendertarget support\n");
3993 return WINED3DERR_NOTAVAILABLE;
3995 UsageCaps |= WINED3DUSAGE_RENDERTARGET;
3998 /* Always report software processing. */
3999 if (Usage & WINED3DUSAGE_SOFTWAREPROCESSING)
4000 UsageCaps |= WINED3DUSAGE_SOFTWAREPROCESSING;
4002 if (Usage & WINED3DUSAGE_QUERY_FILTER)
4004 if (!CheckFilterCapability(adapter, format))
4006 TRACE_(d3d_caps)("[FAILED] - No query filter support\n");
4007 return WINED3DERR_NOTAVAILABLE;
4009 UsageCaps |= WINED3DUSAGE_QUERY_FILTER;
4012 if (Usage & WINED3DUSAGE_QUERY_LEGACYBUMPMAP)
4014 if (!CheckBumpMapCapability(adapter, format))
4016 TRACE_(d3d_caps)("[FAILED] - No legacy bumpmap support\n");
4017 return WINED3DERR_NOTAVAILABLE;
4019 UsageCaps |= WINED3DUSAGE_QUERY_LEGACYBUMPMAP;
4022 if (Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING)
4024 if (!CheckPostPixelShaderBlendingCapability(adapter, format))
4026 TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
4027 return WINED3DERR_NOTAVAILABLE;
4029 UsageCaps |= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
4032 if (Usage & WINED3DUSAGE_QUERY_SRGBREAD)
4034 if (!CheckSrgbReadCapability(adapter, format))
4036 TRACE_(d3d_caps)("[FAILED] - No query srgbread support\n");
4037 return WINED3DERR_NOTAVAILABLE;
4039 UsageCaps |= WINED3DUSAGE_QUERY_SRGBREAD;
4042 if (Usage & WINED3DUSAGE_QUERY_SRGBWRITE)
4044 if (!CheckSrgbWriteCapability(adapter, format))
4046 TRACE_(d3d_caps)("[FAILED] - No query srgbwrite support\n");
4047 return WINED3DERR_NOTAVAILABLE;
4049 UsageCaps |= WINED3DUSAGE_QUERY_SRGBWRITE;
4052 if (Usage & WINED3DUSAGE_QUERY_VERTEXTEXTURE)
4054 if (!CheckVertexTextureCapability(adapter, format))
4056 TRACE_(d3d_caps)("[FAILED] - No query vertextexture support\n");
4057 return WINED3DERR_NOTAVAILABLE;
4059 UsageCaps |= WINED3DUSAGE_QUERY_VERTEXTEXTURE;
4062 if (Usage & WINED3DUSAGE_QUERY_WRAPANDMIP)
4064 if (!CheckWrapAndMipCapability(adapter, format))
4066 TRACE_(d3d_caps)("[FAILED] - No wrapping and mipmapping support\n");
4067 return WINED3DERR_NOTAVAILABLE;
4069 UsageCaps |= WINED3DUSAGE_QUERY_WRAPANDMIP;
4072 if (Usage & WINED3DUSAGE_DEPTHSTENCIL)
4074 if (!CheckDepthStencilCapability(adapter, adapter_format, format))
4076 TRACE_(d3d_caps)("[FAILED] - No depth stencil support\n");
4077 return WINED3DERR_NOTAVAILABLE;
4079 if ((format->Flags & WINED3DFMT_FLAG_SHADOW) && !gl_info->supported[ARB_SHADOW])
4081 TRACE_(d3d_caps)("[FAILED] - No shadow sampler support.\n");
4082 return WINED3DERR_NOTAVAILABLE;
4084 UsageCaps |= WINED3DUSAGE_DEPTHSTENCIL;
4088 case WINED3DRTYPE_VOLUMETEXTURE:
4089 case WINED3DRTYPE_VOLUME:
4090 /* Volume is to VolumeTexture what Surface is to Texture, but its
4091 * usage caps are not documented. Most driver seem to offer
4092 * (nearly) the same on Volume and VolumeTexture, so do that too.
4094 * Volumetexture allows:
4095 * - D3DUSAGE_DYNAMIC
4096 * - D3DUSAGE_NONSECURE (d3d9ex)
4097 * - D3DUSAGE_SOFTWAREPROCESSING
4098 * - D3DUSAGE_QUERY_WRAPANDMIP
4100 if (SurfaceType != SURFACE_OPENGL)
4102 TRACE_(d3d_caps)("[FAILED]\n");
4103 return WINED3DERR_NOTAVAILABLE;
4106 if (!gl_info->supported[EXT_TEXTURE3D])
4108 TRACE_(d3d_caps)("[FAILED] - No volume texture support\n");
4109 return WINED3DERR_NOTAVAILABLE;
4112 if (!CheckTextureCapability(adapter, format))
4114 TRACE_(d3d_caps)("[FAILED] - Format not supported\n");
4115 return WINED3DERR_NOTAVAILABLE;
4118 /* Filter formats that need conversion; For one part, this
4119 * conversion is unimplemented, and volume textures are huge, so
4120 * it would be a big performance hit. Unless we hit an application
4121 * needing one of those formats, don't advertize them to avoid
4122 * leading applications into temptation. The windows drivers don't
4123 * support most of those formats on volumes anyway, except for
4124 * WINED3DFMT_R32_FLOAT. */
4125 switch (CheckFormat)
4127 case WINED3DFMT_P8_UINT:
4128 case WINED3DFMT_L4A4_UNORM:
4129 case WINED3DFMT_R32_FLOAT:
4130 case WINED3DFMT_R16_FLOAT:
4131 case WINED3DFMT_R8G8_SNORM_L8X8_UNORM:
4132 case WINED3DFMT_R5G5_SNORM_L6_UNORM:
4133 case WINED3DFMT_R16G16_UNORM:
4134 TRACE_(d3d_caps)("[FAILED] - No converted formats on volumes\n");
4135 return WINED3DERR_NOTAVAILABLE;
4137 case WINED3DFMT_R8G8B8A8_SNORM:
4138 case WINED3DFMT_R16G16_SNORM:
4139 if (!gl_info->supported[NV_TEXTURE_SHADER])
4141 TRACE_(d3d_caps)("[FAILED] - No converted formats on volumes\n");
4142 return WINED3DERR_NOTAVAILABLE;
4146 case WINED3DFMT_R8G8_SNORM:
4147 if (!gl_info->supported[NV_TEXTURE_SHADER])
4149 TRACE_(d3d_caps)("[FAILED] - No converted formats on volumes\n");
4150 return WINED3DERR_NOTAVAILABLE;
4154 case WINED3DFMT_DXT1:
4155 case WINED3DFMT_DXT2:
4156 case WINED3DFMT_DXT3:
4157 case WINED3DFMT_DXT4:
4158 case WINED3DFMT_DXT5:
4159 /* The GL_EXT_texture_compression_s3tc spec requires that
4160 * loading an s3tc compressed texture results in an error.
4161 * While the D3D refrast does support s3tc volumes, at
4162 * least the nvidia windows driver does not, so we're free
4163 * not to support this format. */
4164 TRACE_(d3d_caps)("[FAILED] - DXTn does not support 3D textures\n");
4165 return WINED3DERR_NOTAVAILABLE;
4168 /* Do nothing, continue with checking the format below */
4172 /* Always report dynamic locking. */
4173 if (Usage & WINED3DUSAGE_DYNAMIC)
4174 UsageCaps |= WINED3DUSAGE_DYNAMIC;
4176 /* Always report software processing. */
4177 if (Usage & WINED3DUSAGE_SOFTWAREPROCESSING)
4178 UsageCaps |= WINED3DUSAGE_SOFTWAREPROCESSING;
4180 if (Usage & WINED3DUSAGE_QUERY_FILTER)
4182 if (!CheckFilterCapability(adapter, format))
4184 TRACE_(d3d_caps)("[FAILED] - No query filter support\n");
4185 return WINED3DERR_NOTAVAILABLE;
4187 UsageCaps |= WINED3DUSAGE_QUERY_FILTER;
4190 if (Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING)
4192 if (!CheckPostPixelShaderBlendingCapability(adapter, format))
4194 TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
4195 return WINED3DERR_NOTAVAILABLE;
4197 UsageCaps |= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
4200 if (Usage & WINED3DUSAGE_QUERY_SRGBREAD)
4202 if (!CheckSrgbReadCapability(adapter, format))
4204 TRACE_(d3d_caps)("[FAILED] - No query srgbread support\n");
4205 return WINED3DERR_NOTAVAILABLE;
4207 UsageCaps |= WINED3DUSAGE_QUERY_SRGBREAD;
4210 if (Usage & WINED3DUSAGE_QUERY_SRGBWRITE)
4212 if (!CheckSrgbWriteCapability(adapter, format))
4214 TRACE_(d3d_caps)("[FAILED] - No query srgbwrite support\n");
4215 return WINED3DERR_NOTAVAILABLE;
4217 UsageCaps |= WINED3DUSAGE_QUERY_SRGBWRITE;
4220 if (Usage & WINED3DUSAGE_QUERY_VERTEXTEXTURE)
4222 if (!CheckVertexTextureCapability(adapter, format))
4224 TRACE_(d3d_caps)("[FAILED] - No query vertextexture support\n");
4225 return WINED3DERR_NOTAVAILABLE;
4227 UsageCaps |= WINED3DUSAGE_QUERY_VERTEXTEXTURE;
4230 if (Usage & WINED3DUSAGE_QUERY_WRAPANDMIP)
4232 if (!CheckWrapAndMipCapability(adapter, format))
4234 TRACE_(d3d_caps)("[FAILED] - No wrapping and mipmapping support\n");
4235 return WINED3DERR_NOTAVAILABLE;
4237 UsageCaps |= WINED3DUSAGE_QUERY_WRAPANDMIP;
4242 FIXME_(d3d_caps)("Unhandled resource type %s.\n", debug_d3dresourcetype(RType));
4243 return WINED3DERR_NOTAVAILABLE;
4246 /* When the UsageCaps exactly matches Usage return WINED3D_OK except for
4247 * the situation in which WINED3DUSAGE_AUTOGENMIPMAP isn't around, then
4248 * WINED3DOK_NOAUTOGEN is returned if all the other usage flags match. */
4249 if (UsageCaps == Usage)
4251 if (UsageCaps == (Usage & ~WINED3DUSAGE_AUTOGENMIPMAP))
4252 return WINED3DOK_NOAUTOGEN;
4254 TRACE_(d3d_caps)("[FAILED] - Usage %#x requested for CheckFormat %s and RType %s but only %#x is available\n",
4255 Usage, debug_d3dformat(CheckFormat), debug_d3dresourcetype(RType), UsageCaps);
4257 return WINED3DERR_NOTAVAILABLE;
4260 static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormatConversion(IWineD3D *iface, UINT adapter_idx,
4261 WINED3DDEVTYPE device_type, enum wined3d_format_id src_format, enum wined3d_format_id dst_format)
4263 FIXME("iface %p, adapter_idx %u, device_type %s, src_format %s, dst_format %s stub!\n",
4264 iface, adapter_idx, debug_d3ddevicetype(device_type), debug_d3dformat(src_format),
4265 debug_d3dformat(dst_format));
4270 static HRESULT WINAPI IWineD3DImpl_CheckDeviceType(IWineD3D *iface, UINT adapter_idx, WINED3DDEVTYPE device_type,
4271 enum wined3d_format_id display_format, enum wined3d_format_id backbuffer_format, BOOL windowed)
4276 TRACE("iface %p, adapter_idx %u, device_type %s, display_format %s, backbuffer_format %s, windowed %#x.\n",
4277 iface, adapter_idx, debug_d3ddevicetype(device_type), debug_d3dformat(display_format),
4278 debug_d3dformat(backbuffer_format), windowed);
4280 if (adapter_idx >= IWineD3D_GetAdapterCount(iface))
4282 WARN_(d3d_caps)("adapter_idx >= IWineD3D_GetAdapterCount(iface), returning WINED3DERR_INVALIDCALL\n");
4283 return WINED3DERR_INVALIDCALL;
4286 /* The task of this function is to check whether a certain display / backbuffer format
4287 * combination is available on the given adapter. In fullscreen mode microsoft specified
4288 * that the display format shouldn't provide alpha and that ignoring alpha the backbuffer
4289 * and display format should match exactly.
4290 * In windowed mode format conversion can occur and this depends on the driver. When format
4291 * conversion is done, this function should nevertheless fail and applications need to use
4292 * CheckDeviceFormatConversion.
4293 * At the moment we assume that fullscreen and windowed have the same capabilities. */
4295 /* There are only 4 display formats. */
4296 if (!(display_format == WINED3DFMT_B5G6R5_UNORM
4297 || display_format == WINED3DFMT_B5G5R5X1_UNORM
4298 || display_format == WINED3DFMT_B8G8R8X8_UNORM
4299 || display_format == WINED3DFMT_B10G10R10A2_UNORM))
4301 TRACE_(d3d_caps)("Format %s is not supported as display format.\n", debug_d3dformat(display_format));
4302 return WINED3DERR_NOTAVAILABLE;
4305 /* If the requested display format is not available, don't continue. */
4306 mode_count = IWineD3DImpl_GetAdapterModeCount(iface, adapter_idx, display_format);
4309 TRACE_(d3d_caps)("No available modes for display format %s.\n", debug_d3dformat(display_format));
4310 return WINED3DERR_NOTAVAILABLE;
4313 /* Windowed mode allows you to specify WINED3DFMT_UNKNOWN for the backbuffer format,
4314 * it means 'reuse' the display format for the backbuffer. */
4315 if (!windowed && backbuffer_format == WINED3DFMT_UNKNOWN)
4317 TRACE_(d3d_caps)("backbuffer_format WINED3FMT_UNKNOWN only available in windowed mode.\n");
4318 return WINED3DERR_NOTAVAILABLE;
4321 /* In FULLSCREEN mode WINED3DFMT_B5G6R5_UNORM can only be mixed with
4322 * backbuffer format WINED3DFMT_B5G6R5_UNORM. */
4323 if (display_format == WINED3DFMT_B5G6R5_UNORM && backbuffer_format != WINED3DFMT_B5G6R5_UNORM)
4325 TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s / %s.\n",
4326 debug_d3dformat(display_format), debug_d3dformat(backbuffer_format));
4327 return WINED3DERR_NOTAVAILABLE;
4330 /* In FULLSCREEN mode WINED3DFMT_B5G5R5X1_UNORM can only be mixed with
4331 * backbuffer formats WINED3DFMT_B5G5R5X1_UNORM and
4332 * WINED3DFMT_B5G5R5A1_UNORM. */
4333 if (display_format == WINED3DFMT_B5G5R5X1_UNORM
4334 && !(backbuffer_format == WINED3DFMT_B5G5R5X1_UNORM || backbuffer_format == WINED3DFMT_B5G5R5A1_UNORM))
4336 TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s / %s.\n",
4337 debug_d3dformat(display_format), debug_d3dformat(backbuffer_format));
4338 return WINED3DERR_NOTAVAILABLE;
4341 /* In FULLSCREEN mode WINED3DFMT_B8G8R8X8_UNORM can only be mixed with
4342 * backbuffer formats WINED3DFMT_B8G8R8X8_UNORM and
4343 * WINED3DFMT_B8G8R8A8_UNORM. */
4344 if (display_format == WINED3DFMT_B8G8R8X8_UNORM
4345 && !(backbuffer_format == WINED3DFMT_B8G8R8X8_UNORM || backbuffer_format == WINED3DFMT_B8G8R8A8_UNORM))
4347 TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s / %s.\n",
4348 debug_d3dformat(display_format), debug_d3dformat(backbuffer_format));
4349 return WINED3DERR_NOTAVAILABLE;
4352 /* WINED3DFMT_B10G10R10A2_UNORM is only allowed in fullscreen mode and it
4353 * can only be mixed with backbuffer format WINED3DFMT_B10G10R10A2_UNORM. */
4354 if (display_format == WINED3DFMT_B10G10R10A2_UNORM
4355 && (backbuffer_format != WINED3DFMT_B10G10R10A2_UNORM || windowed))
4357 TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s / %s.\n",
4358 debug_d3dformat(display_format), debug_d3dformat(backbuffer_format));
4359 return WINED3DERR_NOTAVAILABLE;
4362 /* Use CheckDeviceFormat to see if the backbuffer_format is usable with the given display_format */
4363 hr = IWineD3DImpl_CheckDeviceFormat(iface, adapter_idx, device_type, display_format,
4364 WINED3DUSAGE_RENDERTARGET, WINED3DRTYPE_SURFACE, backbuffer_format, SURFACE_OPENGL);
4366 TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s / %s.\n",
4367 debug_d3dformat(display_format), debug_d3dformat(backbuffer_format));
4372 /* Note: d3d8 passes in a pointer to a D3DCAPS8 structure, which is a true
4373 subset of a D3DCAPS9 structure. However, it has to come via a void *
4374 as the d3d8 interface cannot import the d3d9 header */
4375 static HRESULT WINAPI IWineD3DImpl_GetDeviceCaps(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType, WINED3DCAPS* pCaps) {
4377 IWineD3DImpl *This = (IWineD3DImpl *)iface;
4378 struct wined3d_adapter *adapter = &This->adapters[Adapter];
4379 const struct wined3d_gl_info *gl_info = &adapter->gl_info;
4380 int vs_selected_mode;
4381 int ps_selected_mode;
4382 struct shader_caps shader_caps;
4383 struct fragment_caps fragment_caps;
4384 DWORD ckey_caps, blit_caps, fx_caps, pal_caps;
4386 TRACE_(d3d_caps)("(%p)->(Adptr:%d, DevType: %x, pCaps: %p)\n", This, Adapter, DeviceType, pCaps);
4388 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
4389 return WINED3DERR_INVALIDCALL;
4392 select_shader_mode(&adapter->gl_info, &ps_selected_mode, &vs_selected_mode);
4394 /* ------------------------------------------------
4395 The following fields apply to both d3d8 and d3d9
4396 ------------------------------------------------ */
4397 pCaps->DeviceType = (DeviceType == WINED3DDEVTYPE_HAL) ? WINED3DDEVTYPE_HAL : WINED3DDEVTYPE_REF; /* Not quite true, but use h/w supported by opengl I suppose */
4398 pCaps->AdapterOrdinal = Adapter;
4401 pCaps->Caps2 = WINED3DCAPS2_CANRENDERWINDOWED |
4402 WINED3DCAPS2_FULLSCREENGAMMA |
4403 WINED3DCAPS2_DYNAMICTEXTURES;
4404 if (gl_info->supported[SGIS_GENERATE_MIPMAP])
4406 pCaps->Caps2 |= WINED3DCAPS2_CANAUTOGENMIPMAP;
4409 pCaps->Caps3 = WINED3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD |
4410 WINED3DCAPS3_COPY_TO_VIDMEM |
4411 WINED3DCAPS3_COPY_TO_SYSTEMMEM;
4413 pCaps->PresentationIntervals = WINED3DPRESENT_INTERVAL_IMMEDIATE |
4414 WINED3DPRESENT_INTERVAL_ONE;
4416 pCaps->CursorCaps = WINED3DCURSORCAPS_COLOR |
4417 WINED3DCURSORCAPS_LOWRES;
4419 pCaps->DevCaps = WINED3DDEVCAPS_FLOATTLVERTEX |
4420 WINED3DDEVCAPS_EXECUTESYSTEMMEMORY |
4421 WINED3DDEVCAPS_TLVERTEXSYSTEMMEMORY|
4422 WINED3DDEVCAPS_TLVERTEXVIDEOMEMORY |
4423 WINED3DDEVCAPS_DRAWPRIMTLVERTEX |
4424 WINED3DDEVCAPS_HWTRANSFORMANDLIGHT |
4425 WINED3DDEVCAPS_EXECUTEVIDEOMEMORY |
4426 WINED3DDEVCAPS_PUREDEVICE |
4427 WINED3DDEVCAPS_HWRASTERIZATION |
4428 WINED3DDEVCAPS_TEXTUREVIDEOMEMORY |
4429 WINED3DDEVCAPS_TEXTURESYSTEMMEMORY |
4430 WINED3DDEVCAPS_CANRENDERAFTERFLIP |
4431 WINED3DDEVCAPS_DRAWPRIMITIVES2 |
4432 WINED3DDEVCAPS_DRAWPRIMITIVES2EX |
4433 WINED3DDEVCAPS_RTPATCHES;
4435 pCaps->PrimitiveMiscCaps = WINED3DPMISCCAPS_CULLNONE |
4436 WINED3DPMISCCAPS_CULLCCW |
4437 WINED3DPMISCCAPS_CULLCW |
4438 WINED3DPMISCCAPS_COLORWRITEENABLE |
4439 WINED3DPMISCCAPS_CLIPTLVERTS |
4440 WINED3DPMISCCAPS_CLIPPLANESCALEDPOINTS |
4441 WINED3DPMISCCAPS_MASKZ |
4442 WINED3DPMISCCAPS_BLENDOP |
4443 WINED3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING;
4445 WINED3DPMISCCAPS_NULLREFERENCE
4446 WINED3DPMISCCAPS_FOGANDSPECULARALPHA
4447 WINED3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS
4448 WINED3DPMISCCAPS_FOGVERTEXCLAMPED */
4450 if (gl_info->supported[EXT_BLEND_EQUATION_SEPARATE] && gl_info->supported[EXT_BLEND_FUNC_SEPARATE])
4451 pCaps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_SEPARATEALPHABLEND;
4452 if (gl_info->supported[EXT_DRAW_BUFFERS2])
4453 pCaps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_INDEPENDENTWRITEMASKS;
4455 pCaps->RasterCaps = WINED3DPRASTERCAPS_DITHER |
4456 WINED3DPRASTERCAPS_PAT |
4457 WINED3DPRASTERCAPS_WFOG |
4458 WINED3DPRASTERCAPS_ZFOG |
4459 WINED3DPRASTERCAPS_FOGVERTEX |
4460 WINED3DPRASTERCAPS_FOGTABLE |
4461 WINED3DPRASTERCAPS_STIPPLE |
4462 WINED3DPRASTERCAPS_SUBPIXEL |
4463 WINED3DPRASTERCAPS_ZTEST |
4464 WINED3DPRASTERCAPS_SCISSORTEST |
4465 WINED3DPRASTERCAPS_SLOPESCALEDEPTHBIAS |
4466 WINED3DPRASTERCAPS_DEPTHBIAS;
4468 if (gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC])
4470 pCaps->RasterCaps |= WINED3DPRASTERCAPS_ANISOTROPY |
4471 WINED3DPRASTERCAPS_ZBIAS |
4472 WINED3DPRASTERCAPS_MIPMAPLODBIAS;
4474 if (gl_info->supported[NV_FOG_DISTANCE])
4476 pCaps->RasterCaps |= WINED3DPRASTERCAPS_FOGRANGE;
4479 WINED3DPRASTERCAPS_COLORPERSPECTIVE
4480 WINED3DPRASTERCAPS_STRETCHBLTMULTISAMPLE
4481 WINED3DPRASTERCAPS_ANTIALIASEDGES
4482 WINED3DPRASTERCAPS_ZBUFFERLESSHSR
4483 WINED3DPRASTERCAPS_WBUFFER */
4485 pCaps->ZCmpCaps = WINED3DPCMPCAPS_ALWAYS |
4486 WINED3DPCMPCAPS_EQUAL |
4487 WINED3DPCMPCAPS_GREATER |
4488 WINED3DPCMPCAPS_GREATEREQUAL |
4489 WINED3DPCMPCAPS_LESS |
4490 WINED3DPCMPCAPS_LESSEQUAL |
4491 WINED3DPCMPCAPS_NEVER |
4492 WINED3DPCMPCAPS_NOTEQUAL;
4494 pCaps->SrcBlendCaps = WINED3DPBLENDCAPS_BOTHINVSRCALPHA |
4495 WINED3DPBLENDCAPS_BOTHSRCALPHA |
4496 WINED3DPBLENDCAPS_DESTALPHA |
4497 WINED3DPBLENDCAPS_DESTCOLOR |
4498 WINED3DPBLENDCAPS_INVDESTALPHA |
4499 WINED3DPBLENDCAPS_INVDESTCOLOR |
4500 WINED3DPBLENDCAPS_INVSRCALPHA |
4501 WINED3DPBLENDCAPS_INVSRCCOLOR |
4502 WINED3DPBLENDCAPS_ONE |
4503 WINED3DPBLENDCAPS_SRCALPHA |
4504 WINED3DPBLENDCAPS_SRCALPHASAT |
4505 WINED3DPBLENDCAPS_SRCCOLOR |
4506 WINED3DPBLENDCAPS_ZERO;
4508 pCaps->DestBlendCaps = WINED3DPBLENDCAPS_DESTALPHA |
4509 WINED3DPBLENDCAPS_DESTCOLOR |
4510 WINED3DPBLENDCAPS_INVDESTALPHA |
4511 WINED3DPBLENDCAPS_INVDESTCOLOR |
4512 WINED3DPBLENDCAPS_INVSRCALPHA |
4513 WINED3DPBLENDCAPS_INVSRCCOLOR |
4514 WINED3DPBLENDCAPS_ONE |
4515 WINED3DPBLENDCAPS_SRCALPHA |
4516 WINED3DPBLENDCAPS_SRCCOLOR |
4517 WINED3DPBLENDCAPS_ZERO;
4518 /* NOTE: WINED3DPBLENDCAPS_SRCALPHASAT is not supported as dest blend factor,
4519 * according to the glBlendFunc manpage
4521 * WINED3DPBLENDCAPS_BOTHINVSRCALPHA and WINED3DPBLENDCAPS_BOTHSRCALPHA are
4522 * legacy settings for srcblend only
4525 if (gl_info->supported[EXT_BLEND_COLOR])
4527 pCaps->SrcBlendCaps |= WINED3DPBLENDCAPS_BLENDFACTOR;
4528 pCaps->DestBlendCaps |= WINED3DPBLENDCAPS_BLENDFACTOR;
4532 pCaps->AlphaCmpCaps = WINED3DPCMPCAPS_ALWAYS |
4533 WINED3DPCMPCAPS_EQUAL |
4534 WINED3DPCMPCAPS_GREATER |
4535 WINED3DPCMPCAPS_GREATEREQUAL |
4536 WINED3DPCMPCAPS_LESS |
4537 WINED3DPCMPCAPS_LESSEQUAL |
4538 WINED3DPCMPCAPS_NEVER |
4539 WINED3DPCMPCAPS_NOTEQUAL;
4541 pCaps->ShadeCaps = WINED3DPSHADECAPS_SPECULARGOURAUDRGB |
4542 WINED3DPSHADECAPS_COLORGOURAUDRGB |
4543 WINED3DPSHADECAPS_ALPHAFLATBLEND |
4544 WINED3DPSHADECAPS_ALPHAGOURAUDBLEND |
4545 WINED3DPSHADECAPS_COLORFLATRGB |
4546 WINED3DPSHADECAPS_FOGFLAT |
4547 WINED3DPSHADECAPS_FOGGOURAUD |
4548 WINED3DPSHADECAPS_SPECULARFLATRGB;
4550 pCaps->TextureCaps = WINED3DPTEXTURECAPS_ALPHA |
4551 WINED3DPTEXTURECAPS_ALPHAPALETTE |
4552 WINED3DPTEXTURECAPS_TRANSPARENCY |
4553 WINED3DPTEXTURECAPS_BORDER |
4554 WINED3DPTEXTURECAPS_MIPMAP |
4555 WINED3DPTEXTURECAPS_PROJECTED |
4556 WINED3DPTEXTURECAPS_PERSPECTIVE;
4558 if (!gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO])
4560 pCaps->TextureCaps |= WINED3DPTEXTURECAPS_POW2 |
4561 WINED3DPTEXTURECAPS_NONPOW2CONDITIONAL;
4564 if (gl_info->supported[EXT_TEXTURE3D])
4566 pCaps->TextureCaps |= WINED3DPTEXTURECAPS_VOLUMEMAP |
4567 WINED3DPTEXTURECAPS_MIPVOLUMEMAP |
4568 WINED3DPTEXTURECAPS_VOLUMEMAP_POW2;
4571 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
4573 pCaps->TextureCaps |= WINED3DPTEXTURECAPS_CUBEMAP |
4574 WINED3DPTEXTURECAPS_MIPCUBEMAP |
4575 WINED3DPTEXTURECAPS_CUBEMAP_POW2;
4579 pCaps->TextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR |
4580 WINED3DPTFILTERCAPS_MAGFPOINT |
4581 WINED3DPTFILTERCAPS_MINFLINEAR |
4582 WINED3DPTFILTERCAPS_MINFPOINT |
4583 WINED3DPTFILTERCAPS_MIPFLINEAR |
4584 WINED3DPTFILTERCAPS_MIPFPOINT |
4585 WINED3DPTFILTERCAPS_LINEAR |
4586 WINED3DPTFILTERCAPS_LINEARMIPLINEAR |
4587 WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
4588 WINED3DPTFILTERCAPS_MIPLINEAR |
4589 WINED3DPTFILTERCAPS_MIPNEAREST |
4590 WINED3DPTFILTERCAPS_NEAREST;
4592 if (gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC])
4594 pCaps->TextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC |
4595 WINED3DPTFILTERCAPS_MINFANISOTROPIC;
4598 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
4600 pCaps->CubeTextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR |
4601 WINED3DPTFILTERCAPS_MAGFPOINT |
4602 WINED3DPTFILTERCAPS_MINFLINEAR |
4603 WINED3DPTFILTERCAPS_MINFPOINT |
4604 WINED3DPTFILTERCAPS_MIPFLINEAR |
4605 WINED3DPTFILTERCAPS_MIPFPOINT |
4606 WINED3DPTFILTERCAPS_LINEAR |
4607 WINED3DPTFILTERCAPS_LINEARMIPLINEAR |
4608 WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
4609 WINED3DPTFILTERCAPS_MIPLINEAR |
4610 WINED3DPTFILTERCAPS_MIPNEAREST |
4611 WINED3DPTFILTERCAPS_NEAREST;
4613 if (gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC])
4615 pCaps->CubeTextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC |
4616 WINED3DPTFILTERCAPS_MINFANISOTROPIC;
4619 pCaps->CubeTextureFilterCaps = 0;
4621 if (gl_info->supported[EXT_TEXTURE3D])
4623 pCaps->VolumeTextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR |
4624 WINED3DPTFILTERCAPS_MAGFPOINT |
4625 WINED3DPTFILTERCAPS_MINFLINEAR |
4626 WINED3DPTFILTERCAPS_MINFPOINT |
4627 WINED3DPTFILTERCAPS_MIPFLINEAR |
4628 WINED3DPTFILTERCAPS_MIPFPOINT |
4629 WINED3DPTFILTERCAPS_LINEAR |
4630 WINED3DPTFILTERCAPS_LINEARMIPLINEAR |
4631 WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
4632 WINED3DPTFILTERCAPS_MIPLINEAR |
4633 WINED3DPTFILTERCAPS_MIPNEAREST |
4634 WINED3DPTFILTERCAPS_NEAREST;
4636 pCaps->VolumeTextureFilterCaps = 0;
4638 pCaps->TextureAddressCaps = WINED3DPTADDRESSCAPS_INDEPENDENTUV |
4639 WINED3DPTADDRESSCAPS_CLAMP |
4640 WINED3DPTADDRESSCAPS_WRAP;
4642 if (gl_info->supported[ARB_TEXTURE_BORDER_CLAMP])
4644 pCaps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_BORDER;
4646 if (gl_info->supported[ARB_TEXTURE_MIRRORED_REPEAT])
4648 pCaps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRROR;
4650 if (gl_info->supported[ATI_TEXTURE_MIRROR_ONCE])
4652 pCaps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRRORONCE;
4655 if (gl_info->supported[EXT_TEXTURE3D])
4657 pCaps->VolumeTextureAddressCaps = WINED3DPTADDRESSCAPS_INDEPENDENTUV |
4658 WINED3DPTADDRESSCAPS_CLAMP |
4659 WINED3DPTADDRESSCAPS_WRAP;
4660 if (gl_info->supported[ARB_TEXTURE_BORDER_CLAMP])
4662 pCaps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_BORDER;
4664 if (gl_info->supported[ARB_TEXTURE_MIRRORED_REPEAT])
4666 pCaps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRROR;
4668 if (gl_info->supported[ATI_TEXTURE_MIRROR_ONCE])
4670 pCaps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRRORONCE;
4673 pCaps->VolumeTextureAddressCaps = 0;
4675 pCaps->LineCaps = WINED3DLINECAPS_TEXTURE |
4676 WINED3DLINECAPS_ZTEST |
4677 WINED3DLINECAPS_BLEND |
4678 WINED3DLINECAPS_ALPHACMP |
4679 WINED3DLINECAPS_FOG;
4680 /* WINED3DLINECAPS_ANTIALIAS is not supported on Windows, and dx and gl seem to have a different
4681 * idea how generating the smoothing alpha values works; the result is different
4684 pCaps->MaxTextureWidth = gl_info->limits.texture_size;
4685 pCaps->MaxTextureHeight = gl_info->limits.texture_size;
4687 if (gl_info->supported[EXT_TEXTURE3D])
4688 pCaps->MaxVolumeExtent = gl_info->limits.texture3d_size;
4690 pCaps->MaxVolumeExtent = 0;
4692 pCaps->MaxTextureRepeat = 32768;
4693 pCaps->MaxTextureAspectRatio = gl_info->limits.texture_size;
4694 pCaps->MaxVertexW = 1.0f;
4696 pCaps->GuardBandLeft = 0.0f;
4697 pCaps->GuardBandTop = 0.0f;
4698 pCaps->GuardBandRight = 0.0f;
4699 pCaps->GuardBandBottom = 0.0f;
4701 pCaps->ExtentsAdjust = 0.0f;
4703 pCaps->StencilCaps = WINED3DSTENCILCAPS_DECRSAT |
4704 WINED3DSTENCILCAPS_INCRSAT |
4705 WINED3DSTENCILCAPS_INVERT |
4706 WINED3DSTENCILCAPS_KEEP |
4707 WINED3DSTENCILCAPS_REPLACE |
4708 WINED3DSTENCILCAPS_ZERO;
4709 if (gl_info->supported[EXT_STENCIL_WRAP])
4711 pCaps->StencilCaps |= WINED3DSTENCILCAPS_DECR |
4712 WINED3DSTENCILCAPS_INCR;
4714 if (gl_info->supported[EXT_STENCIL_TWO_SIDE] || gl_info->supported[ATI_SEPARATE_STENCIL])
4716 pCaps->StencilCaps |= WINED3DSTENCILCAPS_TWOSIDED;
4719 pCaps->FVFCaps = WINED3DFVFCAPS_PSIZE | 0x0008; /* 8 texture coords */
4721 pCaps->MaxUserClipPlanes = gl_info->limits.clipplanes;
4722 pCaps->MaxActiveLights = gl_info->limits.lights;
4724 pCaps->MaxVertexBlendMatrices = gl_info->limits.blends;
4725 pCaps->MaxVertexBlendMatrixIndex = 0;
4727 pCaps->MaxAnisotropy = gl_info->limits.anisotropy;
4728 pCaps->MaxPointSize = gl_info->limits.pointsize_max;
4731 /* FIXME: Add D3DVTXPCAPS_TWEENING, D3DVTXPCAPS_TEXGEN_SPHEREMAP */
4732 pCaps->VertexProcessingCaps = WINED3DVTXPCAPS_DIRECTIONALLIGHTS |
4733 WINED3DVTXPCAPS_MATERIALSOURCE7 |
4734 WINED3DVTXPCAPS_POSITIONALLIGHTS |
4735 WINED3DVTXPCAPS_LOCALVIEWER |
4736 WINED3DVTXPCAPS_VERTEXFOG |
4737 WINED3DVTXPCAPS_TEXGEN;
4739 pCaps->MaxPrimitiveCount = 0xFFFFF; /* For now set 2^20-1 which is used by most >=Geforce3/Radeon8500 cards */
4740 pCaps->MaxVertexIndex = 0xFFFFF;
4741 pCaps->MaxStreams = MAX_STREAMS;
4742 pCaps->MaxStreamStride = 1024;
4744 /* d3d9.dll sets D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES here because StretchRects is implemented in d3d9 */
4745 pCaps->DevCaps2 = WINED3DDEVCAPS2_STREAMOFFSET |
4746 WINED3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET;
4747 pCaps->MaxNpatchTessellationLevel = 0;
4748 pCaps->MasterAdapterOrdinal = 0;
4749 pCaps->AdapterOrdinalInGroup = 0;
4750 pCaps->NumberOfAdaptersInGroup = 1;
4752 pCaps->NumSimultaneousRTs = gl_info->limits.buffers;
4754 pCaps->StretchRectFilterCaps = WINED3DPTFILTERCAPS_MINFPOINT |
4755 WINED3DPTFILTERCAPS_MAGFPOINT |
4756 WINED3DPTFILTERCAPS_MINFLINEAR |
4757 WINED3DPTFILTERCAPS_MAGFLINEAR;
4758 pCaps->VertexTextureFilterCaps = 0;
4760 adapter->shader_backend->shader_get_caps(&adapter->gl_info, &shader_caps);
4761 adapter->fragment_pipe->get_caps(&adapter->gl_info, &fragment_caps);
4763 /* Add shader misc caps. Only some of them belong to the shader parts of the pipeline */
4764 pCaps->PrimitiveMiscCaps |= fragment_caps.PrimitiveMiscCaps;
4766 /* This takes care for disabling vertex shader or pixel shader caps while leaving the other one enabled.
4767 * Ignore shader model capabilities if disabled in config
4769 if(vs_selected_mode == SHADER_NONE) {
4770 TRACE_(d3d_caps)("Vertex shader disabled in config, reporting version 0.0\n");
4771 pCaps->VertexShaderVersion = WINED3DVS_VERSION(0,0);
4772 pCaps->MaxVertexShaderConst = 0;
4774 pCaps->VertexShaderVersion = shader_caps.VertexShaderVersion;
4775 pCaps->MaxVertexShaderConst = shader_caps.MaxVertexShaderConst;
4778 if(ps_selected_mode == SHADER_NONE) {
4779 TRACE_(d3d_caps)("Pixel shader disabled in config, reporting version 0.0\n");
4780 pCaps->PixelShaderVersion = WINED3DPS_VERSION(0,0);
4781 pCaps->PixelShader1xMaxValue = 0.0f;
4783 pCaps->PixelShaderVersion = shader_caps.PixelShaderVersion;
4784 pCaps->PixelShader1xMaxValue = shader_caps.PixelShader1xMaxValue;
4787 pCaps->TextureOpCaps = fragment_caps.TextureOpCaps;
4788 pCaps->MaxTextureBlendStages = fragment_caps.MaxTextureBlendStages;
4789 pCaps->MaxSimultaneousTextures = fragment_caps.MaxSimultaneousTextures;
4791 /* The following caps are shader specific, but they are things we cannot detect, or which
4792 * are the same among all shader models. So to avoid code duplication set the shader version
4793 * specific, but otherwise constant caps here
4795 if(pCaps->VertexShaderVersion == WINED3DVS_VERSION(3,0)) {
4796 /* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering)
4797 use the VS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum VS3.0 value. */
4798 pCaps->VS20Caps.Caps = WINED3DVS20CAPS_PREDICATION;
4799 pCaps->VS20Caps.DynamicFlowControlDepth = WINED3DVS20_MAX_DYNAMICFLOWCONTROLDEPTH; /* VS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
4800 pCaps->VS20Caps.NumTemps = max(32, adapter->gl_info.limits.arb_vs_temps);
4801 pCaps->VS20Caps.StaticFlowControlDepth = WINED3DVS20_MAX_STATICFLOWCONTROLDEPTH ; /* level of nesting in loops / if-statements; VS 3.0 requires MAX (4) */
4803 pCaps->MaxVShaderInstructionsExecuted = 65535; /* VS 3.0 needs at least 65535, some cards even use 2^32-1 */
4804 pCaps->MaxVertexShader30InstructionSlots = max(512, adapter->gl_info.limits.arb_vs_instructions);
4806 else if (pCaps->VertexShaderVersion == WINED3DVS_VERSION(2,0))
4808 pCaps->VS20Caps.Caps = 0;
4809 pCaps->VS20Caps.DynamicFlowControlDepth = WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH;
4810 pCaps->VS20Caps.NumTemps = max(12, adapter->gl_info.limits.arb_vs_temps);
4811 pCaps->VS20Caps.StaticFlowControlDepth = 1;
4813 pCaps->MaxVShaderInstructionsExecuted = 65535;
4814 pCaps->MaxVertexShader30InstructionSlots = 0;
4815 } else { /* VS 1.x */
4816 pCaps->VS20Caps.Caps = 0;
4817 pCaps->VS20Caps.DynamicFlowControlDepth = 0;
4818 pCaps->VS20Caps.NumTemps = 0;
4819 pCaps->VS20Caps.StaticFlowControlDepth = 0;
4821 pCaps->MaxVShaderInstructionsExecuted = 0;
4822 pCaps->MaxVertexShader30InstructionSlots = 0;
4825 if(pCaps->PixelShaderVersion == WINED3DPS_VERSION(3,0)) {
4826 /* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering)
4827 use the PS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum PS 3.0 value. */
4829 /* 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 */
4830 pCaps->PS20Caps.Caps = WINED3DPS20CAPS_ARBITRARYSWIZZLE |
4831 WINED3DPS20CAPS_GRADIENTINSTRUCTIONS |
4832 WINED3DPS20CAPS_PREDICATION |
4833 WINED3DPS20CAPS_NODEPENDENTREADLIMIT |
4834 WINED3DPS20CAPS_NOTEXINSTRUCTIONLIMIT;
4835 pCaps->PS20Caps.DynamicFlowControlDepth = WINED3DPS20_MAX_DYNAMICFLOWCONTROLDEPTH; /* PS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
4836 pCaps->PS20Caps.NumTemps = max(32, adapter->gl_info.limits.arb_ps_temps);
4837 pCaps->PS20Caps.StaticFlowControlDepth = WINED3DPS20_MAX_STATICFLOWCONTROLDEPTH; /* PS 3.0 requires MAX_STATICFLOWCONTROLDEPTH (4) */
4838 pCaps->PS20Caps.NumInstructionSlots = WINED3DPS20_MAX_NUMINSTRUCTIONSLOTS; /* PS 3.0 requires MAX_NUMINSTRUCTIONSLOTS (512) */
4840 pCaps->MaxPShaderInstructionsExecuted = 65535;
4841 pCaps->MaxPixelShader30InstructionSlots = max(WINED3DMIN30SHADERINSTRUCTIONS,
4842 adapter->gl_info.limits.arb_ps_instructions);
4844 else if(pCaps->PixelShaderVersion == WINED3DPS_VERSION(2,0))
4846 /* Below we assume PS2.0 specs, not extended 2.0a(GeforceFX)/2.0b(Radeon R3xx) ones */
4847 pCaps->PS20Caps.Caps = 0;
4848 pCaps->PS20Caps.DynamicFlowControlDepth = 0; /* WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH = 0 */
4849 pCaps->PS20Caps.NumTemps = max(12, adapter->gl_info.limits.arb_ps_temps);
4850 pCaps->PS20Caps.StaticFlowControlDepth = WINED3DPS20_MIN_STATICFLOWCONTROLDEPTH; /* Minimum: 1 */
4851 pCaps->PS20Caps.NumInstructionSlots = WINED3DPS20_MIN_NUMINSTRUCTIONSLOTS; /* Minimum number (64 ALU + 32 Texture), a GeforceFX uses 512 */
4853 pCaps->MaxPShaderInstructionsExecuted = 512; /* Minimum value, a GeforceFX uses 1024 */
4854 pCaps->MaxPixelShader30InstructionSlots = 0;
4855 } else { /* PS 1.x */
4856 pCaps->PS20Caps.Caps = 0;
4857 pCaps->PS20Caps.DynamicFlowControlDepth = 0;
4858 pCaps->PS20Caps.NumTemps = 0;
4859 pCaps->PS20Caps.StaticFlowControlDepth = 0;
4860 pCaps->PS20Caps.NumInstructionSlots = 0;
4862 pCaps->MaxPShaderInstructionsExecuted = 0;
4863 pCaps->MaxPixelShader30InstructionSlots = 0;
4866 if(pCaps->VertexShaderVersion >= WINED3DVS_VERSION(2,0)) {
4867 /* OpenGL supports all the formats below, perhaps not always
4868 * without conversion, but it supports them.
4869 * Further GLSL doesn't seem to have an official unsigned type so
4870 * don't advertise it yet as I'm not sure how we handle it.
4871 * We might need to add some clamping in the shader engine to
4873 * TODO: WINED3DDTCAPS_USHORT2N, WINED3DDTCAPS_USHORT4N, WINED3DDTCAPS_UDEC3, WINED3DDTCAPS_DEC3N */
4874 pCaps->DeclTypes = WINED3DDTCAPS_UBYTE4 |
4875 WINED3DDTCAPS_UBYTE4N |
4876 WINED3DDTCAPS_SHORT2N |
4877 WINED3DDTCAPS_SHORT4N;
4878 if (gl_info->supported[ARB_HALF_FLOAT_VERTEX])
4880 pCaps->DeclTypes |= WINED3DDTCAPS_FLOAT16_2 |
4881 WINED3DDTCAPS_FLOAT16_4;
4884 pCaps->DeclTypes = 0;
4886 /* Set DirectDraw helper Caps */
4887 ckey_caps = WINEDDCKEYCAPS_DESTBLT |
4888 WINEDDCKEYCAPS_SRCBLT;
4889 fx_caps = WINEDDFXCAPS_BLTALPHA |
4890 WINEDDFXCAPS_BLTMIRRORLEFTRIGHT |
4891 WINEDDFXCAPS_BLTMIRRORUPDOWN |
4892 WINEDDFXCAPS_BLTROTATION90 |
4893 WINEDDFXCAPS_BLTSHRINKX |
4894 WINEDDFXCAPS_BLTSHRINKXN |
4895 WINEDDFXCAPS_BLTSHRINKY |
4896 WINEDDFXCAPS_BLTSHRINKXN |
4897 WINEDDFXCAPS_BLTSTRETCHX |
4898 WINEDDFXCAPS_BLTSTRETCHXN |
4899 WINEDDFXCAPS_BLTSTRETCHY |
4900 WINEDDFXCAPS_BLTSTRETCHYN;
4901 blit_caps = WINEDDCAPS_BLT |
4902 WINEDDCAPS_BLTCOLORFILL |
4903 WINEDDCAPS_BLTDEPTHFILL |
4904 WINEDDCAPS_BLTSTRETCH |
4905 WINEDDCAPS_CANBLTSYSMEM |
4906 WINEDDCAPS_CANCLIP |
4907 WINEDDCAPS_CANCLIPSTRETCHED |
4908 WINEDDCAPS_COLORKEY |
4909 WINEDDCAPS_COLORKEYHWASSIST |
4910 WINEDDCAPS_ALIGNBOUNDARYSRC;
4911 pal_caps = WINEDDPCAPS_8BIT |
4912 WINEDDPCAPS_PRIMARYSURFACE;
4914 /* Fill the ddraw caps structure */
4915 pCaps->DirectDrawCaps.Caps = WINEDDCAPS_GDI |
4916 WINEDDCAPS_PALETTE |
4918 pCaps->DirectDrawCaps.Caps2 = WINEDDCAPS2_CERTIFIED |
4919 WINEDDCAPS2_NOPAGELOCKREQUIRED |
4920 WINEDDCAPS2_PRIMARYGAMMA |
4921 WINEDDCAPS2_WIDESURFACES |
4922 WINEDDCAPS2_CANRENDERWINDOWED;
4923 pCaps->DirectDrawCaps.CKeyCaps = ckey_caps;
4924 pCaps->DirectDrawCaps.FXCaps = fx_caps;
4925 pCaps->DirectDrawCaps.PalCaps = pal_caps;
4926 pCaps->DirectDrawCaps.SVBCaps = blit_caps;
4927 pCaps->DirectDrawCaps.SVBCKeyCaps = ckey_caps;
4928 pCaps->DirectDrawCaps.SVBFXCaps = fx_caps;
4929 pCaps->DirectDrawCaps.VSBCaps = blit_caps;
4930 pCaps->DirectDrawCaps.VSBCKeyCaps = ckey_caps;
4931 pCaps->DirectDrawCaps.VSBFXCaps = fx_caps;
4932 pCaps->DirectDrawCaps.SSBCaps = blit_caps;
4933 pCaps->DirectDrawCaps.SSBCKeyCaps = ckey_caps;
4934 pCaps->DirectDrawCaps.SSBFXCaps = fx_caps;
4936 pCaps->DirectDrawCaps.ddsCaps = WINEDDSCAPS_ALPHA |
4937 WINEDDSCAPS_BACKBUFFER |
4939 WINEDDSCAPS_FRONTBUFFER |
4940 WINEDDSCAPS_OFFSCREENPLAIN |
4941 WINEDDSCAPS_PALETTE |
4942 WINEDDSCAPS_PRIMARYSURFACE |
4943 WINEDDSCAPS_SYSTEMMEMORY |
4944 WINEDDSCAPS_VIDEOMEMORY |
4945 WINEDDSCAPS_VISIBLE;
4946 pCaps->DirectDrawCaps.StrideAlign = DDRAW_PITCH_ALIGNMENT;
4948 /* Set D3D caps if OpenGL is available. */
4949 if (adapter->opengl)
4951 pCaps->DirectDrawCaps.ddsCaps |=WINEDDSCAPS_3DDEVICE |
4952 WINEDDSCAPS_MIPMAP |
4953 WINEDDSCAPS_TEXTURE |
4954 WINEDDSCAPS_ZBUFFER;
4955 pCaps->DirectDrawCaps.Caps |= WINEDDCAPS_3D;
4961 static HRESULT WINAPI IWineD3DImpl_CreateDevice(IWineD3D *iface, UINT adapter_idx, WINED3DDEVTYPE device_type,
4962 HWND focus_window, DWORD flags, IWineD3DDeviceParent *device_parent, IWineD3DDevice **device)
4964 IWineD3DImpl *This = (IWineD3DImpl *)iface;
4965 IWineD3DDeviceImpl *object;
4968 TRACE("iface %p, adapter_idx %u, device_type %#x, focus_window %p, flags %#x, device_parent %p, device %p.\n",
4969 iface, adapter_idx, device_type, focus_window, flags, device_parent, device);
4971 /* Validate the adapter number. If no adapters are available(no GL), ignore the adapter
4972 * number and create a device without a 3D adapter for 2D only operation. */
4973 if (IWineD3D_GetAdapterCount(iface) && adapter_idx >= IWineD3D_GetAdapterCount(iface))
4975 return WINED3DERR_INVALIDCALL;
4978 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
4981 ERR("Failed to allocate device memory.\n");
4982 return E_OUTOFMEMORY;
4985 hr = device_init(object, This, adapter_idx, device_type, focus_window, flags, device_parent);
4988 WARN("Failed to initialize device, hr %#x.\n", hr);
4989 HeapFree(GetProcessHeap(), 0, object);
4993 TRACE("Created device %p.\n", object);
4994 *device = (IWineD3DDevice *)object;
4996 IWineD3DDeviceParent_WineD3DDeviceCreated(device_parent, *device);
5001 static void * WINAPI IWineD3DImpl_GetParent(IWineD3D *iface)
5003 TRACE("iface %p.\n", iface);
5005 return ((IWineD3DImpl *)iface)->parent;
5008 static void WINE_GLAPI invalid_func(const void *data)
5010 ERR("Invalid vertex attribute function called\n");
5014 static void WINE_GLAPI invalid_texcoord_func(GLenum unit, const void *data)
5016 ERR("Invalid texcoord function called\n");
5020 /* Helper functions for providing vertex data to opengl. The arrays are initialized based on
5021 * the extension detection and are used in drawStridedSlow
5023 static void WINE_GLAPI position_d3dcolor(const void *data)
5025 DWORD pos = *((const DWORD *)data);
5027 FIXME("Add a test for fixed function position from d3dcolor type\n");
5028 glVertex4s(D3DCOLOR_B_R(pos),
5034 static void WINE_GLAPI position_float4(const void *data)
5036 const GLfloat *pos = data;
5038 if (pos[3] != 0.0f && pos[3] != 1.0f)
5040 float w = 1.0f / pos[3];
5042 glVertex4f(pos[0] * w, pos[1] * w, pos[2] * w, w);
5050 static void WINE_GLAPI diffuse_d3dcolor(const void *data)
5052 DWORD diffuseColor = *((const DWORD *)data);
5054 glColor4ub(D3DCOLOR_B_R(diffuseColor),
5055 D3DCOLOR_B_G(diffuseColor),
5056 D3DCOLOR_B_B(diffuseColor),
5057 D3DCOLOR_B_A(diffuseColor));
5060 static void WINE_GLAPI specular_d3dcolor(const void *data)
5062 DWORD specularColor = *((const DWORD *)data);
5063 GLbyte d[] = {D3DCOLOR_B_R(specularColor),
5064 D3DCOLOR_B_G(specularColor),
5065 D3DCOLOR_B_B(specularColor)};
5067 specular_func_3ubv(d);
5070 static void WINE_GLAPI warn_no_specular_func(const void *data)
5072 WARN("GL_EXT_secondary_color not supported\n");
5075 static void fillGLAttribFuncs(const struct wined3d_gl_info *gl_info)
5077 position_funcs[WINED3D_FFP_EMIT_FLOAT1] = invalid_func;
5078 position_funcs[WINED3D_FFP_EMIT_FLOAT2] = invalid_func;
5079 position_funcs[WINED3D_FFP_EMIT_FLOAT3] = (glAttribFunc)glVertex3fv;
5080 position_funcs[WINED3D_FFP_EMIT_FLOAT4] = position_float4;
5081 position_funcs[WINED3D_FFP_EMIT_D3DCOLOR] = position_d3dcolor;
5082 position_funcs[WINED3D_FFP_EMIT_UBYTE4] = invalid_func;
5083 position_funcs[WINED3D_FFP_EMIT_SHORT2] = invalid_func;
5084 position_funcs[WINED3D_FFP_EMIT_SHORT4] = (glAttribFunc)glVertex2sv;
5085 position_funcs[WINED3D_FFP_EMIT_UBYTE4N] = invalid_func;
5086 position_funcs[WINED3D_FFP_EMIT_SHORT2N] = invalid_func;
5087 position_funcs[WINED3D_FFP_EMIT_SHORT4N] = invalid_func;
5088 position_funcs[WINED3D_FFP_EMIT_USHORT2N] = invalid_func;
5089 position_funcs[WINED3D_FFP_EMIT_USHORT4N] = invalid_func;
5090 position_funcs[WINED3D_FFP_EMIT_UDEC3] = invalid_func;
5091 position_funcs[WINED3D_FFP_EMIT_DEC3N] = invalid_func;
5092 position_funcs[WINED3D_FFP_EMIT_FLOAT16_2] = invalid_func;
5093 position_funcs[WINED3D_FFP_EMIT_FLOAT16_4] = invalid_func;
5095 diffuse_funcs[WINED3D_FFP_EMIT_FLOAT1] = invalid_func;
5096 diffuse_funcs[WINED3D_FFP_EMIT_FLOAT2] = invalid_func;
5097 diffuse_funcs[WINED3D_FFP_EMIT_FLOAT3] = (glAttribFunc)glColor3fv;
5098 diffuse_funcs[WINED3D_FFP_EMIT_FLOAT4] = (glAttribFunc)glColor4fv;
5099 diffuse_funcs[WINED3D_FFP_EMIT_D3DCOLOR] = diffuse_d3dcolor;
5100 diffuse_funcs[WINED3D_FFP_EMIT_UBYTE4] = invalid_func;
5101 diffuse_funcs[WINED3D_FFP_EMIT_SHORT2] = invalid_func;
5102 diffuse_funcs[WINED3D_FFP_EMIT_SHORT4] = invalid_func;
5103 diffuse_funcs[WINED3D_FFP_EMIT_UBYTE4N] = (glAttribFunc)glColor4ubv;
5104 diffuse_funcs[WINED3D_FFP_EMIT_SHORT2N] = invalid_func;
5105 diffuse_funcs[WINED3D_FFP_EMIT_SHORT4N] = (glAttribFunc)glColor4sv;
5106 diffuse_funcs[WINED3D_FFP_EMIT_USHORT2N] = invalid_func;
5107 diffuse_funcs[WINED3D_FFP_EMIT_USHORT4N] = (glAttribFunc)glColor4usv;
5108 diffuse_funcs[WINED3D_FFP_EMIT_UDEC3] = invalid_func;
5109 diffuse_funcs[WINED3D_FFP_EMIT_DEC3N] = invalid_func;
5110 diffuse_funcs[WINED3D_FFP_EMIT_FLOAT16_2] = invalid_func;
5111 diffuse_funcs[WINED3D_FFP_EMIT_FLOAT16_4] = invalid_func;
5113 /* No 4 component entry points here */
5114 specular_funcs[WINED3D_FFP_EMIT_FLOAT1] = invalid_func;
5115 specular_funcs[WINED3D_FFP_EMIT_FLOAT2] = invalid_func;
5116 if (gl_info->supported[EXT_SECONDARY_COLOR])
5118 specular_funcs[WINED3D_FFP_EMIT_FLOAT3] = (glAttribFunc)GL_EXTCALL(glSecondaryColor3fvEXT);
5122 specular_funcs[WINED3D_FFP_EMIT_FLOAT3] = warn_no_specular_func;
5124 specular_funcs[WINED3D_FFP_EMIT_FLOAT4] = invalid_func;
5125 if (gl_info->supported[EXT_SECONDARY_COLOR])
5127 specular_func_3ubv = (glAttribFunc)GL_EXTCALL(glSecondaryColor3ubvEXT);
5128 specular_funcs[WINED3D_FFP_EMIT_D3DCOLOR] = specular_d3dcolor;
5132 specular_funcs[WINED3D_FFP_EMIT_D3DCOLOR] = warn_no_specular_func;
5134 specular_funcs[WINED3D_FFP_EMIT_UBYTE4] = invalid_func;
5135 specular_funcs[WINED3D_FFP_EMIT_SHORT2] = invalid_func;
5136 specular_funcs[WINED3D_FFP_EMIT_SHORT4] = invalid_func;
5137 specular_funcs[WINED3D_FFP_EMIT_UBYTE4N] = invalid_func;
5138 specular_funcs[WINED3D_FFP_EMIT_SHORT2N] = invalid_func;
5139 specular_funcs[WINED3D_FFP_EMIT_SHORT4N] = invalid_func;
5140 specular_funcs[WINED3D_FFP_EMIT_USHORT2N] = invalid_func;
5141 specular_funcs[WINED3D_FFP_EMIT_USHORT4N] = invalid_func;
5142 specular_funcs[WINED3D_FFP_EMIT_UDEC3] = invalid_func;
5143 specular_funcs[WINED3D_FFP_EMIT_DEC3N] = invalid_func;
5144 specular_funcs[WINED3D_FFP_EMIT_FLOAT16_2] = invalid_func;
5145 specular_funcs[WINED3D_FFP_EMIT_FLOAT16_4] = invalid_func;
5147 /* Only 3 component entry points here. Test how others behave. Float4 normals are used
5148 * by one of our tests, trying to pass it to the pixel shader, which fails on Windows.
5150 normal_funcs[WINED3D_FFP_EMIT_FLOAT1] = invalid_func;
5151 normal_funcs[WINED3D_FFP_EMIT_FLOAT2] = invalid_func;
5152 normal_funcs[WINED3D_FFP_EMIT_FLOAT3] = (glAttribFunc)glNormal3fv;
5153 normal_funcs[WINED3D_FFP_EMIT_FLOAT4] = (glAttribFunc)glNormal3fv; /* Just ignore the 4th value */
5154 normal_funcs[WINED3D_FFP_EMIT_D3DCOLOR] = invalid_func;
5155 normal_funcs[WINED3D_FFP_EMIT_UBYTE4] = invalid_func;
5156 normal_funcs[WINED3D_FFP_EMIT_SHORT2] = invalid_func;
5157 normal_funcs[WINED3D_FFP_EMIT_SHORT4] = invalid_func;
5158 normal_funcs[WINED3D_FFP_EMIT_UBYTE4N] = invalid_func;
5159 normal_funcs[WINED3D_FFP_EMIT_SHORT2N] = invalid_func;
5160 normal_funcs[WINED3D_FFP_EMIT_SHORT4N] = invalid_func;
5161 normal_funcs[WINED3D_FFP_EMIT_USHORT2N] = invalid_func;
5162 normal_funcs[WINED3D_FFP_EMIT_USHORT4N] = invalid_func;
5163 normal_funcs[WINED3D_FFP_EMIT_UDEC3] = invalid_func;
5164 normal_funcs[WINED3D_FFP_EMIT_DEC3N] = invalid_func;
5165 normal_funcs[WINED3D_FFP_EMIT_FLOAT16_2] = invalid_func;
5166 normal_funcs[WINED3D_FFP_EMIT_FLOAT16_4] = invalid_func;
5168 multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT1] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord1fvARB);
5169 multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT2] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord2fvARB);
5170 multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT3] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord3fvARB);
5171 multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT4] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord4fvARB);
5172 multi_texcoord_funcs[WINED3D_FFP_EMIT_D3DCOLOR] = invalid_texcoord_func;
5173 multi_texcoord_funcs[WINED3D_FFP_EMIT_UBYTE4] = invalid_texcoord_func;
5174 multi_texcoord_funcs[WINED3D_FFP_EMIT_SHORT2] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord2svARB);
5175 multi_texcoord_funcs[WINED3D_FFP_EMIT_SHORT4] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord4svARB);
5176 multi_texcoord_funcs[WINED3D_FFP_EMIT_UBYTE4N] = invalid_texcoord_func;
5177 multi_texcoord_funcs[WINED3D_FFP_EMIT_SHORT2N] = invalid_texcoord_func;
5178 multi_texcoord_funcs[WINED3D_FFP_EMIT_SHORT4N] = invalid_texcoord_func;
5179 multi_texcoord_funcs[WINED3D_FFP_EMIT_USHORT2N] = invalid_texcoord_func;
5180 multi_texcoord_funcs[WINED3D_FFP_EMIT_USHORT4N] = invalid_texcoord_func;
5181 multi_texcoord_funcs[WINED3D_FFP_EMIT_UDEC3] = invalid_texcoord_func;
5182 multi_texcoord_funcs[WINED3D_FFP_EMIT_DEC3N] = invalid_texcoord_func;
5183 if (gl_info->supported[NV_HALF_FLOAT])
5185 /* Not supported by ARB_HALF_FLOAT_VERTEX, so check for NV_HALF_FLOAT */
5186 multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT16_2] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord2hvNV);
5187 multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT16_4] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord4hvNV);
5189 multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT16_2] = invalid_texcoord_func;
5190 multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT16_4] = invalid_texcoord_func;
5194 /* Do not call while under the GL lock. */
5195 static BOOL InitAdapters(IWineD3DImpl *This)
5197 static HMODULE mod_gl;
5199 int ps_selected_mode, vs_selected_mode;
5201 /* No need to hold any lock. The calling library makes sure only one thread calls
5202 * wined3d simultaneously
5205 TRACE("Initializing adapters\n");
5208 #ifdef USE_WIN32_OPENGL
5209 #define USE_GL_FUNC(pfn) pfn = (void*)GetProcAddress(mod_gl, #pfn);
5210 mod_gl = LoadLibraryA("opengl32.dll");
5212 ERR("Can't load opengl32.dll!\n");
5216 #define USE_GL_FUNC(pfn) pfn = (void*)pwglGetProcAddress(#pfn);
5217 /* To bypass the opengl32 thunks load wglGetProcAddress from gdi32 (glXGetProcAddress wrapper) instead of opengl32's */
5218 mod_gl = GetModuleHandleA("gdi32.dll");
5222 /* Load WGL core functions from opengl32.dll */
5223 #define USE_WGL_FUNC(pfn) p##pfn = (void*)GetProcAddress(mod_gl, #pfn);
5227 if(!pwglGetProcAddress) {
5228 ERR("Unable to load wglGetProcAddress!\n");
5232 /* Dynamically load all GL core functions */
5236 /* Load glFinish and glFlush from opengl32.dll even if we're not using WIN32 opengl
5237 * otherwise because we have to use winex11.drv's override
5239 #ifdef USE_WIN32_OPENGL
5240 wglFinish = (void*)GetProcAddress(mod_gl, "glFinish");
5241 wglFlush = (void*)GetProcAddress(mod_gl, "glFlush");
5243 wglFinish = (void*)pwglGetProcAddress("wglFinish");
5244 wglFlush = (void*)pwglGetProcAddress("wglFlush");
5247 glEnableWINE = glEnable;
5248 glDisableWINE = glDisable;
5250 /* For now only one default adapter */
5252 struct wined3d_adapter *adapter = &This->adapters[0];
5253 const struct wined3d_gl_info *gl_info = &adapter->gl_info;
5254 struct wined3d_fake_gl_ctx fake_gl_ctx = {0};
5258 WineD3D_PixelFormat *cfgs;
5259 DISPLAY_DEVICEW DisplayDevice;
5262 TRACE("Initializing default adapter\n");
5263 adapter->ordinal = 0;
5264 adapter->monitorPoint.x = -1;
5265 adapter->monitorPoint.y = -1;
5267 if (!AllocateLocallyUniqueId(&adapter->luid))
5269 DWORD err = GetLastError();
5270 ERR("Failed to set adapter LUID (%#x).\n", err);
5273 TRACE("Allocated LUID %08x:%08x for adapter.\n",
5274 adapter->luid.HighPart, adapter->luid.LowPart);
5276 if (!WineD3D_CreateFakeGLContext(&fake_gl_ctx))
5278 ERR("Failed to get a gl context for default adapter\n");
5282 ret = IWineD3DImpl_FillGLCaps(adapter);
5284 ERR("Failed to initialize gl caps for default adapter\n");
5285 WineD3D_ReleaseFakeGLContext(&fake_gl_ctx);
5288 ret = initPixelFormats(&adapter->gl_info, adapter->driver_info.vendor);
5290 ERR("Failed to init gl formats\n");
5291 WineD3D_ReleaseFakeGLContext(&fake_gl_ctx);
5295 hdc = fake_gl_ctx.dc;
5297 /* Use the VideoRamSize registry setting when set */
5298 if(wined3d_settings.emulated_textureram)
5299 adapter->TextureRam = wined3d_settings.emulated_textureram;
5301 adapter->TextureRam = adapter->gl_info.vidmem;
5302 adapter->UsedTextureRam = 0;
5303 TRACE("Emulating %dMB of texture ram\n", adapter->TextureRam/(1024*1024));
5305 /* Initialize the Adapter's DeviceName which is required for ChangeDisplaySettings and friends */
5306 DisplayDevice.cb = sizeof(DisplayDevice);
5307 EnumDisplayDevicesW(NULL, 0 /* Adapter 0 = iDevNum 0 */, &DisplayDevice, 0);
5308 TRACE("DeviceName: %s\n", debugstr_w(DisplayDevice.DeviceName));
5309 strcpyW(adapter->DeviceName, DisplayDevice.DeviceName);
5311 if (gl_info->supported[WGL_ARB_PIXEL_FORMAT])
5318 attribute = WGL_NUMBER_PIXEL_FORMATS_ARB;
5319 GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc, 0, 0, 1, &attribute, &adapter->nCfgs));
5321 adapter->cfgs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, adapter->nCfgs *sizeof(WineD3D_PixelFormat));
5322 cfgs = adapter->cfgs;
5323 attribs[nAttribs++] = WGL_RED_BITS_ARB;
5324 attribs[nAttribs++] = WGL_GREEN_BITS_ARB;
5325 attribs[nAttribs++] = WGL_BLUE_BITS_ARB;
5326 attribs[nAttribs++] = WGL_ALPHA_BITS_ARB;
5327 attribs[nAttribs++] = WGL_COLOR_BITS_ARB;
5328 attribs[nAttribs++] = WGL_DEPTH_BITS_ARB;
5329 attribs[nAttribs++] = WGL_STENCIL_BITS_ARB;
5330 attribs[nAttribs++] = WGL_DRAW_TO_WINDOW_ARB;
5331 attribs[nAttribs++] = WGL_PIXEL_TYPE_ARB;
5332 attribs[nAttribs++] = WGL_DOUBLE_BUFFER_ARB;
5333 attribs[nAttribs++] = WGL_AUX_BUFFERS_ARB;
5335 for (iPixelFormat=1; iPixelFormat <= adapter->nCfgs; ++iPixelFormat)
5337 res = GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc, iPixelFormat, 0, nAttribs, attribs, values));
5342 /* Cache the pixel format */
5343 cfgs->iPixelFormat = iPixelFormat;
5344 cfgs->redSize = values[0];
5345 cfgs->greenSize = values[1];
5346 cfgs->blueSize = values[2];
5347 cfgs->alphaSize = values[3];
5348 cfgs->colorSize = values[4];
5349 cfgs->depthSize = values[5];
5350 cfgs->stencilSize = values[6];
5351 cfgs->windowDrawable = values[7];
5352 cfgs->iPixelType = values[8];
5353 cfgs->doubleBuffer = values[9];
5354 cfgs->auxBuffers = values[10];
5356 cfgs->numSamples = 0;
5357 /* Check multisample support */
5358 if (gl_info->supported[ARB_MULTISAMPLE])
5360 int attrib[2] = {WGL_SAMPLE_BUFFERS_ARB, WGL_SAMPLES_ARB};
5362 if(GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc, iPixelFormat, 0, 2, attrib, value))) {
5363 /* value[0] = WGL_SAMPLE_BUFFERS_ARB which tells whether multisampling is supported.
5364 * value[1] = number of multi sample buffers*/
5366 cfgs->numSamples = value[1];
5370 TRACE("iPixelFormat=%d, iPixelType=%#x, doubleBuffer=%d, RGBA=%d/%d/%d/%d, "
5371 "depth=%d, stencil=%d, samples=%d, windowDrawable=%d\n",
5372 cfgs->iPixelFormat, cfgs->iPixelType, cfgs->doubleBuffer,
5373 cfgs->redSize, cfgs->greenSize, cfgs->blueSize, cfgs->alphaSize,
5374 cfgs->depthSize, cfgs->stencilSize, cfgs->numSamples, cfgs->windowDrawable);
5380 int nCfgs = DescribePixelFormat(hdc, 0, 0, 0);
5381 adapter->cfgs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, nCfgs*sizeof(WineD3D_PixelFormat));
5382 adapter->nCfgs = 0; /* We won't accept all formats e.g. software accelerated ones will be skipped */
5384 cfgs = adapter->cfgs;
5385 for(iPixelFormat=1; iPixelFormat<=nCfgs; iPixelFormat++)
5387 PIXELFORMATDESCRIPTOR ppfd;
5389 res = DescribePixelFormat(hdc, iPixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &ppfd);
5393 /* We only want HW acceleration using an OpenGL ICD driver.
5394 * PFD_GENERIC_FORMAT = slow opengl 1.1 gdi software rendering
5395 * PFD_GENERIC_ACCELERATED = partial hw acceleration using a MCD driver (e.g. 3dfx minigl)
5397 if(ppfd.dwFlags & (PFD_GENERIC_FORMAT | PFD_GENERIC_ACCELERATED))
5399 TRACE("Skipping iPixelFormat=%d because it isn't ICD accelerated\n", iPixelFormat);
5403 cfgs->iPixelFormat = iPixelFormat;
5404 cfgs->redSize = ppfd.cRedBits;
5405 cfgs->greenSize = ppfd.cGreenBits;
5406 cfgs->blueSize = ppfd.cBlueBits;
5407 cfgs->alphaSize = ppfd.cAlphaBits;
5408 cfgs->colorSize = ppfd.cColorBits;
5409 cfgs->depthSize = ppfd.cDepthBits;
5410 cfgs->stencilSize = ppfd.cStencilBits;
5411 cfgs->windowDrawable = (ppfd.dwFlags & PFD_DRAW_TO_WINDOW) ? 1 : 0;
5412 cfgs->iPixelType = (ppfd.iPixelType == PFD_TYPE_RGBA) ? WGL_TYPE_RGBA_ARB : WGL_TYPE_COLORINDEX_ARB;
5413 cfgs->doubleBuffer = (ppfd.dwFlags & PFD_DOUBLEBUFFER) ? 1 : 0;
5414 cfgs->auxBuffers = ppfd.cAuxBuffers;
5415 cfgs->numSamples = 0;
5417 TRACE("iPixelFormat=%d, iPixelType=%#x, doubleBuffer=%d, RGBA=%d/%d/%d/%d, "
5418 "depth=%d, stencil=%d, windowDrawable=%d\n",
5419 cfgs->iPixelFormat, cfgs->iPixelType, cfgs->doubleBuffer,
5420 cfgs->redSize, cfgs->greenSize, cfgs->blueSize, cfgs->alphaSize,
5421 cfgs->depthSize, cfgs->stencilSize, cfgs->windowDrawable);
5426 /* 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 */
5429 ERR("Disabling Direct3D because no hardware accelerated pixel formats have been found!\n");
5431 WineD3D_ReleaseFakeGLContext(&fake_gl_ctx);
5432 HeapFree(GetProcessHeap(), 0, adapter->cfgs);
5437 /* D16, D24X8 and D24S8 are common depth / depth+stencil formats. All drivers support them though this doesn't
5438 * mean that the format is offered in hardware. For instance Geforce8 cards don't have offer D16 in hardware
5439 * but just fake it using D24(X8?) which is fine. D3D also allows that.
5440 * Some display drivers (i915 on Linux) only report mixed depth+stencil formats like D24S8. MSDN clearly mentions
5441 * that only on lockable formats (e.g. D16_locked) the bit order is guaranteed and that on other formats the
5442 * driver is allowed to consume more bits EXCEPT for stencil bits.
5444 * Mark an adapter with this broken stencil behavior.
5446 adapter->brokenStencil = TRUE;
5447 for (i = 0, cfgs = adapter->cfgs; i < adapter->nCfgs; ++i)
5449 /* Nearly all drivers offer depth formats without stencil, only on i915 this if-statement won't be entered. */
5450 if(cfgs[i].depthSize && !cfgs[i].stencilSize) {
5451 adapter->brokenStencil = FALSE;
5456 WineD3D_ReleaseFakeGLContext(&fake_gl_ctx);
5458 select_shader_mode(&adapter->gl_info, &ps_selected_mode, &vs_selected_mode);
5459 fillGLAttribFuncs(&adapter->gl_info);
5460 adapter->opengl = TRUE;
5462 This->adapter_count = 1;
5463 TRACE("%u adapters successfully initialized\n", This->adapter_count);
5468 /* Initialize an adapter for ddraw-only memory counting */
5469 memset(This->adapters, 0, sizeof(This->adapters));
5470 This->adapters[0].ordinal = 0;
5471 This->adapters[0].opengl = FALSE;
5472 This->adapters[0].monitorPoint.x = -1;
5473 This->adapters[0].monitorPoint.y = -1;
5475 This->adapters[0].driver_info.name = "Display";
5476 This->adapters[0].driver_info.description = "WineD3D DirectDraw Emulation";
5477 if(wined3d_settings.emulated_textureram) {
5478 This->adapters[0].TextureRam = wined3d_settings.emulated_textureram;
5480 This->adapters[0].TextureRam = 8 * 1024 * 1024; /* This is plenty for a DDraw-only card */
5483 initPixelFormatsNoGL(&This->adapters[0].gl_info);
5485 This->adapter_count = 1;
5489 /**********************************************************
5490 * IWineD3D VTbl follows
5491 **********************************************************/
5493 static const struct IWineD3DVtbl IWineD3D_Vtbl =
5496 IWineD3DImpl_QueryInterface,
5497 IWineD3DImpl_AddRef,
5498 IWineD3DImpl_Release,
5500 IWineD3DImpl_GetParent,
5501 IWineD3DImpl_GetAdapterCount,
5502 IWineD3DImpl_RegisterSoftwareDevice,
5503 IWineD3DImpl_GetAdapterMonitor,
5504 IWineD3DImpl_GetAdapterModeCount,
5505 IWineD3DImpl_EnumAdapterModes,
5506 IWineD3DImpl_GetAdapterDisplayMode,
5507 IWineD3DImpl_GetAdapterIdentifier,
5508 IWineD3DImpl_CheckDeviceMultiSampleType,
5509 IWineD3DImpl_CheckDepthStencilMatch,
5510 IWineD3DImpl_CheckDeviceType,
5511 IWineD3DImpl_CheckDeviceFormat,
5512 IWineD3DImpl_CheckDeviceFormatConversion,
5513 IWineD3DImpl_GetDeviceCaps,
5514 IWineD3DImpl_CreateDevice
5517 static void STDMETHODCALLTYPE wined3d_null_wined3d_object_destroyed(void *parent) {}
5519 const struct wined3d_parent_ops wined3d_null_parent_ops =
5521 wined3d_null_wined3d_object_destroyed,
5524 /* Do not call while under the GL lock. */
5525 HRESULT wined3d_init(IWineD3DImpl *wined3d, UINT version, void *parent)
5527 wined3d->lpVtbl = &IWineD3D_Vtbl;
5528 wined3d->dxVersion = version;
5530 wined3d->parent = parent;
5532 if (!InitAdapters(wined3d))
5534 WARN("Failed to initialize adapters.\n");
5537 MESSAGE("Direct3D%u is not available without OpenGL.\n", version);