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_cube_map", ARB_TEXTURE_CUBE_MAP, 0 },
81 {"GL_ARB_texture_env_add", ARB_TEXTURE_ENV_ADD, 0 },
82 {"GL_ARB_texture_env_combine", ARB_TEXTURE_ENV_COMBINE, 0 },
83 {"GL_ARB_texture_env_dot3", ARB_TEXTURE_ENV_DOT3, 0 },
84 {"GL_ARB_texture_float", ARB_TEXTURE_FLOAT, 0 },
85 {"GL_ARB_texture_mirrored_repeat", ARB_TEXTURE_MIRRORED_REPEAT, 0 },
86 {"GL_ARB_texture_non_power_of_two", ARB_TEXTURE_NON_POWER_OF_TWO, MAKEDWORD_VERSION(2, 0) },
87 {"GL_ARB_texture_rectangle", ARB_TEXTURE_RECTANGLE, 0 },
88 {"GL_ARB_texture_rg", ARB_TEXTURE_RG, 0 },
89 {"GL_ARB_vertex_array_bgra", ARB_VERTEX_ARRAY_BGRA, 0 },
90 {"GL_ARB_vertex_blend", ARB_VERTEX_BLEND, 0 },
91 {"GL_ARB_vertex_buffer_object", ARB_VERTEX_BUFFER_OBJECT, 0 },
92 {"GL_ARB_vertex_program", ARB_VERTEX_PROGRAM, 0 },
93 {"GL_ARB_vertex_shader", ARB_VERTEX_SHADER, 0 },
96 {"GL_ATI_fragment_shader", ATI_FRAGMENT_SHADER, 0 },
97 {"GL_ATI_separate_stencil", ATI_SEPARATE_STENCIL, 0 },
98 {"GL_ATI_texture_compression_3dc", ATI_TEXTURE_COMPRESSION_3DC, 0 },
99 {"GL_ATI_texture_env_combine3", ATI_TEXTURE_ENV_COMBINE3, 0 },
100 {"GL_ATI_texture_mirror_once", ATI_TEXTURE_MIRROR_ONCE, 0 },
103 {"GL_EXT_blend_color", EXT_BLEND_COLOR, 0 },
104 {"GL_EXT_blend_equation_separate", EXT_BLEND_EQUATION_SEPARATE, 0 },
105 {"GL_EXT_blend_func_separate", EXT_BLEND_FUNC_SEPARATE, 0 },
106 {"GL_EXT_blend_minmax", EXT_BLEND_MINMAX, 0 },
107 {"GL_EXT_draw_buffers2", EXT_DRAW_BUFFERS2, 0 },
108 {"GL_EXT_fog_coord", EXT_FOG_COORD, 0 },
109 {"GL_EXT_framebuffer_blit", EXT_FRAMEBUFFER_BLIT, 0 },
110 {"GL_EXT_framebuffer_multisample", EXT_FRAMEBUFFER_MULTISAMPLE, 0 },
111 {"GL_EXT_framebuffer_object", EXT_FRAMEBUFFER_OBJECT, 0 },
112 {"GL_EXT_gpu_program_parameters", EXT_GPU_PROGRAM_PARAMETERS, 0 },
113 {"GL_EXT_gpu_shader4", EXT_GPU_SHADER4, 0 },
114 {"GL_EXT_packed_depth_stencil", EXT_PACKED_DEPTH_STENCIL, 0 },
115 {"GL_EXT_paletted_texture", EXT_PALETTED_TEXTURE, 0 },
116 {"GL_EXT_point_parameters", EXT_POINT_PARAMETERS, 0 },
117 {"GL_EXT_provoking_vertex", EXT_PROVOKING_VERTEX, 0 },
118 {"GL_EXT_secondary_color", EXT_SECONDARY_COLOR, 0 },
119 {"GL_EXT_stencil_two_side", EXT_STENCIL_TWO_SIDE, 0 },
120 {"GL_EXT_stencil_wrap", EXT_STENCIL_WRAP, 0 },
121 {"GL_EXT_texture3D", EXT_TEXTURE3D, MAKEDWORD_VERSION(1, 2) },
122 {"GL_EXT_texture_compression_rgtc", EXT_TEXTURE_COMPRESSION_RGTC, 0 },
123 {"GL_EXT_texture_compression_s3tc", EXT_TEXTURE_COMPRESSION_S3TC, 0 },
124 {"GL_EXT_texture_env_add", EXT_TEXTURE_ENV_ADD, 0 },
125 {"GL_EXT_texture_env_combine", EXT_TEXTURE_ENV_COMBINE, 0 },
126 {"GL_EXT_texture_env_dot3", EXT_TEXTURE_ENV_DOT3, 0 },
127 {"GL_EXT_texture_filter_anisotropic", EXT_TEXTURE_FILTER_ANISOTROPIC, 0 },
128 {"GL_EXT_texture_lod_bias", EXT_TEXTURE_LOD_BIAS, 0 },
129 {"GL_EXT_texture_sRGB", EXT_TEXTURE_SRGB, 0 },
130 {"GL_EXT_vertex_array_bgra", EXT_VERTEX_ARRAY_BGRA, 0 },
133 {"GL_NV_depth_clamp", NV_DEPTH_CLAMP, 0 },
134 {"GL_NV_fence", NV_FENCE, 0 },
135 {"GL_NV_fog_distance", NV_FOG_DISTANCE, 0 },
136 {"GL_NV_fragment_program", NV_FRAGMENT_PROGRAM, 0 },
137 {"GL_NV_fragment_program2", NV_FRAGMENT_PROGRAM2, 0 },
138 {"GL_NV_fragment_program_option", NV_FRAGMENT_PROGRAM_OPTION, 0 },
139 {"GL_NV_half_float", NV_HALF_FLOAT, 0 },
140 {"GL_NV_light_max_exponent", NV_LIGHT_MAX_EXPONENT, 0 },
141 {"GL_NV_register_combiners", NV_REGISTER_COMBINERS, 0 },
142 {"GL_NV_register_combiners2", NV_REGISTER_COMBINERS2, 0 },
143 {"GL_NV_texgen_reflection", NV_TEXGEN_REFLECTION, 0 },
144 {"GL_NV_texture_env_combine4", NV_TEXTURE_ENV_COMBINE4, 0 },
145 {"GL_NV_texture_shader", NV_TEXTURE_SHADER, 0 },
146 {"GL_NV_texture_shader2", NV_TEXTURE_SHADER2, 0 },
147 {"GL_NV_vertex_program", NV_VERTEX_PROGRAM, 0 },
148 {"GL_NV_vertex_program1_1", NV_VERTEX_PROGRAM1_1, 0 },
149 {"GL_NV_vertex_program2", NV_VERTEX_PROGRAM2, 0 },
150 {"GL_NV_vertex_program2_option", NV_VERTEX_PROGRAM2_OPTION, 0 },
151 {"GL_NV_vertex_program3", NV_VERTEX_PROGRAM3, 0 },
154 {"GL_SGIS_generate_mipmap", SGIS_GENERATE_MIPMAP, 0 },
157 /**********************************************************
158 * Utility functions follow
159 **********************************************************/
161 static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType, WINED3DFORMAT AdapterFormat, DWORD Usage, WINED3DRESOURCETYPE RType, WINED3DFORMAT CheckFormat, WINED3DSURFTYPE SurfaceType);
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 static BOOL WineD3D_CreateFakeGLContext(struct wined3d_fake_gl_ctx *ctx)
248 PIXELFORMATDESCRIPTOR pfd;
251 TRACE("getting context...\n");
253 ctx->restore_dc = pwglGetCurrentDC();
254 ctx->restore_gl_ctx = pwglGetCurrentContext();
256 /* We need a fake window as a hdc retrieved using GetDC(0) can't be used for much GL purposes. */
257 ctx->wnd = CreateWindowA(WINED3D_OPENGL_WINDOW_CLASS_NAME, "WineD3D fake window",
258 WS_OVERLAPPEDWINDOW, 10, 10, 10, 10, NULL, NULL, NULL, NULL);
261 ERR_(d3d_caps)("Failed to create a window.\n");
265 ctx->dc = GetDC(ctx->wnd);
268 ERR_(d3d_caps)("Failed to get a DC.\n");
272 /* PixelFormat selection */
273 ZeroMemory(&pfd, sizeof(pfd));
274 pfd.nSize = sizeof(pfd);
276 pfd.dwFlags = PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER | PFD_DRAW_TO_WINDOW; /* PFD_GENERIC_ACCELERATED */
277 pfd.iPixelType = PFD_TYPE_RGBA;
279 pfd.iLayerType = PFD_MAIN_PLANE;
281 iPixelFormat = ChoosePixelFormat(ctx->dc, &pfd);
284 /* If this happens something is very wrong as ChoosePixelFormat barely fails. */
285 ERR_(d3d_caps)("Can't find a suitable iPixelFormat.\n");
288 DescribePixelFormat(ctx->dc, iPixelFormat, sizeof(pfd), &pfd);
289 SetPixelFormat(ctx->dc, iPixelFormat, &pfd);
291 /* Create a GL context. */
292 ctx->gl_ctx = pwglCreateContext(ctx->dc);
295 WARN_(d3d_caps)("Error creating default context for capabilities initialization.\n");
299 /* Make it the current GL context. */
300 if (!context_set_current(NULL))
302 ERR_(d3d_caps)("Failed to clear current D3D context.\n");
305 if (!pwglMakeCurrent(ctx->dc, ctx->gl_ctx))
307 ERR_(d3d_caps)("Failed to make fake GL context current.\n");
314 if (ctx->gl_ctx) pwglDeleteContext(ctx->gl_ctx);
316 if (ctx->dc) ReleaseDC(ctx->wnd, ctx->dc);
318 if (ctx->wnd) DestroyWindow(ctx->wnd);
320 if (ctx->restore_gl_ctx && !pwglMakeCurrent(ctx->restore_dc, ctx->restore_gl_ctx))
322 ERR_(d3d_caps)("Failed to restore previous GL context.\n");
328 /* Adjust the amount of used texture memory */
329 unsigned int WineD3DAdapterChangeGLRam(IWineD3DDeviceImpl *device, unsigned int glram)
331 struct wined3d_adapter *adapter = device->adapter;
333 adapter->UsedTextureRam += glram;
334 TRACE("Adjusted gl ram by %d to %d\n", glram, adapter->UsedTextureRam);
335 return adapter->UsedTextureRam;
338 static void wined3d_adapter_cleanup(struct wined3d_adapter *adapter)
340 HeapFree(GetProcessHeap(), 0, adapter->gl_info.gl_formats);
341 HeapFree(GetProcessHeap(), 0, adapter->cfgs);
344 /**********************************************************
345 * IUnknown parts follows
346 **********************************************************/
348 static HRESULT WINAPI IWineD3DImpl_QueryInterface(IWineD3D *iface,REFIID riid,LPVOID *ppobj)
350 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
352 TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppobj);
353 if (IsEqualGUID(riid, &IID_IUnknown)
354 || IsEqualGUID(riid, &IID_IWineD3DBase)
355 || IsEqualGUID(riid, &IID_IWineD3DDevice)) {
356 IUnknown_AddRef(iface);
361 return E_NOINTERFACE;
364 static ULONG WINAPI IWineD3DImpl_AddRef(IWineD3D *iface) {
365 IWineD3DImpl *This = (IWineD3DImpl *)iface;
366 ULONG refCount = InterlockedIncrement(&This->ref);
368 TRACE("(%p) : AddRef increasing from %d\n", This, refCount - 1);
372 static ULONG WINAPI IWineD3DImpl_Release(IWineD3D *iface) {
373 IWineD3DImpl *This = (IWineD3DImpl *)iface;
375 TRACE("(%p) : Releasing from %d\n", This, This->ref);
376 ref = InterlockedDecrement(&This->ref);
380 for (i = 0; i < This->adapter_count; ++i)
382 wined3d_adapter_cleanup(&This->adapters[i]);
384 HeapFree(GetProcessHeap(), 0, This);
390 /**********************************************************
391 * IWineD3D parts follows
392 **********************************************************/
394 /* GL locking is done by the caller */
395 static inline BOOL test_arb_vs_offset_limit(const struct wined3d_gl_info *gl_info)
399 const char *testcode =
401 "PARAM C[66] = { program.env[0..65] };\n"
403 "PARAM zero = {0.0, 0.0, 0.0, 0.0};\n"
404 "ARL A0.x, zero.x;\n"
405 "MOV result.position, C[A0.x + 65];\n"
409 GL_EXTCALL(glGenProgramsARB(1, &prog));
411 ERR("Failed to create an ARB offset limit test program\n");
413 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, prog));
414 GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
415 strlen(testcode), testcode));
416 if(glGetError() != 0) {
417 TRACE("OpenGL implementation does not allow indirect addressing offsets > 63\n");
418 TRACE("error: %s\n", debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
420 } else TRACE("OpenGL implementation allows offsets > 63\n");
422 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, 0));
423 GL_EXTCALL(glDeleteProgramsARB(1, &prog));
424 checkGLcall("ARB vp offset limit test cleanup");
429 static DWORD ver_for_ext(GL_SupportedExt ext)
432 for (i = 0; i < (sizeof(EXTENSION_MAP) / sizeof(*EXTENSION_MAP)); ++i) {
433 if(EXTENSION_MAP[i].extension == ext) {
434 return EXTENSION_MAP[i].version;
440 static BOOL match_ati_r300_to_500(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
441 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
443 if (card_vendor != HW_VENDOR_ATI) return FALSE;
444 if (device == CARD_ATI_RADEON_9500) return TRUE;
445 if (device == CARD_ATI_RADEON_X700) return TRUE;
446 if (device == CARD_ATI_RADEON_X1600) return TRUE;
450 static BOOL match_geforce5(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
451 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
453 if (card_vendor == HW_VENDOR_NVIDIA)
455 if (device == CARD_NVIDIA_GEFORCEFX_5200 ||
456 device == CARD_NVIDIA_GEFORCEFX_5600 ||
457 device == CARD_NVIDIA_GEFORCEFX_5800)
465 static BOOL match_apple(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
466 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
468 /* MacOS has various specialities in the extensions it advertises. Some have to be loaded from
469 * the opengl 1.2+ core, while other extensions are advertised, but software emulated. So try to
470 * detect the Apple OpenGL implementation to apply some extension fixups afterwards.
472 * Detecting this isn't really easy. The vendor string doesn't mention Apple. Compile-time checks
473 * aren't sufficient either because a Linux binary may display on a macos X server via remote X11.
474 * So try to detect the GL implementation by looking at certain Apple extensions. Some extensions
475 * like client storage might be supported on other implementations too, but GL_APPLE_flush_render
476 * is specific to the Mac OS X window management, and GL_APPLE_ycbcr_422 is QuickTime specific. So
477 * the chance that other implementations support them is rather small since Win32 QuickTime uses
478 * DirectDraw, not OpenGL.
480 * This test has been moved into wined3d_guess_gl_vendor()
482 if (gl_vendor == GL_VENDOR_APPLE)
489 /* Context activation is done by the caller. */
490 static void test_pbo_functionality(struct wined3d_gl_info *gl_info)
492 /* Some OpenGL implementations, namely Apple's Geforce 8 driver, advertises PBOs,
493 * but glTexSubImage from a PBO fails miserably, with the first line repeated over
494 * all the texture. This function detects this bug by its symptom and disables PBOs
497 * The test uploads a 4x4 texture via the PBO in the "native" format GL_BGRA,
498 * GL_UNSIGNED_INT_8_8_8_8_REV. This format triggers the bug, and it is what we use
499 * for D3DFMT_A8R8G8B8. Then the texture is read back without any PBO and the data
500 * read back is compared to the original. If they are equal PBOs are assumed to work,
501 * otherwise the PBO extension is disabled. */
503 static const unsigned int pattern[] =
505 0x00000000, 0x000000ff, 0x0000ff00, 0x40ff0000,
506 0x80ffffff, 0x40ffff00, 0x00ff00ff, 0x0000ffff,
507 0x00ffff00, 0x00ff00ff, 0x0000ffff, 0x000000ff,
508 0x80ff00ff, 0x0000ffff, 0x00ff00ff, 0x40ff00ff
510 unsigned int check[sizeof(pattern) / sizeof(pattern[0])];
512 /* No PBO -> No point in testing them. */
513 if (!gl_info->supported[ARB_PIXEL_BUFFER_OBJECT]) return;
517 while (glGetError());
518 glGenTextures(1, &texture);
519 glBindTexture(GL_TEXTURE_2D, texture);
521 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
522 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 4, 4, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, 0);
523 checkGLcall("Specifying the PBO test texture");
525 GL_EXTCALL(glGenBuffersARB(1, &pbo));
526 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pbo));
527 GL_EXTCALL(glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, sizeof(pattern), pattern, GL_STREAM_DRAW_ARB));
528 checkGLcall("Specifying the PBO test pbo");
530 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL);
531 checkGLcall("Loading the PBO test texture");
533 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
536 wglFinish(); /* just to be sure */
538 memset(check, 0, sizeof(check));
540 glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, check);
541 checkGLcall("Reading back the PBO test texture");
543 glDeleteTextures(1, &texture);
544 GL_EXTCALL(glDeleteBuffersARB(1, &pbo));
545 checkGLcall("PBO test cleanup");
549 if (memcmp(check, pattern, sizeof(check)))
551 WARN_(d3d_caps)("PBO test failed, read back data doesn't match original.\n");
552 WARN_(d3d_caps)("Disabling PBOs. This may result in slower performance.\n");
553 gl_info->supported[ARB_PIXEL_BUFFER_OBJECT] = FALSE;
557 TRACE_(d3d_caps)("PBO test successful.\n");
561 static BOOL match_apple_intel(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
562 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
564 return (card_vendor == HW_VENDOR_INTEL) && (gl_vendor == GL_VENDOR_APPLE);
567 static BOOL match_apple_nonr500ati(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
568 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
570 if (gl_vendor != GL_VENDOR_APPLE) return FALSE;
571 if (card_vendor != HW_VENDOR_ATI) return FALSE;
572 if (device == CARD_ATI_RADEON_X1600) return FALSE;
576 static BOOL match_fglrx(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
577 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
579 return gl_vendor == GL_VENDOR_FGLRX;
583 static BOOL match_dx10_capable(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
584 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
586 /* DX9 cards support 40 single float varyings in hardware, most drivers report 32. ATI misreports
587 * 44 varyings. So assume that if we have more than 44 varyings we have a dx10 card.
588 * This detection is for the gl_ClipPos varying quirk. If a d3d9 card really supports more than 44
589 * varyings and we subtract one in dx9 shaders its not going to hurt us because the dx9 limit is
592 * dx10 cards usually have 64 varyings */
593 return gl_info->limits.glsl_varyings > 44;
596 /* A GL context is provided by the caller */
597 static BOOL match_allows_spec_alpha(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
598 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
603 if (!gl_info->supported[EXT_SECONDARY_COLOR]) return FALSE;
607 GL_EXTCALL(glSecondaryColorPointerEXT)(4, GL_UNSIGNED_BYTE, 4, data);
608 error = glGetError();
611 if(error == GL_NO_ERROR)
613 TRACE("GL Implementation accepts 4 component specular color pointers\n");
618 TRACE("GL implementation does not accept 4 component specular colors, error %s\n",
619 debug_glerror(error));
624 static BOOL match_apple_nvts(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
625 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
627 if (!match_apple(gl_info, gl_renderer, gl_vendor, card_vendor, device)) return FALSE;
628 return gl_info->supported[NV_TEXTURE_SHADER];
631 /* A GL context is provided by the caller */
632 static BOOL match_broken_nv_clip(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
633 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
638 const char *testcode =
640 "OPTION NV_vertex_program2;\n"
641 "MOV result.clip[0], 0.0;\n"
642 "MOV result.position, 0.0;\n"
645 if (!gl_info->supported[NV_VERTEX_PROGRAM2_OPTION]) return FALSE;
650 GL_EXTCALL(glGenProgramsARB(1, &prog));
653 ERR("Failed to create the NVvp clip test program\n");
657 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, prog));
658 GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
659 strlen(testcode), testcode));
660 glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &pos);
663 WARN("GL_NV_vertex_program2_option result.clip[] test failed\n");
664 TRACE("error: %s\n", debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
668 else TRACE("GL_NV_vertex_program2_option result.clip[] test passed\n");
670 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, 0));
671 GL_EXTCALL(glDeleteProgramsARB(1, &prog));
672 checkGLcall("GL_NV_vertex_program2_option result.clip[] test cleanup");
678 /* Context activation is done by the caller. */
679 static BOOL match_fbo_tex_update(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
680 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
682 char data[4 * 4 * 4];
686 if (wined3d_settings.offscreen_rendering_mode != ORM_FBO) return FALSE;
688 memset(data, 0xcc, sizeof(data));
692 glGenTextures(1, &tex);
693 glBindTexture(GL_TEXTURE_2D, tex);
694 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
695 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
696 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 4, 4, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL);
697 checkGLcall("glTexImage2D");
699 gl_info->fbo_ops.glGenFramebuffers(1, &fbo);
700 gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
701 gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0);
702 checkGLcall("glFramebufferTexture2D");
704 status = gl_info->fbo_ops.glCheckFramebufferStatus(GL_FRAMEBUFFER);
705 if (status != GL_FRAMEBUFFER_COMPLETE) ERR("FBO status %#x\n", status);
706 checkGLcall("glCheckFramebufferStatus");
708 memset(data, 0x11, sizeof(data));
709 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, data);
710 checkGLcall("glTexSubImage2D");
712 glClearColor(0.996, 0.729, 0.745, 0.792);
713 glClear(GL_COLOR_BUFFER_BIT);
714 checkGLcall("glClear");
716 glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, data);
717 checkGLcall("glGetTexImage");
719 gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
720 gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, 0);
721 glBindTexture(GL_TEXTURE_2D, 0);
722 checkGLcall("glBindTexture");
724 gl_info->fbo_ops.glDeleteFramebuffers(1, &fbo);
725 glDeleteTextures(1, &tex);
726 checkGLcall("glDeleteTextures");
730 return *(DWORD *)data == 0x11111111;
733 static void quirk_arb_constants(struct wined3d_gl_info *gl_info)
735 TRACE_(d3d_caps)("Using ARB vs constant limit(=%u) for GLSL.\n", gl_info->limits.arb_vs_native_constants);
736 gl_info->limits.glsl_vs_float_constants = gl_info->limits.arb_vs_native_constants;
737 TRACE_(d3d_caps)("Using ARB ps constant limit(=%u) for GLSL.\n", gl_info->limits.arb_ps_native_constants);
738 gl_info->limits.glsl_ps_float_constants = gl_info->limits.arb_ps_native_constants;
741 static void quirk_apple_glsl_constants(struct wined3d_gl_info *gl_info)
743 quirk_arb_constants(gl_info);
744 /* MacOS needs uniforms for relative addressing offsets. This can accumulate to quite a few uniforms.
745 * Beyond that the general uniform isn't optimal, so reserve a number of uniforms. 12 vec4's should
746 * allow 48 different offsets or other helper immediate values. */
747 TRACE_(d3d_caps)("Reserving 12 GLSL constants for compiler private use.\n");
748 gl_info->reserved_glsl_constants = max(gl_info->reserved_glsl_constants, 12);
751 /* fglrx crashes with a very bad kernel panic if GL_POINT_SPRITE_ARB is set to GL_COORD_REPLACE_ARB
752 * on more than one texture unit. This means that the d3d9 visual point size test will cause a
753 * kernel panic on any machine running fglrx 9.3(latest that supports r300 to r500 cards). This
754 * quirk only enables point sprites on the first texture unit. This keeps point sprites working in
755 * most games, but avoids the crash
757 * A more sophisticated way would be to find all units that need texture coordinates and enable
758 * point sprites for one if only one is found, and software emulate point sprites in drawStridedSlow
759 * if more than one unit needs texture coordinates(This requires software ffp and vertex shaders though)
761 * Note that disabling the extension entirely does not gain predictability because there is no point
762 * sprite capability flag in d3d, so the potential rendering bugs are the same if we disable the extension. */
763 static void quirk_one_point_sprite(struct wined3d_gl_info *gl_info)
765 if (gl_info->supported[ARB_POINT_SPRITE])
767 TRACE("Limiting point sprites to one texture unit.\n");
768 gl_info->limits.point_sprite_units = 1;
772 static void quirk_ati_dx9(struct wined3d_gl_info *gl_info)
774 quirk_arb_constants(gl_info);
776 /* MacOS advertises GL_ARB_texture_non_power_of_two on ATI r500 and earlier cards, although
777 * these cards only support GL_ARB_texture_rectangle(D3DPTEXTURECAPS_NONPOW2CONDITIONAL).
778 * If real NP2 textures are used, the driver falls back to software. We could just remove the
779 * extension and use GL_ARB_texture_rectangle instead, but texture_rectangle is inconventient
780 * due to the non-normalized texture coordinates. Thus set an internal extension flag,
781 * GL_WINE_normalized_texrect, which signals the code that it can use non power of two textures
782 * as per GL_ARB_texture_non_power_of_two, but has to stick to the texture_rectangle limits.
784 * fglrx doesn't advertise GL_ARB_texture_non_power_of_two, but it advertises opengl 2.0 which
785 * has this extension promoted to core. The extension loading code sets this extension supported
786 * due to that, so this code works on fglrx as well. */
787 if(gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO])
789 TRACE("GL_ARB_texture_non_power_of_two advertised on R500 or earlier card, removing.\n");
790 gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] = FALSE;
791 gl_info->supported[WINE_NORMALIZED_TEXRECT] = TRUE;
794 /* fglrx has the same structural issues as the one described in quirk_apple_glsl_constants, although
795 * it is generally more efficient. Reserve just 8 constants. */
796 TRACE_(d3d_caps)("Reserving 8 GLSL constants for compiler private use.\n");
797 gl_info->reserved_glsl_constants = max(gl_info->reserved_glsl_constants, 8);
800 static void quirk_no_np2(struct wined3d_gl_info *gl_info)
802 /* The nVidia GeForceFX series reports OpenGL 2.0 capabilities with the latest drivers versions, but
803 * doesn't explicitly advertise the ARB_tex_npot extension in the GL extension string.
804 * This usually means that ARB_tex_npot is supported in hardware as long as the application is staying
805 * within the limits enforced by the ARB_texture_rectangle extension. This however is not true for the
806 * FX series, which instantly falls back to a slower software path as soon as ARB_tex_npot is used.
807 * We therefore completely remove ARB_tex_npot from the list of supported extensions.
809 * Note that wine_normalized_texrect can't be used in this case because internally it uses ARB_tex_npot,
810 * triggering the software fallback. There is not much we can do here apart from disabling the
811 * software-emulated extension and reenable ARB_tex_rect (which was previously disabled
812 * in IWineD3DImpl_FillGLCaps).
813 * This fixup removes performance problems on both the FX 5900 and FX 5700 (e.g. for framebuffer
814 * post-processing effects in the game "Max Payne 2").
815 * The behaviour can be verified through a simple test app attached in bugreport #14724. */
816 TRACE("GL_ARB_texture_non_power_of_two advertised through OpenGL 2.0 on NV FX card, removing.\n");
817 gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] = FALSE;
818 gl_info->supported[ARB_TEXTURE_RECTANGLE] = TRUE;
821 static void quirk_texcoord_w(struct wined3d_gl_info *gl_info)
823 /* The Intel GPUs on MacOS set the .w register of texcoords to 0.0 by default, which causes problems
824 * with fixed function fragment processing. Ideally this flag should be detected with a test shader
825 * and OpenGL feedback mode, but some GL implementations (MacOS ATI at least, probably all MacOS ones)
826 * do not like vertex shaders in feedback mode and return an error, even though it should be valid
827 * according to the spec.
829 * We don't want to enable this on all cards, as it adds an extra instruction per texcoord used. This
830 * makes the shader slower and eats instruction slots which should be available to the d3d app.
832 * ATI Radeon HD 2xxx cards on MacOS have the issue. Instead of checking for the buggy cards, blacklist
833 * all radeon cards on Macs and whitelist the good ones. That way we're prepared for the future. If
834 * this workaround is activated on cards that do not need it, it won't break things, just affect
835 * performance negatively. */
836 TRACE("Enabling vertex texture coord fixes in vertex shaders.\n");
837 gl_info->quirks |= WINED3D_QUIRK_SET_TEXCOORD_W;
840 static void quirk_clip_varying(struct wined3d_gl_info *gl_info)
842 gl_info->quirks |= WINED3D_QUIRK_GLSL_CLIP_VARYING;
845 static void quirk_allows_specular_alpha(struct wined3d_gl_info *gl_info)
847 gl_info->quirks |= WINED3D_QUIRK_ALLOWS_SPECULAR_ALPHA;
850 static void quirk_apple_nvts(struct wined3d_gl_info *gl_info)
852 gl_info->supported[NV_TEXTURE_SHADER] = FALSE;
853 gl_info->supported[NV_TEXTURE_SHADER2] = FALSE;
856 static void quirk_disable_nvvp_clip(struct wined3d_gl_info *gl_info)
858 gl_info->quirks |= WINED3D_QUIRK_NV_CLIP_BROKEN;
861 static void quirk_fbo_tex_update(struct wined3d_gl_info *gl_info)
863 gl_info->quirks |= WINED3D_QUIRK_FBO_TEX_UPDATE;
868 BOOL (*match)(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
869 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device);
870 void (*apply)(struct wined3d_gl_info *gl_info);
871 const char *description;
874 static const struct driver_quirk quirk_table[] =
877 match_ati_r300_to_500,
879 "ATI GLSL constant and normalized texrect quirk"
881 /* MacOS advertises more GLSL vertex shader uniforms than supported by the hardware, and if more are
882 * used it falls back to software. While the compiler can detect if the shader uses all declared
883 * uniforms, the optimization fails if the shader uses relative addressing. So any GLSL shader
884 * using relative addressing falls back to software.
886 * ARB vp gives the correct amount of uniforms, so use it instead of GLSL. */
889 quirk_apple_glsl_constants,
890 "Apple GLSL uniform override"
895 "Geforce 5 NP2 disable"
900 "Init texcoord .w for Apple Intel GPU driver"
903 match_apple_nonr500ati,
905 "Init texcoord .w for Apple ATI >= r600 GPU driver"
909 quirk_one_point_sprite,
910 "Fglrx point sprite crash workaround"
915 "Reserved varying for gl_ClipPos"
918 /* GL_EXT_secondary_color does not allow 4 component secondary colors, but most
919 * GL implementations accept it. The Mac GL is the only implementation known to
922 * If we can pass 4 component specular colors, do it, because (a) we don't have
923 * to screw around with the data, and (b) the D3D fixed function vertex pipeline
924 * passes specular alpha to the pixel shader if any is used. Otherwise the
925 * specular alpha is used to pass the fog coordinate, which we pass to opengl
926 * via GL_EXT_fog_coord.
928 match_allows_spec_alpha,
929 quirk_allows_specular_alpha,
930 "Allow specular alpha quirk"
933 /* The pixel formats provided by GL_NV_texture_shader are broken on OSX
938 "Apple NV_texture_shader disable"
941 match_broken_nv_clip,
942 quirk_disable_nvvp_clip,
943 "Apple NV_vertex_program clip bug quirk"
946 match_fbo_tex_update,
947 quirk_fbo_tex_update,
948 "FBO rebind for attachment updates"
952 /* Certain applications (Steam) complain if we report an outdated driver version. In general,
953 * reporting a driver version is moot because we are not the Windows driver, and we have different
954 * bugs, features, etc.
956 * The driver version has the form "x.y.z.w".
958 * "x" is the Windows version the driver is meant for:
965 * "y" is the Direct3D level the driver supports:
972 * "z" is unknown, possibly vendor specific.
974 * "w" is the vendor specific driver version.
976 struct driver_version_information
978 WORD vendor; /* reported PCI card vendor ID */
979 WORD card; /* reported PCI card device ID */
980 const char *description; /* Description of the card e.g. NVIDIA RIVA TNT */
981 WORD d3d_level; /* driver hiword to report */
982 WORD lopart_hi, lopart_lo; /* driver loword to report */
985 static const struct driver_version_information driver_version_table[] =
987 /* Nvidia drivers. Geforce6 and newer cards are supported by the current driver (180.x)
988 * GeforceFX support is up to 173.x, - driver uses numbering x.y.11.7341 for 173.41 where x is the windows revision (6=2000/xp, 7=vista), y is unknown
989 * Geforce2MX/3/4 up to 96.x - driver uses numbering 9.6.8.9 for 96.89
990 * TNT/Geforce1/2 up to 71.x - driver uses numbering 7.1.8.6 for 71.86
992 * All version numbers used below are from the Linux nvidia drivers. */
993 {HW_VENDOR_NVIDIA, CARD_NVIDIA_RIVA_TNT, "NVIDIA RIVA TNT", 1, 8, 6 },
994 {HW_VENDOR_NVIDIA, CARD_NVIDIA_RIVA_TNT2, "NVIDIA RIVA TNT2/TNT2 Pro", 1, 8, 6 },
995 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE, "NVIDIA GeForce 256", 1, 8, 6 },
996 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE2_MX, "NVIDIA GeForce2 MX/MX 400", 6, 4, 3 },
997 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE2, "NVIDIA GeForce2 GTS/GeForce2 Pro", 1, 8, 6 },
998 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE3, "NVIDIA GeForce3", 6, 10, 9371 },
999 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE4_MX, "NVIDIA GeForce4 MX 460", 6, 10, 9371 },
1000 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE4_TI4200, "NVIDIA GeForce4 Ti 4200", 6, 10, 9371 },
1001 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCEFX_5200, "NVIDIA GeForce FX 5200", 15, 11, 7516 },
1002 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCEFX_5600, "NVIDIA GeForce FX 5600", 15, 11, 7516 },
1003 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCEFX_5800, "NVIDIA GeForce FX 5800", 15, 11, 7516 },
1004 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_6200, "NVIDIA GeForce 6200", 15, 11, 9745 },
1005 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_6600GT, "NVIDIA GeForce 6600 GT", 15, 11, 9745 },
1006 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_6800, "NVIDIA GeForce 6800", 15, 11, 9745 },
1007 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7300, "NVIDIA GeForce Go 7300", 15, 11, 9745 },
1008 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7400, "NVIDIA GeForce Go 7400", 15, 11, 9745 },
1009 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7600, "NVIDIA GeForce 7600 GT", 15, 11, 9745 },
1010 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7800GT, "NVIDIA GeForce 7800 GT", 15, 11, 9745 },
1011 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8300GS, "NVIDIA GeForce 8300 GS", 15, 11, 9745 },
1012 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8400GS, "NVIDIA GeForce 8400 GS", 15, 11, 9745 },
1013 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8600GT, "NVIDIA GeForce 8600 GT", 15, 11, 9745 },
1014 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8600MGT, "NVIDIA GeForce 8600M GT", 15, 11, 9745 },
1015 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8800GTS, "NVIDIA GeForce 8800 GTS", 15, 11, 9745 },
1016 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9200, "NVIDIA GeForce 9200", 15, 11, 9745 },
1017 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9400GT, "NVIDIA GeForce 9400 GT", 15, 11, 9745 },
1018 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9500GT, "NVIDIA GeForce 9500 GT", 15, 11, 9745 },
1019 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9600GT, "NVIDIA GeForce 9600 GT", 15, 11, 9745 },
1020 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9800GT, "NVIDIA GeForce 9800 GT", 15, 11, 9745 },
1021 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_210, "NVIDIA GeForce 210", 15, 11, 9745 },
1022 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT220, "NVIDIA GeForce GT 220", 15, 11, 9745 },
1023 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT240, "NVIDIA GeForce GT 240", 15, 11, 9745 },
1024 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX260, "NVIDIA GeForce GTX 260", 15, 11, 9745 },
1025 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX275, "NVIDIA GeForce GTX 275", 15, 11, 9745 },
1026 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX280, "NVIDIA GeForce GTX 280", 15, 11, 9745 },
1027 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT325M, "NVIDIA GeForce GT 325M", 15, 11, 9745 },
1028 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTS350M, "NVIDIA GeForce GTS 350M", 15, 11, 9745 },
1029 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX470, "NVIDIA GeForce GTX 470", 15, 11, 9775 },
1030 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX480, "NVIDIA GeForce GTX 480", 15, 11, 9775 },
1031 /* ATI cards. The driver versions are somewhat similar, but not quite the same. Let's hardcode. */
1032 {HW_VENDOR_ATI, CARD_ATI_RADEON_9500, "ATI Radeon 9500", 14, 10, 6764 },
1033 {HW_VENDOR_ATI, CARD_ATI_RADEON_X700, "ATI Radeon X700 SE", 14, 10, 6764 },
1034 {HW_VENDOR_ATI, CARD_ATI_RADEON_X1600, "ATI Radeon X1600 Series", 14, 10, 6764 },
1035 {HW_VENDOR_ATI, CARD_ATI_RADEON_HD2350, "ATI Mobility Radeon HD 2350", 14, 10, 6764 },
1036 {HW_VENDOR_ATI, CARD_ATI_RADEON_HD2600, "ATI Mobility Radeon HD 2600", 14, 10, 6764 },
1037 {HW_VENDOR_ATI, CARD_ATI_RADEON_HD2900, "ATI Radeon HD 2900 XT", 14, 10, 6764 },
1038 {HW_VENDOR_ATI, CARD_ATI_RADEON_HD4350, "ATI Radeon HD 4350", 14, 10, 6764 },
1039 {HW_VENDOR_ATI, CARD_ATI_RADEON_HD4600, "ATI Radeon HD 4600 Series", 14, 10, 6764 },
1040 {HW_VENDOR_ATI, CARD_ATI_RADEON_HD4700, "ATI Radeon HD 4700 Series", 14, 10, 6764 },
1041 {HW_VENDOR_ATI, CARD_ATI_RADEON_HD4800, "ATI Radeon HD 4800 Series", 14, 10, 6764 },
1042 {HW_VENDOR_ATI, CARD_ATI_RADEON_HD5700, "ATI Radeon HD 5700 Series", 14, 10, 8681 },
1043 {HW_VENDOR_ATI, CARD_ATI_RADEON_HD5800, "ATI Radeon HD 5800 Series", 14, 10, 8681 },
1045 /* TODO: Add information about legacy ATI hardware, Intel and other cards. */
1048 static void init_driver_info(struct wined3d_driver_info *driver_info,
1049 enum wined3d_pci_vendor vendor, enum wined3d_pci_device device)
1051 OSVERSIONINFOW os_version;
1052 WORD driver_os_version;
1055 if (wined3d_settings.pci_vendor_id != PCI_VENDOR_NONE)
1057 TRACE_(d3d_caps)("Overriding PCI vendor ID with: %04x\n", wined3d_settings.pci_vendor_id);
1058 vendor = wined3d_settings.pci_vendor_id;
1060 driver_info->vendor = vendor;
1062 if (wined3d_settings.pci_device_id != PCI_DEVICE_NONE)
1064 TRACE_(d3d_caps)("Overriding PCI device ID with: %04x\n", wined3d_settings.pci_device_id);
1065 device = wined3d_settings.pci_device_id;
1067 driver_info->device = device;
1072 driver_info->name = "ati2dvag.dll";
1075 case HW_VENDOR_NVIDIA:
1076 driver_info->name = "nv4_disp.dll";
1079 case HW_VENDOR_INTEL:
1081 FIXME_(d3d_caps)("Unhandled vendor %04x.\n", vendor);
1082 driver_info->name = "Display";
1086 memset(&os_version, 0, sizeof(os_version));
1087 os_version.dwOSVersionInfoSize = sizeof(os_version);
1088 if (!GetVersionExW(&os_version))
1090 ERR("Failed to get OS version, reporting 2000/XP.\n");
1091 driver_os_version = 6;
1095 TRACE("OS version %u.%u.\n", os_version.dwMajorVersion, os_version.dwMinorVersion);
1096 switch (os_version.dwMajorVersion)
1099 driver_os_version = 4;
1103 driver_os_version = 6;
1107 if (os_version.dwMinorVersion == 0)
1109 driver_os_version = 7;
1113 if (os_version.dwMinorVersion > 1)
1115 FIXME("Unhandled OS version %u.%u, reporting Win 7.\n",
1116 os_version.dwMajorVersion, os_version.dwMinorVersion);
1118 driver_os_version = 8;
1123 FIXME("Unhandled OS version %u.%u, reporting 2000/XP.\n",
1124 os_version.dwMajorVersion, os_version.dwMinorVersion);
1125 driver_os_version = 6;
1130 driver_info->description = "Direct3D HAL";
1131 driver_info->version_high = MAKEDWORD_VERSION(driver_os_version, 15);
1132 driver_info->version_low = MAKEDWORD_VERSION(8, 6); /* Nvidia RIVA TNT, arbitrary */
1134 for (i = 0; i < (sizeof(driver_version_table) / sizeof(driver_version_table[0])); ++i)
1136 if (vendor == driver_version_table[i].vendor && device == driver_version_table[i].card)
1138 TRACE_(d3d_caps)("Found card %04x:%04x in driver DB.\n", vendor, device);
1140 driver_info->description = driver_version_table[i].description;
1141 driver_info->version_high = MAKEDWORD_VERSION(driver_os_version, driver_version_table[i].d3d_level);
1142 driver_info->version_low = MAKEDWORD_VERSION(driver_version_table[i].lopart_hi,
1143 driver_version_table[i].lopart_lo);
1148 TRACE_(d3d_caps)("Reporting (fake) driver version 0x%08x-0x%08x.\n",
1149 driver_info->version_high, driver_info->version_low);
1152 /* Context activation is done by the caller. */
1153 static void fixup_extensions(struct wined3d_gl_info *gl_info, const char *gl_renderer,
1154 enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
1158 for (i = 0; i < (sizeof(quirk_table) / sizeof(*quirk_table)); ++i)
1160 if (!quirk_table[i].match(gl_info, gl_renderer, gl_vendor, card_vendor, device)) continue;
1161 TRACE_(d3d_caps)("Applying driver quirk \"%s\".\n", quirk_table[i].description);
1162 quirk_table[i].apply(gl_info);
1165 /* Find out if PBOs work as they are supposed to. */
1166 test_pbo_functionality(gl_info);
1169 static DWORD wined3d_parse_gl_version(const char *gl_version)
1171 const char *ptr = gl_version;
1175 if (major <= 0) ERR_(d3d_caps)("Invalid opengl major version: %d.\n", major);
1177 while (isdigit(*ptr)) ++ptr;
1178 if (*ptr++ != '.') ERR_(d3d_caps)("Invalid opengl version string: %s.\n", debugstr_a(gl_version));
1182 TRACE_(d3d_caps)("Found OpenGL version: %d.%d.\n", major, minor);
1184 return MAKEDWORD_VERSION(major, minor);
1187 static enum wined3d_gl_vendor wined3d_guess_gl_vendor(struct wined3d_gl_info *gl_info, const char *gl_vendor_string, const char *gl_renderer)
1190 /* MacOS has various specialities in the extensions it advertises. Some have to be loaded from
1191 * the opengl 1.2+ core, while other extensions are advertised, but software emulated. So try to
1192 * detect the Apple OpenGL implementation to apply some extension fixups afterwards.
1194 * Detecting this isn't really easy. The vendor string doesn't mention Apple. Compile-time checks
1195 * aren't sufficient either because a Linux binary may display on a macos X server via remote X11.
1196 * So try to detect the GL implementation by looking at certain Apple extensions. Some extensions
1197 * like client storage might be supported on other implementations too, but GL_APPLE_flush_render
1198 * is specific to the Mac OS X window management, and GL_APPLE_ycbcr_422 is QuickTime specific. So
1199 * the chance that other implementations support them is rather small since Win32 QuickTime uses
1200 * DirectDraw, not OpenGL. */
1201 if (gl_info->supported[APPLE_FENCE]
1202 && gl_info->supported[APPLE_CLIENT_STORAGE]
1203 && gl_info->supported[APPLE_FLUSH_RENDER]
1204 && gl_info->supported[APPLE_YCBCR_422])
1205 return GL_VENDOR_APPLE;
1207 if (strstr(gl_vendor_string, "NVIDIA"))
1208 return GL_VENDOR_NVIDIA;
1210 if (strstr(gl_vendor_string, "ATI"))
1211 return GL_VENDOR_FGLRX;
1213 if (strstr(gl_vendor_string, "Intel(R)")
1214 /* Intel switched from Intel(R) to Intel® recently, so just match Intel. */
1215 || strstr(gl_renderer, "Intel")
1216 || strstr(gl_vendor_string, "Intel Inc."))
1217 return GL_VENDOR_INTEL;
1219 if (strstr(gl_vendor_string, "Mesa")
1220 || strstr(gl_vendor_string, "Advanced Micro Devices, Inc.")
1221 || strstr(gl_vendor_string, "DRI R300 Project")
1222 || strstr(gl_vendor_string, "X.Org R300 Project")
1223 || strstr(gl_vendor_string, "Tungsten Graphics, Inc")
1224 || strstr(gl_vendor_string, "VMware, Inc.")
1225 || strstr(gl_renderer, "Mesa")
1226 || strstr(gl_renderer, "Gallium"))
1227 return GL_VENDOR_MESA;
1229 FIXME_(d3d_caps)("Received unrecognized GL_VENDOR %s. Returning GL_VENDOR_UNKNOWN.\n",
1230 debugstr_a(gl_vendor_string));
1232 return GL_VENDOR_UNKNOWN;
1235 static enum wined3d_pci_vendor wined3d_guess_card_vendor(const char *gl_vendor_string, const char *gl_renderer)
1237 if (strstr(gl_vendor_string, "NVIDIA"))
1238 return HW_VENDOR_NVIDIA;
1240 if (strstr(gl_vendor_string, "ATI")
1241 || strstr(gl_vendor_string, "Advanced Micro Devices, Inc.")
1242 || strstr(gl_vendor_string, "X.Org R300 Project")
1243 || strstr(gl_vendor_string, "DRI R300 Project"))
1244 return HW_VENDOR_ATI;
1246 if (strstr(gl_vendor_string, "Intel(R)")
1247 /* Intel switched from Intel(R) to Intel® recently, so just match Intel. */
1248 || strstr(gl_renderer, "Intel")
1249 || strstr(gl_vendor_string, "Intel Inc."))
1250 return HW_VENDOR_INTEL;
1252 if (strstr(gl_vendor_string, "Mesa")
1253 || strstr(gl_vendor_string, "Tungsten Graphics, Inc")
1254 || strstr(gl_vendor_string, "VMware, Inc."))
1255 return HW_VENDOR_SOFTWARE;
1257 FIXME_(d3d_caps)("Received unrecognized GL_VENDOR %s. Returning HW_VENDOR_NVIDIA.\n", debugstr_a(gl_vendor_string));
1259 return HW_VENDOR_NVIDIA;
1264 static enum wined3d_pci_device select_card_nvidia_binary(const struct wined3d_gl_info *gl_info,
1265 const char *gl_renderer, unsigned int *vidmem)
1267 if (WINE_D3D10_CAPABLE(gl_info))
1269 /* Geforce 400 - highend */
1270 if (strstr(gl_renderer, "GTX 480"))
1273 return CARD_NVIDIA_GEFORCE_GTX480;
1276 /* Geforce 400 - midend high */
1277 if (strstr(gl_renderer, "GTX 470"))
1280 return CARD_NVIDIA_GEFORCE_GTX470;
1283 /* Geforce 300 highend mobile */
1284 if (strstr(gl_renderer, "GTS 350M")
1285 || strstr(gl_renderer, "GTS 360M"))
1288 return CARD_NVIDIA_GEFORCE_GTS350M;
1291 /* Geforce 300 midend mobile (Geforce GT 325M/330M use the same core) */
1292 if (strstr(gl_renderer, "GT 325M")
1293 || strstr(gl_renderer, "GT 330M"))
1296 return CARD_NVIDIA_GEFORCE_GT325M;
1299 /* Geforce 200 - highend */
1300 if (strstr(gl_renderer, "GTX 280")
1301 || strstr(gl_renderer, "GTX 285")
1302 || strstr(gl_renderer, "GTX 295"))
1305 return CARD_NVIDIA_GEFORCE_GTX280;
1308 /* Geforce 200 - midend high */
1309 if (strstr(gl_renderer, "GTX 275"))
1312 return CARD_NVIDIA_GEFORCE_GTX275;
1315 /* Geforce 200 - midend */
1316 if (strstr(gl_renderer, "GTX 260"))
1319 return CARD_NVIDIA_GEFORCE_GTX260;
1321 /* Geforce 200 - midend */
1322 if (strstr(gl_renderer, "GT 240"))
1325 return CARD_NVIDIA_GEFORCE_GT240;
1328 /* Geforce 200 lowend */
1329 if (strstr(gl_renderer, "GT 220"))
1331 *vidmem = 512; /* The GT 220 has 512-1024MB */
1332 return CARD_NVIDIA_GEFORCE_GT220;
1334 /* Geforce 200 lowend (Geforce 305/310 use the same core) */
1335 if (strstr(gl_renderer, "Geforce 210")
1336 || strstr(gl_renderer, "G 210")
1337 || strstr(gl_renderer, "Geforce 305")
1338 || strstr(gl_renderer, "Geforce 310"))
1341 return CARD_NVIDIA_GEFORCE_210;
1344 /* Geforce9 - highend / Geforce 200 - midend (GTS 150/250 are based on the same core) */
1345 if (strstr(gl_renderer, "9800")
1346 || strstr(gl_renderer, "GTS 150")
1347 || strstr(gl_renderer, "GTS 250"))
1350 return CARD_NVIDIA_GEFORCE_9800GT;
1353 /* Geforce9 - midend (GT 140 uses the same core as the 9600GT) */
1354 if (strstr(gl_renderer, "9600")
1355 || strstr(gl_renderer, "GT 140"))
1357 *vidmem = 384; /* The 9600GSO has 384MB, the 9600GT has 512-1024MB */
1358 return CARD_NVIDIA_GEFORCE_9600GT;
1361 /* Geforce9 - midend low / Geforce 200 - low */
1362 if (strstr(gl_renderer, "9500")
1363 || strstr(gl_renderer, "GT 120")
1364 || strstr(gl_renderer, "GT 130"))
1366 *vidmem = 256; /* The 9500GT has 256-1024MB */
1367 return CARD_NVIDIA_GEFORCE_9500GT;
1370 /* Geforce9 - lowend */
1371 if (strstr(gl_renderer, "9400"))
1373 *vidmem = 256; /* The 9400GT has 256-1024MB */
1374 return CARD_NVIDIA_GEFORCE_9400GT;
1377 /* Geforce9 - lowend low */
1378 if (strstr(gl_renderer, "9100")
1379 || strstr(gl_renderer, "9200")
1380 || strstr(gl_renderer, "9300")
1381 || strstr(gl_renderer, "G 100"))
1383 *vidmem = 256; /* The 9100-9300 cards have 256MB */
1384 return CARD_NVIDIA_GEFORCE_9200;
1387 /* Geforce8 - highend */
1388 if (strstr(gl_renderer, "8800"))
1390 *vidmem = 320; /* The 8800GTS uses 320MB, a 8800GTX can have 768MB */
1391 return CARD_NVIDIA_GEFORCE_8800GTS;
1394 /* Geforce8 - midend mobile */
1395 if (strstr(gl_renderer, "8600 M"))
1398 return CARD_NVIDIA_GEFORCE_8600MGT;
1401 /* Geforce8 - midend */
1402 if (strstr(gl_renderer, "8600")
1403 || strstr(gl_renderer, "8700"))
1406 return CARD_NVIDIA_GEFORCE_8600GT;
1409 /* Geforce8 - mid-lowend */
1410 if (strstr(gl_renderer, "8400")
1411 || strstr(gl_renderer, "8500"))
1413 *vidmem = 128; /* 128-256MB for a 8400, 256-512MB for a 8500 */
1414 return CARD_NVIDIA_GEFORCE_8400GS;
1417 /* Geforce8 - lowend */
1418 if (strstr(gl_renderer, "8100")
1419 || strstr(gl_renderer, "8200")
1420 || strstr(gl_renderer, "8300"))
1422 *vidmem = 128; /* 128-256MB for a 8300 */
1423 return CARD_NVIDIA_GEFORCE_8300GS;
1426 /* Geforce8-compatible fall back if the GPU is not in the list yet */
1428 return CARD_NVIDIA_GEFORCE_8300GS;
1431 /* Both the GeforceFX, 6xxx and 7xxx series support D3D9. The last two types have more
1432 * shader capabilities, so we use the shader capabilities to distinguish between FX and 6xxx/7xxx.
1434 if (WINE_D3D9_CAPABLE(gl_info) && gl_info->supported[NV_VERTEX_PROGRAM3])
1436 /* Geforce7 - highend */
1437 if (strstr(gl_renderer, "7800")
1438 || strstr(gl_renderer, "7900")
1439 || strstr(gl_renderer, "7950")
1440 || strstr(gl_renderer, "Quadro FX 4")
1441 || strstr(gl_renderer, "Quadro FX 5"))
1443 *vidmem = 256; /* A 7800GT uses 256MB while highend 7900 cards can use 512MB */
1444 return CARD_NVIDIA_GEFORCE_7800GT;
1447 /* Geforce7 midend */
1448 if (strstr(gl_renderer, "7600")
1449 || strstr(gl_renderer, "7700"))
1451 *vidmem = 256; /* The 7600 uses 256-512MB */
1452 return CARD_NVIDIA_GEFORCE_7600;
1455 /* Geforce7 lower medium */
1456 if (strstr(gl_renderer, "7400"))
1458 *vidmem = 256; /* The 7400 uses 256-512MB */
1459 return CARD_NVIDIA_GEFORCE_7400;
1462 /* Geforce7 lowend */
1463 if (strstr(gl_renderer, "7300"))
1465 *vidmem = 256; /* Mac Pros with this card have 256 MB */
1466 return CARD_NVIDIA_GEFORCE_7300;
1469 /* Geforce6 highend */
1470 if (strstr(gl_renderer, "6800"))
1472 *vidmem = 128; /* The 6800 uses 128-256MB, the 7600 uses 256-512MB */
1473 return CARD_NVIDIA_GEFORCE_6800;
1476 /* Geforce6 - midend */
1477 if (strstr(gl_renderer, "6600")
1478 || strstr(gl_renderer, "6610")
1479 || strstr(gl_renderer, "6700"))
1481 *vidmem = 128; /* A 6600GT has 128-256MB */
1482 return CARD_NVIDIA_GEFORCE_6600GT;
1485 /* Geforce6/7 lowend */
1487 return CARD_NVIDIA_GEFORCE_6200; /* Geforce 6100/6150/6200/7300/7400/7500 */
1490 if (WINE_D3D9_CAPABLE(gl_info))
1492 /* GeforceFX - highend */
1493 if (strstr(gl_renderer, "5800")
1494 || strstr(gl_renderer, "5900")
1495 || strstr(gl_renderer, "5950")
1496 || strstr(gl_renderer, "Quadro FX"))
1498 *vidmem = 256; /* 5800-5900 cards use 256MB */
1499 return CARD_NVIDIA_GEFORCEFX_5800;
1502 /* GeforceFX - midend */
1503 if (strstr(gl_renderer, "5600")
1504 || strstr(gl_renderer, "5650")
1505 || strstr(gl_renderer, "5700")
1506 || strstr(gl_renderer, "5750"))
1508 *vidmem = 128; /* A 5600 uses 128-256MB */
1509 return CARD_NVIDIA_GEFORCEFX_5600;
1512 /* GeforceFX - lowend */
1513 *vidmem = 64; /* Normal FX5200 cards use 64-256MB; laptop (non-standard) can have less */
1514 return CARD_NVIDIA_GEFORCEFX_5200; /* GeforceFX 5100/5200/5250/5300/5500 */
1517 if (WINE_D3D8_CAPABLE(gl_info))
1519 if (strstr(gl_renderer, "GeForce4 Ti") || strstr(gl_renderer, "Quadro4"))
1521 *vidmem = 64; /* Geforce4 Ti cards have 64-128MB */
1522 return CARD_NVIDIA_GEFORCE4_TI4200; /* Geforce4 Ti4200/Ti4400/Ti4600/Ti4800, Quadro4 */
1525 *vidmem = 64; /* Geforce3 cards have 64-128MB */
1526 return CARD_NVIDIA_GEFORCE3; /* Geforce3 standard/Ti200/Ti500, Quadro DCC */
1529 if (WINE_D3D7_CAPABLE(gl_info))
1531 if (strstr(gl_renderer, "GeForce4 MX"))
1533 /* Most Geforce4MX GPUs have at least 64MB of memory, some
1534 * early models had 32MB but most have 64MB or even 128MB. */
1536 return CARD_NVIDIA_GEFORCE4_MX; /* MX420/MX440/MX460/MX4000 */
1539 if (strstr(gl_renderer, "GeForce2 MX") || strstr(gl_renderer, "Quadro2 MXR"))
1541 *vidmem = 32; /* Geforce2MX GPUs have 32-64MB of video memory */
1542 return CARD_NVIDIA_GEFORCE2_MX; /* Geforce2 standard/MX100/MX200/MX400, Quadro2 MXR */
1545 if (strstr(gl_renderer, "GeForce2") || strstr(gl_renderer, "Quadro2"))
1547 *vidmem = 32; /* Geforce2 GPUs have 32-64MB of video memory */
1548 return CARD_NVIDIA_GEFORCE2; /* Geforce2 GTS/Pro/Ti/Ultra, Quadro2 */
1551 /* Most Geforce1 cards have 32MB, there are also some rare 16
1552 * and 64MB (Dell) models. */
1554 return CARD_NVIDIA_GEFORCE; /* Geforce 256/DDR, Quadro */
1557 if (strstr(gl_renderer, "TNT2"))
1559 *vidmem = 32; /* Most TNT2 boards have 32MB, though there are 16MB boards too */
1560 return CARD_NVIDIA_RIVA_TNT2; /* Riva TNT2 standard/M64/Pro/Ultra */
1563 *vidmem = 16; /* Most TNT boards have 16MB, some rare models have 8MB */
1564 return CARD_NVIDIA_RIVA_TNT; /* Riva TNT, Vanta */
1568 static enum wined3d_pci_device select_card_ati_binary(const struct wined3d_gl_info *gl_info,
1569 const char *gl_renderer, unsigned int *vidmem)
1571 /* See http://developer.amd.com/drivers/pc_vendor_id/Pages/default.aspx
1573 * Beware: renderer string do not match exact card model,
1574 * eg HD 4800 is returned for multiple cards, even for RV790 based ones. */
1575 if (WINE_D3D10_CAPABLE(gl_info))
1577 /* Radeon EG CYPRESS XT / PRO HD5800 - highend */
1578 if (strstr(gl_renderer, "HD 5800") /* Radeon EG CYPRESS HD58xx generic renderer string */
1579 || strstr(gl_renderer, "HD 5850") /* Radeon EG CYPRESS XT */
1580 || strstr(gl_renderer, "HD 5870")) /* Radeon EG CYPRESS PRO */
1582 *vidmem = 1024; /* note: HD58xx cards use 1024MB */
1583 return CARD_ATI_RADEON_HD5800;
1586 /* Radeon EG JUNIPER XT / LE HD5700 - midend */
1587 if (strstr(gl_renderer, "HD 5700") /* Radeon EG JUNIPER HD57xx generic renderer string */
1588 || strstr(gl_renderer, "HD 5750") /* Radeon EG JUNIPER LE */
1589 || strstr(gl_renderer, "HD 5770")) /* Radeon EG JUNIPER XT */
1591 *vidmem = 512; /* note: HD5770 cards use 1024MB and HD5750 cards use 512MB or 1024MB */
1592 return CARD_ATI_RADEON_HD5700;
1595 /* Radeon R7xx HD4800 - highend */
1596 if (strstr(gl_renderer, "HD 4800") /* Radeon RV7xx HD48xx generic renderer string */
1597 || strstr(gl_renderer, "HD 4830") /* Radeon RV770 */
1598 || strstr(gl_renderer, "HD 4850") /* Radeon RV770 */
1599 || strstr(gl_renderer, "HD 4870") /* Radeon RV770 */
1600 || strstr(gl_renderer, "HD 4890")) /* Radeon RV790 */
1602 *vidmem = 512; /* note: HD4890 cards use 1024MB */
1603 return CARD_ATI_RADEON_HD4800;
1606 /* Radeon R740 HD4700 - midend */
1607 if (strstr(gl_renderer, "HD 4700") /* Radeon RV770 */
1608 || strstr(gl_renderer, "HD 4770")) /* Radeon RV740 */
1611 return CARD_ATI_RADEON_HD4700;
1614 /* Radeon R730 HD4600 - midend */
1615 if (strstr(gl_renderer, "HD 4600") /* Radeon RV730 */
1616 || strstr(gl_renderer, "HD 4650") /* Radeon RV730 */
1617 || strstr(gl_renderer, "HD 4670")) /* Radeon RV730 */
1620 return CARD_ATI_RADEON_HD4600;
1623 /* Radeon R710 HD4500/HD4350 - lowend */
1624 if (strstr(gl_renderer, "HD 4350") /* Radeon RV710 */
1625 || strstr(gl_renderer, "HD 4550")) /* Radeon RV710 */
1628 return CARD_ATI_RADEON_HD4350;
1631 /* Radeon R6xx HD2900/HD3800 - highend */
1632 if (strstr(gl_renderer, "HD 2900")
1633 || strstr(gl_renderer, "HD 3870")
1634 || strstr(gl_renderer, "HD 3850"))
1636 *vidmem = 512; /* HD2900/HD3800 uses 256-1024MB */
1637 return CARD_ATI_RADEON_HD2900;
1640 /* Radeon R6xx HD2600/HD3600 - midend; HD3830 is China-only midend */
1641 if (strstr(gl_renderer, "HD 2600")
1642 || strstr(gl_renderer, "HD 3830")
1643 || strstr(gl_renderer, "HD 3690")
1644 || strstr(gl_renderer, "HD 3650"))
1646 *vidmem = 256; /* HD2600/HD3600 uses 256-512MB */
1647 return CARD_ATI_RADEON_HD2600;
1650 /* Radeon R6xx HD2350/HD2400/HD3400 - lowend
1651 * Note HD2300=DX9, HD2350=DX10 */
1652 if (strstr(gl_renderer, "HD 2350")
1653 || strstr(gl_renderer, "HD 2400")
1654 || strstr(gl_renderer, "HD 3470")
1655 || strstr(gl_renderer, "HD 3450")
1656 || strstr(gl_renderer, "HD 3430")
1657 || strstr(gl_renderer, "HD 3400"))
1659 *vidmem = 256; /* HD2350/2400 use 256MB, HD34xx use 256-512MB */
1660 return CARD_ATI_RADEON_HD2350;
1663 /* Radeon R6xx/R7xx integrated */
1664 if (strstr(gl_renderer, "HD 3100")
1665 || strstr(gl_renderer, "HD 3200")
1666 || strstr(gl_renderer, "HD 3300"))
1668 *vidmem = 128; /* 128MB */
1669 return CARD_ATI_RADEON_HD3200;
1672 /* Default for when no GPU has been found */
1673 *vidmem = 128; /* 128MB */
1674 return CARD_ATI_RADEON_HD3200;
1677 if (WINE_D3D8_CAPABLE(gl_info))
1680 if (strstr(gl_renderer, "X1600")
1681 || strstr(gl_renderer, "X1650")
1682 || strstr(gl_renderer, "X1800")
1683 || strstr(gl_renderer, "X1900")
1684 || strstr(gl_renderer, "X1950"))
1686 *vidmem = 128; /* X1600 uses 128-256MB, >=X1800 uses 256MB */
1687 return CARD_ATI_RADEON_X1600;
1690 /* Radeon R4xx + X1300/X1400/X1450/X1550/X2300/X2500/HD2300 (lowend R5xx)
1691 * Note X2300/X2500/HD2300 are R5xx GPUs with a 2xxx naming but they are still DX9-only */
1692 if (strstr(gl_renderer, "X700")
1693 || strstr(gl_renderer, "X800")
1694 || strstr(gl_renderer, "X850")
1695 || strstr(gl_renderer, "X1300")
1696 || strstr(gl_renderer, "X1400")
1697 || strstr(gl_renderer, "X1450")
1698 || strstr(gl_renderer, "X1550")
1699 || strstr(gl_renderer, "X2300")
1700 || strstr(gl_renderer, "X2500")
1701 || strstr(gl_renderer, "HD 2300")
1704 *vidmem = 128; /* x700/x8*0 use 128-256MB, >=x1300 128-512MB */
1705 return CARD_ATI_RADEON_X700;
1708 /* Radeon Xpress Series - onboard, DX9b, Shader 2.0, 300-400MHz */
1709 if (strstr(gl_renderer, "Radeon Xpress"))
1711 *vidmem = 64; /* Shared RAM, BIOS configurable, 64-256M */
1712 return CARD_ATI_RADEON_XPRESS_200M;
1716 *vidmem = 64; /* Radeon 9500 uses 64MB, higher models use up to 256MB */
1717 return CARD_ATI_RADEON_9500; /* Radeon 9500/9550/9600/9700/9800/X300/X550/X600 */
1720 if (WINE_D3D8_CAPABLE(gl_info))
1722 *vidmem = 64; /* 8500/9000 cards use mostly 64MB, though there are 32MB and 128MB models */
1723 return CARD_ATI_RADEON_8500; /* Radeon 8500/9000/9100/9200/9300 */
1726 if (WINE_D3D7_CAPABLE(gl_info))
1728 *vidmem = 32; /* There are models with up to 64MB */
1729 return CARD_ATI_RADEON_7200; /* Radeon 7000/7100/7200/7500 */
1732 *vidmem = 16; /* There are 16-32MB models */
1733 return CARD_ATI_RAGE_128PRO;
1737 static enum wined3d_pci_device select_card_intel_binary(const struct wined3d_gl_info *gl_info,
1738 const char *gl_renderer, unsigned int *vidmem)
1740 if (strstr(gl_renderer, "X3100"))
1742 /* MacOS calls the card GMA X3100, otherwise known as GM965/GL960 */
1744 return CARD_INTEL_X3100;
1747 if (strstr(gl_renderer, "GMA 950") || strstr(gl_renderer, "945GM"))
1749 /* MacOS calls the card GMA 950, but everywhere else the PCI ID is named 945GM */
1751 return CARD_INTEL_I945GM;
1754 if (strstr(gl_renderer, "915GM")) return CARD_INTEL_I915GM;
1755 if (strstr(gl_renderer, "915G")) return CARD_INTEL_I915G;
1756 if (strstr(gl_renderer, "865G")) return CARD_INTEL_I865G;
1757 if (strstr(gl_renderer, "855G")) return CARD_INTEL_I855G;
1758 if (strstr(gl_renderer, "830G")) return CARD_INTEL_I830G;
1759 return CARD_INTEL_I915G;
1763 static enum wined3d_pci_device select_card_ati_mesa(const struct wined3d_gl_info *gl_info,
1764 const char *gl_renderer, unsigned int *vidmem)
1766 /* See http://developer.amd.com/drivers/pc_vendor_id/Pages/default.aspx
1768 * Beware: renderer string do not match exact card model,
1769 * eg HD 4800 is returned for multiple cards, even for RV790 based ones. */
1770 if (strstr(gl_renderer, "Gallium"))
1772 /* Radeon R7xx HD4800 - highend */
1773 if (strstr(gl_renderer, "R700") /* Radeon R7xx HD48xx generic renderer string */
1774 || strstr(gl_renderer, "RV770") /* Radeon RV770 */
1775 || strstr(gl_renderer, "RV790")) /* Radeon RV790 */
1777 *vidmem = 512; /* note: HD4890 cards use 1024MB */
1778 return CARD_ATI_RADEON_HD4800;
1781 /* Radeon R740 HD4700 - midend */
1782 if (strstr(gl_renderer, "RV740")) /* Radeon RV740 */
1785 return CARD_ATI_RADEON_HD4700;
1788 /* Radeon R730 HD4600 - midend */
1789 if (strstr(gl_renderer, "RV730")) /* Radeon RV730 */
1792 return CARD_ATI_RADEON_HD4600;
1795 /* Radeon R710 HD4500/HD4350 - lowend */
1796 if (strstr(gl_renderer, "RV710")) /* Radeon RV710 */
1799 return CARD_ATI_RADEON_HD4350;
1802 /* Radeon R6xx HD2900/HD3800 - highend */
1803 if (strstr(gl_renderer, "R600")
1804 || strstr(gl_renderer, "RV670")
1805 || strstr(gl_renderer, "R680"))
1807 *vidmem = 512; /* HD2900/HD3800 uses 256-1024MB */
1808 return CARD_ATI_RADEON_HD2900;
1811 /* Radeon R6xx HD2600/HD3600 - midend; HD3830 is China-only midend */
1812 if (strstr(gl_renderer, "RV630")
1813 || strstr(gl_renderer, "RV635"))
1815 *vidmem = 256; /* HD2600/HD3600 uses 256-512MB */
1816 return CARD_ATI_RADEON_HD2600;
1819 /* Radeon R6xx HD2350/HD2400/HD3400 - lowend */
1820 if (strstr(gl_renderer, "RV610")
1821 || strstr(gl_renderer, "RV620"))
1823 *vidmem = 256; /* HD2350/2400 use 256MB, HD34xx use 256-512MB */
1824 return CARD_ATI_RADEON_HD2350;
1827 /* Radeon R6xx/R7xx integrated */
1828 if (strstr(gl_renderer, "RS780")
1829 || strstr(gl_renderer, "RS880"))
1831 *vidmem = 128; /* 128MB */
1832 return CARD_ATI_RADEON_HD3200;
1836 if (strstr(gl_renderer, "RV530")
1837 || strstr(gl_renderer, "RV535")
1838 || strstr(gl_renderer, "RV560")
1839 || strstr(gl_renderer, "R520")
1840 || strstr(gl_renderer, "RV570")
1841 || strstr(gl_renderer, "R580"))
1843 *vidmem = 128; /* X1600 uses 128-256MB, >=X1800 uses 256MB */
1844 return CARD_ATI_RADEON_X1600;
1847 /* Radeon R4xx + X1300/X1400/X1450/X1550/X2300 (lowend R5xx) */
1848 if (strstr(gl_renderer, "R410")
1849 || strstr(gl_renderer, "R420")
1850 || strstr(gl_renderer, "R423")
1851 || strstr(gl_renderer, "R430")
1852 || strstr(gl_renderer, "R480")
1853 || strstr(gl_renderer, "R481")
1854 || strstr(gl_renderer, "RV410")
1855 || strstr(gl_renderer, "RV515")
1856 || strstr(gl_renderer, "RV516"))
1858 *vidmem = 128; /* x700/x8*0 use 128-256MB, >=x1300 128-512MB */
1859 return CARD_ATI_RADEON_X700;
1862 /* Radeon Xpress Series - onboard, DX9b, Shader 2.0, 300-400MHz */
1863 if (strstr(gl_renderer, "RS400")
1864 || strstr(gl_renderer, "RS480")
1865 || strstr(gl_renderer, "RS482")
1866 || strstr(gl_renderer, "RS485")
1867 || strstr(gl_renderer, "RS600")
1868 || strstr(gl_renderer, "RS690")
1869 || strstr(gl_renderer, "RS740"))
1871 *vidmem = 64; /* Shared RAM, BIOS configurable, 64-256M */
1872 return CARD_ATI_RADEON_XPRESS_200M;
1876 if (strstr(gl_renderer, "R300")
1877 || strstr(gl_renderer, "RV350")
1878 || strstr(gl_renderer, "RV351")
1879 || strstr(gl_renderer, "RV360")
1880 || strstr(gl_renderer, "RV370")
1881 || strstr(gl_renderer, "R350")
1882 || strstr(gl_renderer, "R360"))
1884 *vidmem = 64; /* Radeon 9500 uses 64MB, higher models use up to 256MB */
1885 return CARD_ATI_RADEON_9500; /* Radeon 9500/9550/9600/9700/9800/X300/X550/X600 */
1889 if (WINE_D3D9_CAPABLE(gl_info))
1891 /* Radeon R7xx HD4800 - highend */
1892 if (strstr(gl_renderer, "(R700") /* Radeon R7xx HD48xx generic renderer string */
1893 || strstr(gl_renderer, "(RV770") /* Radeon RV770 */
1894 || strstr(gl_renderer, "(RV790")) /* Radeon RV790 */
1896 *vidmem = 512; /* note: HD4890 cards use 1024MB */
1897 return CARD_ATI_RADEON_HD4800;
1900 /* Radeon R740 HD4700 - midend */
1901 if (strstr(gl_renderer, "(RV740")) /* Radeon RV740 */
1904 return CARD_ATI_RADEON_HD4700;
1907 /* Radeon R730 HD4600 - midend */
1908 if (strstr(gl_renderer, "(RV730")) /* Radeon RV730 */
1911 return CARD_ATI_RADEON_HD4600;
1914 /* Radeon R710 HD4500/HD4350 - lowend */
1915 if (strstr(gl_renderer, "(RV710")) /* Radeon RV710 */
1918 return CARD_ATI_RADEON_HD4350;
1921 /* Radeon R6xx HD2900/HD3800 - highend */
1922 if (strstr(gl_renderer, "(R600")
1923 || strstr(gl_renderer, "(RV670")
1924 || strstr(gl_renderer, "(R680"))
1926 *vidmem = 512; /* HD2900/HD3800 uses 256-1024MB */
1927 return CARD_ATI_RADEON_HD2900;
1930 /* Radeon R6xx HD2600/HD3600 - midend; HD3830 is China-only midend */
1931 if (strstr(gl_renderer, "(RV630")
1932 || strstr(gl_renderer, "(RV635"))
1934 *vidmem = 256; /* HD2600/HD3600 uses 256-512MB */
1935 return CARD_ATI_RADEON_HD2600;
1938 /* Radeon R6xx HD2300/HD2400/HD3400 - lowend */
1939 if (strstr(gl_renderer, "(RV610")
1940 || strstr(gl_renderer, "(RV620"))
1942 *vidmem = 256; /* HD2350/2400 use 256MB, HD34xx use 256-512MB */
1943 return CARD_ATI_RADEON_HD2350;
1946 /* Radeon R6xx/R7xx integrated */
1947 if (strstr(gl_renderer, "(RS780")
1948 || strstr(gl_renderer, "(RS880"))
1950 *vidmem = 128; /* 128MB */
1951 return CARD_ATI_RADEON_HD3200;
1955 if (WINE_D3D8_CAPABLE(gl_info))
1957 *vidmem = 64; /* 8500/9000 cards use mostly 64MB, though there are 32MB and 128MB models */
1958 return CARD_ATI_RADEON_8500; /* Radeon 8500/9000/9100/9200/9300 */
1961 if (WINE_D3D7_CAPABLE(gl_info))
1963 *vidmem = 32; /* There are models with up to 64MB */
1964 return CARD_ATI_RADEON_7200; /* Radeon 7000/7100/7200/7500 */
1967 *vidmem = 16; /* There are 16-32MB models */
1968 return CARD_ATI_RAGE_128PRO;
1972 static enum wined3d_pci_device select_card_nvidia_mesa(const struct wined3d_gl_info *gl_info,
1973 const char *gl_renderer, unsigned int *vidmem)
1975 FIXME_(d3d_caps)("Card selection not handled for Mesa Nouveau driver\n");
1976 if (WINE_D3D9_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCEFX_5600;
1977 if (WINE_D3D8_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCE3;
1978 if (WINE_D3D7_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCE;
1979 if (WINE_D3D6_CAPABLE(gl_info)) return CARD_NVIDIA_RIVA_TNT;
1980 return CARD_NVIDIA_RIVA_128;
1983 static enum wined3d_pci_device select_card_intel_mesa(const struct wined3d_gl_info *gl_info,
1984 const char *gl_renderer, unsigned int *vidmem)
1986 FIXME_(d3d_caps)("Card selection not handled for Mesa Intel driver\n");
1987 return CARD_INTEL_I915G;
1991 struct vendor_card_selection
1993 enum wined3d_gl_vendor gl_vendor;
1994 enum wined3d_pci_vendor card_vendor;
1995 const char *description; /* Description of the card selector i.e. Apple OS/X Intel */
1996 enum wined3d_pci_device (*select_card)(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
1997 unsigned int *vidmem );
2000 static const struct vendor_card_selection vendor_card_select_table[] =
2002 {GL_VENDOR_NVIDIA, HW_VENDOR_NVIDIA, "Nvidia binary driver", select_card_nvidia_binary},
2003 {GL_VENDOR_APPLE, HW_VENDOR_NVIDIA, "Apple OSX NVidia binary driver", select_card_nvidia_binary},
2004 {GL_VENDOR_APPLE, HW_VENDOR_ATI, "Apple OSX AMD/ATI binary driver", select_card_ati_binary},
2005 {GL_VENDOR_APPLE, HW_VENDOR_INTEL, "Apple OSX Intel binary driver", select_card_intel_binary},
2006 {GL_VENDOR_FGLRX, HW_VENDOR_ATI, "AMD/ATI binary driver", select_card_ati_binary},
2007 {GL_VENDOR_MESA, HW_VENDOR_ATI, "Mesa AMD/ATI driver", select_card_ati_mesa},
2008 {GL_VENDOR_MESA, HW_VENDOR_NVIDIA, "Mesa Nouveau driver", select_card_nvidia_mesa},
2009 {GL_VENDOR_MESA, HW_VENDOR_INTEL, "Mesa Intel driver", select_card_intel_mesa},
2010 {GL_VENDOR_INTEL, HW_VENDOR_INTEL, "Mesa Intel driver", select_card_intel_mesa}
2014 static enum wined3d_pci_device wined3d_guess_card(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
2015 enum wined3d_gl_vendor *gl_vendor, enum wined3d_pci_vendor *card_vendor, unsigned int *vidmem)
2017 /* Above is a list of Nvidia and ATI GPUs. Both vendors have dozens of
2018 * different GPUs with roughly the same features. In most cases GPUs from a
2019 * certain family differ in clockspeeds, the amount of video memory and the
2020 * number of shader pipelines.
2022 * A Direct3D device object contains the PCI id (vendor + device) of the
2023 * videocard which is used for rendering. Various applications use this
2024 * information to get a rough estimation of the features of the card and
2025 * some might use it for enabling 3d effects only on certain types of
2026 * videocards. In some cases games might even use it to work around bugs
2027 * which happen on certain videocards/driver combinations. The problem is
2028 * that OpenGL only exposes a rendering string containing the name of the
2029 * videocard and not the PCI id.
2031 * Various games depend on the PCI id, so somehow we need to provide one.
2032 * A simple option is to parse the renderer string and translate this to
2033 * the right PCI id. This is a lot of work because there are more than 200
2034 * GPUs just for Nvidia. Various cards share the same renderer string, so
2035 * the amount of code might be 'small' but there are quite a number of
2036 * exceptions which would make this a pain to maintain. Another way would
2037 * be to query the PCI id from the operating system (assuming this is the
2038 * videocard which is used for rendering which is not always the case).
2039 * This would work but it is not very portable. Second it would not work
2040 * well in, let's say, a remote X situation in which the amount of 3d
2041 * features which can be used is limited.
2043 * As said most games only use the PCI id to get an indication of the
2044 * capabilities of the card. It doesn't really matter if the given id is
2045 * the correct one if we return the id of a card with similar 3d features.
2047 * The code below checks the OpenGL capabilities of a videocard and matches
2048 * that to a certain level of Direct3D functionality. Once a card passes
2049 * the Direct3D9 check, we know that the card (in case of Nvidia) is at
2050 * least a GeforceFX. To give a better estimate we do a basic check on the
2051 * renderer string but if that won't pass we return a default card. This
2052 * way is better than maintaining a full card database as even without a
2053 * full database we can return a card with similar features. Second the
2054 * size of the database can be made quite small because when you know what
2055 * type of 3d functionality a card has, you know to which GPU family the
2056 * GPU must belong. Because of this you only have to check a small part of
2057 * the renderer string to distinguishes between different models from that
2060 * The code also selects a default amount of video memory which we will
2061 * use for an estimation of the amount of free texture memory. In case of
2062 * real D3D the amount of texture memory includes video memory and system
2063 * memory (to be specific AGP memory or in case of PCIE TurboCache /
2064 * HyperMemory). We don't know how much system memory can be addressed by
2065 * the system but we can make a reasonable estimation about the amount of
2066 * video memory. If the value is slightly wrong it doesn't matter as we
2067 * didn't include AGP-like memory which makes the amount of addressable
2068 * memory higher and second OpenGL isn't that critical it moves to system
2069 * memory behind our backs if really needed. Note that the amount of video
2070 * memory can be overruled using a registry setting. */
2074 for (i = 0; i < (sizeof(vendor_card_select_table) / sizeof(*vendor_card_select_table)); ++i)
2076 if ((vendor_card_select_table[i].gl_vendor != *gl_vendor)
2077 || (vendor_card_select_table[i].card_vendor != *card_vendor))
2079 TRACE_(d3d_caps)("Applying card_selector \"%s\".\n", vendor_card_select_table[i].description);
2080 return vendor_card_select_table[i].select_card(gl_info, gl_renderer, vidmem);
2083 FIXME_(d3d_caps)("No card selector available for GL vendor %d and card vendor %04x.\n",
2084 *gl_vendor, *card_vendor);
2086 /* Default to generic Nvidia hardware based on the supported OpenGL extensions. The choice
2087 * for Nvidia was because the hardware and drivers they make are of good quality. This makes
2088 * them a good generic choice. */
2089 *card_vendor = HW_VENDOR_NVIDIA;
2090 if (WINE_D3D9_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCEFX_5600;
2091 if (WINE_D3D8_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCE3;
2092 if (WINE_D3D7_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCE;
2093 if (WINE_D3D6_CAPABLE(gl_info)) return CARD_NVIDIA_RIVA_TNT;
2094 return CARD_NVIDIA_RIVA_128;
2097 static const struct fragment_pipeline *select_fragment_implementation(struct wined3d_adapter *adapter)
2099 const struct wined3d_gl_info *gl_info = &adapter->gl_info;
2100 int vs_selected_mode, ps_selected_mode;
2102 select_shader_mode(gl_info, &ps_selected_mode, &vs_selected_mode);
2103 if ((ps_selected_mode == SHADER_ARB || ps_selected_mode == SHADER_GLSL)
2104 && gl_info->supported[ARB_FRAGMENT_PROGRAM]) return &arbfp_fragment_pipeline;
2105 else if (ps_selected_mode == SHADER_ATI) return &atifs_fragment_pipeline;
2106 else if (gl_info->supported[NV_REGISTER_COMBINERS]
2107 && gl_info->supported[NV_TEXTURE_SHADER2]) return &nvts_fragment_pipeline;
2108 else if (gl_info->supported[NV_REGISTER_COMBINERS]) return &nvrc_fragment_pipeline;
2109 else return &ffp_fragment_pipeline;
2112 static const shader_backend_t *select_shader_backend(struct wined3d_adapter *adapter)
2114 int vs_selected_mode, ps_selected_mode;
2116 select_shader_mode(&adapter->gl_info, &ps_selected_mode, &vs_selected_mode);
2117 if (vs_selected_mode == SHADER_GLSL || ps_selected_mode == SHADER_GLSL) return &glsl_shader_backend;
2118 if (vs_selected_mode == SHADER_ARB || ps_selected_mode == SHADER_ARB) return &arb_program_shader_backend;
2119 return &none_shader_backend;
2122 static const struct blit_shader *select_blit_implementation(struct wined3d_adapter *adapter)
2124 const struct wined3d_gl_info *gl_info = &adapter->gl_info;
2125 int vs_selected_mode, ps_selected_mode;
2127 select_shader_mode(gl_info, &ps_selected_mode, &vs_selected_mode);
2128 if ((ps_selected_mode == SHADER_ARB || ps_selected_mode == SHADER_GLSL)
2129 && gl_info->supported[ARB_FRAGMENT_PROGRAM]) return &arbfp_blit;
2130 else return &ffp_blit;
2133 /* Context activation is done by the caller. */
2134 static BOOL IWineD3DImpl_FillGLCaps(struct wined3d_adapter *adapter)
2136 struct wined3d_driver_info *driver_info = &adapter->driver_info;
2137 struct wined3d_gl_info *gl_info = &adapter->gl_info;
2138 const char *GL_Extensions = NULL;
2139 const char *WGL_Extensions = NULL;
2140 const char *gl_vendor_str, *gl_renderer_str, *gl_version_str;
2141 struct fragment_caps fragment_caps;
2142 enum wined3d_gl_vendor gl_vendor;
2143 enum wined3d_pci_vendor card_vendor;
2144 enum wined3d_pci_device device;
2146 GLfloat gl_floatv[2];
2149 unsigned int vidmem=0;
2153 TRACE_(d3d_caps)("(%p)\n", gl_info);
2157 gl_renderer_str = (const char *)glGetString(GL_RENDERER);
2158 TRACE_(d3d_caps)("GL_RENDERER: %s.\n", debugstr_a(gl_renderer_str));
2159 if (!gl_renderer_str)
2162 ERR_(d3d_caps)("Received a NULL GL_RENDERER.\n");
2166 gl_vendor_str = (const char *)glGetString(GL_VENDOR);
2167 TRACE_(d3d_caps)("GL_VENDOR: %s.\n", debugstr_a(gl_vendor_str));
2171 ERR_(d3d_caps)("Received a NULL GL_VENDOR.\n");
2175 /* Parse the GL_VERSION field into major and minor information */
2176 gl_version_str = (const char *)glGetString(GL_VERSION);
2177 TRACE_(d3d_caps)("GL_VERSION: %s.\n", debugstr_a(gl_version_str));
2178 if (!gl_version_str)
2181 ERR_(d3d_caps)("Received a NULL GL_VERSION.\n");
2184 gl_version = wined3d_parse_gl_version(gl_version_str);
2187 * Initialize openGL extension related variables
2188 * with Default values
2190 memset(gl_info->supported, 0, sizeof(gl_info->supported));
2191 gl_info->limits.blends = 1;
2192 gl_info->limits.buffers = 1;
2193 gl_info->limits.textures = 1;
2194 gl_info->limits.fragment_samplers = 1;
2195 gl_info->limits.vertex_samplers = 0;
2196 gl_info->limits.combined_samplers = gl_info->limits.fragment_samplers + gl_info->limits.vertex_samplers;
2197 gl_info->limits.sampler_stages = 1;
2198 gl_info->limits.glsl_vs_float_constants = 0;
2199 gl_info->limits.glsl_ps_float_constants = 0;
2200 gl_info->limits.arb_vs_float_constants = 0;
2201 gl_info->limits.arb_vs_native_constants = 0;
2202 gl_info->limits.arb_vs_instructions = 0;
2203 gl_info->limits.arb_vs_temps = 0;
2204 gl_info->limits.arb_ps_float_constants = 0;
2205 gl_info->limits.arb_ps_local_constants = 0;
2206 gl_info->limits.arb_ps_instructions = 0;
2207 gl_info->limits.arb_ps_temps = 0;
2209 /* Retrieve opengl defaults */
2210 glGetIntegerv(GL_MAX_CLIP_PLANES, &gl_max);
2211 gl_info->limits.clipplanes = min(WINED3DMAXUSERCLIPPLANES, gl_max);
2212 TRACE_(d3d_caps)("ClipPlanes support - num Planes=%d\n", gl_max);
2214 glGetIntegerv(GL_MAX_LIGHTS, &gl_max);
2215 gl_info->limits.lights = gl_max;
2216 TRACE_(d3d_caps)("Lights support - max lights=%d\n", gl_max);
2218 glGetIntegerv(GL_MAX_TEXTURE_SIZE, &gl_max);
2219 gl_info->limits.texture_size = gl_max;
2220 TRACE_(d3d_caps)("Maximum texture size support - max texture size=%d\n", gl_max);
2222 glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, gl_floatv);
2223 gl_info->limits.pointsize_min = gl_floatv[0];
2224 gl_info->limits.pointsize_max = gl_floatv[1];
2225 TRACE_(d3d_caps)("Maximum point size support - max point size=%f\n", gl_floatv[1]);
2227 /* Parse the gl supported features, in theory enabling parts of our code appropriately. */
2228 GL_Extensions = (const char *)glGetString(GL_EXTENSIONS);
2232 ERR_(d3d_caps)("Received a NULL GL_EXTENSIONS.\n");
2238 TRACE_(d3d_caps)("GL_Extensions reported:\n");
2240 gl_info->supported[WINED3D_GL_EXT_NONE] = TRUE;
2242 while (*GL_Extensions)
2245 char current_ext[256];
2247 while (isspace(*GL_Extensions)) ++GL_Extensions;
2248 start = GL_Extensions;
2249 while (!isspace(*GL_Extensions) && *GL_Extensions) ++GL_Extensions;
2251 len = GL_Extensions - start;
2252 if (!len || len >= sizeof(current_ext)) continue;
2254 memcpy(current_ext, start, len);
2255 current_ext[len] = '\0';
2256 TRACE_(d3d_caps)("- %s\n", debugstr_a(current_ext));
2258 for (i = 0; i < (sizeof(EXTENSION_MAP) / sizeof(*EXTENSION_MAP)); ++i)
2260 if (!strcmp(current_ext, EXTENSION_MAP[i].extension_string))
2262 TRACE_(d3d_caps)(" FOUND: %s support.\n", EXTENSION_MAP[i].extension_string);
2263 gl_info->supported[EXTENSION_MAP[i].extension] = TRUE;
2269 /* Now work out what GL support this card really has */
2270 #define USE_GL_FUNC(type, pfn, ext, replace) \
2272 DWORD ver = ver_for_ext(ext); \
2273 if (gl_info->supported[ext]) gl_info->pfn = (type)pwglGetProcAddress(#pfn); \
2274 else if (ver && ver <= gl_version) gl_info->pfn = (type)pwglGetProcAddress(#replace); \
2275 else gl_info->pfn = NULL; \
2280 #define USE_GL_FUNC(type, pfn, ext, replace) gl_info->pfn = (type)pwglGetProcAddress(#pfn);
2286 /* Now mark all the extensions supported which are included in the opengl core version. Do this *after*
2287 * loading the functions, otherwise the code above will load the extension entry points instead of the
2288 * core functions, which may not work. */
2289 for (i = 0; i < (sizeof(EXTENSION_MAP) / sizeof(*EXTENSION_MAP)); ++i)
2291 if (!gl_info->supported[EXTENSION_MAP[i].extension]
2292 && EXTENSION_MAP[i].version <= gl_version && EXTENSION_MAP[i].version)
2294 TRACE_(d3d_caps)(" GL CORE: %s support.\n", EXTENSION_MAP[i].extension_string);
2295 gl_info->supported[EXTENSION_MAP[i].extension] = TRUE;
2299 if (gl_version >= MAKEDWORD_VERSION(2, 0)) gl_info->supported[WINED3D_GL_VERSION_2_0] = TRUE;
2301 if (gl_info->supported[APPLE_FENCE])
2303 /* GL_NV_fence and GL_APPLE_fence provide the same functionality basically.
2304 * The apple extension interacts with some other apple exts. Disable the NV
2305 * extension if the apple one is support to prevent confusion in other parts
2307 gl_info->supported[NV_FENCE] = FALSE;
2309 if (gl_info->supported[APPLE_FLOAT_PIXELS])
2311 /* GL_APPLE_float_pixels == GL_ARB_texture_float + GL_ARB_half_float_pixel
2313 * The enums are the same:
2314 * GL_RGBA16F_ARB = GL_RGBA_FLOAT16_APPLE = 0x881A
2315 * GL_RGB16F_ARB = GL_RGB_FLOAT16_APPLE = 0x881B
2316 * GL_RGBA32F_ARB = GL_RGBA_FLOAT32_APPLE = 0x8814
2317 * GL_RGB32F_ARB = GL_RGB_FLOAT32_APPLE = 0x8815
2318 * GL_HALF_FLOAT_ARB = GL_HALF_APPLE = 0x140B
2320 if (!gl_info->supported[ARB_TEXTURE_FLOAT])
2322 TRACE_(d3d_caps)(" IMPLIED: GL_ARB_texture_float support(from GL_APPLE_float_pixels.\n");
2323 gl_info->supported[ARB_TEXTURE_FLOAT] = TRUE;
2325 if (!gl_info->supported[ARB_HALF_FLOAT_PIXEL])
2327 TRACE_(d3d_caps)(" IMPLIED: GL_ARB_half_float_pixel support(from GL_APPLE_float_pixels.\n");
2328 gl_info->supported[ARB_HALF_FLOAT_PIXEL] = TRUE;
2331 if (gl_info->supported[ARB_MAP_BUFFER_RANGE])
2333 /* GL_ARB_map_buffer_range and GL_APPLE_flush_buffer_range provide the same
2334 * functionality. Prefer the ARB extension */
2335 gl_info->supported[APPLE_FLUSH_BUFFER_RANGE] = FALSE;
2337 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
2339 TRACE_(d3d_caps)(" IMPLIED: NVIDIA (NV) Texture Gen Reflection support.\n");
2340 gl_info->supported[NV_TEXGEN_REFLECTION] = TRUE;
2342 if (!gl_info->supported[ARB_DEPTH_CLAMP] && gl_info->supported[NV_DEPTH_CLAMP])
2344 TRACE_(d3d_caps)(" IMPLIED: ARB_depth_clamp support (by NV_depth_clamp).\n");
2345 gl_info->supported[ARB_DEPTH_CLAMP] = TRUE;
2347 if (!gl_info->supported[ARB_VERTEX_ARRAY_BGRA] && gl_info->supported[EXT_VERTEX_ARRAY_BGRA])
2349 TRACE_(d3d_caps)(" IMPLIED: ARB_vertex_array_bgra support (by EXT_vertex_array_bgra).\n");
2350 gl_info->supported[ARB_VERTEX_ARRAY_BGRA] = TRUE;
2352 if (gl_info->supported[NV_TEXTURE_SHADER2])
2354 if (gl_info->supported[NV_REGISTER_COMBINERS])
2356 /* Also disable ATI_FRAGMENT_SHADER if register combiners and texture_shader2
2357 * are supported. The nv extensions provide the same functionality as the
2358 * ATI one, and a bit more(signed pixelformats). */
2359 gl_info->supported[ATI_FRAGMENT_SHADER] = FALSE;
2363 if (gl_info->supported[NV_REGISTER_COMBINERS])
2365 glGetIntegerv(GL_MAX_GENERAL_COMBINERS_NV, &gl_max);
2366 gl_info->limits.general_combiners = gl_max;
2367 TRACE_(d3d_caps)("Max general combiners: %d.\n", gl_max);
2369 if (gl_info->supported[ARB_DRAW_BUFFERS])
2371 glGetIntegerv(GL_MAX_DRAW_BUFFERS_ARB, &gl_max);
2372 gl_info->limits.buffers = gl_max;
2373 TRACE_(d3d_caps)("Max draw buffers: %u.\n", gl_max);
2375 if (gl_info->supported[ARB_MULTITEXTURE])
2377 glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &gl_max);
2378 gl_info->limits.textures = min(MAX_TEXTURES, gl_max);
2379 TRACE_(d3d_caps)("Max textures: %d.\n", gl_info->limits.textures);
2381 if (gl_info->supported[ARB_FRAGMENT_PROGRAM])
2384 glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS_ARB, &tmp);
2385 gl_info->limits.fragment_samplers = min(MAX_FRAGMENT_SAMPLERS, tmp);
2389 gl_info->limits.fragment_samplers = max(gl_info->limits.fragment_samplers, gl_max);
2391 TRACE_(d3d_caps)("Max fragment samplers: %d.\n", gl_info->limits.fragment_samplers);
2393 if (gl_info->supported[ARB_VERTEX_SHADER])
2396 glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB, &tmp);
2397 gl_info->limits.vertex_samplers = tmp;
2398 glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB, &tmp);
2399 gl_info->limits.combined_samplers = tmp;
2401 /* Loading GLSL sampler uniforms is much simpler if we can assume that the sampler setup
2402 * is known at shader link time. In a vertex shader + pixel shader combination this isn't
2403 * an issue because then the sampler setup only depends on the two shaders. If a pixel
2404 * shader is used with fixed function vertex processing we're fine too because fixed function
2405 * vertex processing doesn't use any samplers. If fixed function fragment processing is
2406 * used we have to make sure that all vertex sampler setups are valid together with all
2407 * possible fixed function fragment processing setups. This is true if vsamplers + MAX_TEXTURES
2408 * <= max_samplers. This is true on all d3d9 cards that support vtf(gf 6 and gf7 cards).
2409 * dx9 radeon cards do not support vertex texture fetch. DX10 cards have 128 samplers, and
2410 * dx9 is limited to 8 fixed function texture stages and 4 vertex samplers. DX10 does not have
2411 * a fixed function pipeline anymore.
2413 * So this is just a check to check that our assumption holds true. If not, write a warning
2414 * and reduce the number of vertex samplers or probably disable vertex texture fetch. */
2415 if (gl_info->limits.vertex_samplers && gl_info->limits.combined_samplers < 12
2416 && MAX_TEXTURES + gl_info->limits.vertex_samplers > gl_info->limits.combined_samplers)
2418 FIXME("OpenGL implementation supports %u vertex samplers and %u total samplers.\n",
2419 gl_info->limits.vertex_samplers, gl_info->limits.combined_samplers);
2420 FIXME("Expected vertex samplers + MAX_TEXTURES(=8) > combined_samplers.\n");
2421 if (gl_info->limits.combined_samplers > MAX_TEXTURES)
2422 gl_info->limits.vertex_samplers = gl_info->limits.combined_samplers - MAX_TEXTURES;
2424 gl_info->limits.vertex_samplers = 0;
2429 gl_info->limits.combined_samplers = gl_info->limits.fragment_samplers;
2431 TRACE_(d3d_caps)("Max vertex samplers: %u.\n", gl_info->limits.vertex_samplers);
2432 TRACE_(d3d_caps)("Max combined samplers: %u.\n", gl_info->limits.combined_samplers);
2434 if (gl_info->supported[ARB_VERTEX_BLEND])
2436 glGetIntegerv(GL_MAX_VERTEX_UNITS_ARB, &gl_max);
2437 gl_info->limits.blends = gl_max;
2438 TRACE_(d3d_caps)("Max blends: %u.\n", gl_info->limits.blends);
2440 if (gl_info->supported[EXT_TEXTURE3D])
2442 glGetIntegerv(GL_MAX_3D_TEXTURE_SIZE_EXT, &gl_max);
2443 gl_info->limits.texture3d_size = gl_max;
2444 TRACE_(d3d_caps)("Max texture3D size: %d.\n", gl_info->limits.texture3d_size);
2446 if (gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC])
2448 glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &gl_max);
2449 gl_info->limits.anisotropy = gl_max;
2450 TRACE_(d3d_caps)("Max anisotropy: %d.\n", gl_info->limits.anisotropy);
2452 if (gl_info->supported[ARB_FRAGMENT_PROGRAM])
2454 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max));
2455 gl_info->limits.arb_ps_float_constants = gl_max;
2456 TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM float constants: %d.\n", gl_info->limits.arb_ps_float_constants);
2457 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB, &gl_max));
2458 gl_info->limits.arb_ps_native_constants = gl_max;
2459 TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM native float constants: %d.\n",
2460 gl_info->limits.arb_ps_native_constants);
2461 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, &gl_max));
2462 gl_info->limits.arb_ps_temps = gl_max;
2463 TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM native temporaries: %d.\n", gl_info->limits.arb_ps_temps);
2464 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, &gl_max));
2465 gl_info->limits.arb_ps_instructions = gl_max;
2466 TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM native instructions: %d.\n", gl_info->limits.arb_ps_instructions);
2467 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB, &gl_max));
2468 gl_info->limits.arb_ps_local_constants = gl_max;
2469 TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM local parameters: %d.\n", gl_info->limits.arb_ps_instructions);
2471 if (gl_info->supported[ARB_VERTEX_PROGRAM])
2473 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max));
2474 gl_info->limits.arb_vs_float_constants = gl_max;
2475 TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM float constants: %d.\n", gl_info->limits.arb_vs_float_constants);
2476 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB, &gl_max));
2477 gl_info->limits.arb_vs_native_constants = gl_max;
2478 TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM native float constants: %d.\n",
2479 gl_info->limits.arb_vs_native_constants);
2480 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, &gl_max));
2481 gl_info->limits.arb_vs_temps = gl_max;
2482 TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM native temporaries: %d.\n", gl_info->limits.arb_vs_temps);
2483 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, &gl_max));
2484 gl_info->limits.arb_vs_instructions = gl_max;
2485 TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM native instructions: %d.\n", gl_info->limits.arb_vs_instructions);
2487 if (test_arb_vs_offset_limit(gl_info)) gl_info->quirks |= WINED3D_QUIRK_ARB_VS_OFFSET_LIMIT;
2489 if (gl_info->supported[ARB_VERTEX_SHADER])
2491 glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB, &gl_max);
2492 gl_info->limits.glsl_vs_float_constants = gl_max / 4;
2493 TRACE_(d3d_caps)("Max ARB_VERTEX_SHADER float constants: %u.\n", gl_info->limits.glsl_vs_float_constants);
2495 if (gl_info->supported[ARB_FRAGMENT_SHADER])
2497 glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB, &gl_max);
2498 gl_info->limits.glsl_ps_float_constants = gl_max / 4;
2499 TRACE_(d3d_caps)("Max ARB_FRAGMENT_SHADER float constants: %u.\n", gl_info->limits.glsl_ps_float_constants);
2500 glGetIntegerv(GL_MAX_VARYING_FLOATS_ARB, &gl_max);
2501 gl_info->limits.glsl_varyings = gl_max;
2502 TRACE_(d3d_caps)("Max GLSL varyings: %u (%u 4 component varyings).\n", gl_max, gl_max / 4);
2504 if (gl_info->supported[ARB_SHADING_LANGUAGE_100])
2506 const char *str = (const char *)glGetString(GL_SHADING_LANGUAGE_VERSION_ARB);
2507 unsigned int major, minor;
2509 TRACE_(d3d_caps)("GLSL version string: %s.\n", debugstr_a(str));
2511 /* The format of the GLSL version string is "major.minor[.release] [vendor info]". */
2512 sscanf(str, "%u.%u", &major, &minor);
2513 gl_info->glsl_version = MAKEDWORD_VERSION(major, minor);
2515 if (gl_info->supported[NV_LIGHT_MAX_EXPONENT])
2517 glGetFloatv(GL_MAX_SHININESS_NV, &gl_info->limits.shininess);
2521 gl_info->limits.shininess = 128.0f;
2523 if (gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO])
2525 /* If we have full NP2 texture support, disable
2526 * GL_ARB_texture_rectangle because we will never use it.
2527 * This saves a few redundant glDisable calls. */
2528 gl_info->supported[ARB_TEXTURE_RECTANGLE] = FALSE;
2530 if (gl_info->supported[ATI_FRAGMENT_SHADER])
2532 /* Disable NV_register_combiners and fragment shader if this is supported.
2533 * generally the NV extensions are preferred over the ATI ones, and this
2534 * extension is disabled if register_combiners and texture_shader2 are both
2535 * supported. So we reach this place only if we have incomplete NV dxlevel 8
2536 * fragment processing support. */
2537 gl_info->supported[NV_REGISTER_COMBINERS] = FALSE;
2538 gl_info->supported[NV_REGISTER_COMBINERS2] = FALSE;
2539 gl_info->supported[NV_TEXTURE_SHADER] = FALSE;
2540 gl_info->supported[NV_TEXTURE_SHADER2] = FALSE;
2542 if (gl_info->supported[NV_HALF_FLOAT])
2544 /* GL_ARB_half_float_vertex is a subset of GL_NV_half_float. */
2545 gl_info->supported[ARB_HALF_FLOAT_VERTEX] = TRUE;
2547 if (gl_info->supported[ARB_POINT_SPRITE])
2549 gl_info->limits.point_sprite_units = gl_info->limits.textures;
2553 gl_info->limits.point_sprite_units = 0;
2555 checkGLcall("extension detection");
2559 adapter->fragment_pipe = select_fragment_implementation(adapter);
2560 adapter->shader_backend = select_shader_backend(adapter);
2561 adapter->blitter = select_blit_implementation(adapter);
2563 adapter->fragment_pipe->get_caps(gl_info, &fragment_caps);
2564 gl_info->limits.texture_stages = fragment_caps.MaxTextureBlendStages;
2565 TRACE_(d3d_caps)("Max texture stages: %u.\n", gl_info->limits.texture_stages);
2567 /* In some cases the number of texture stages can be larger than the number
2568 * of samplers. The GF4 for example can use only 2 samplers (no fragment
2569 * shaders), but 8 texture stages (register combiners). */
2570 gl_info->limits.sampler_stages = max(gl_info->limits.fragment_samplers, gl_info->limits.texture_stages);
2572 if (gl_info->supported[ARB_FRAMEBUFFER_OBJECT])
2574 gl_info->fbo_ops.glIsRenderbuffer = gl_info->glIsRenderbuffer;
2575 gl_info->fbo_ops.glBindRenderbuffer = gl_info->glBindRenderbuffer;
2576 gl_info->fbo_ops.glDeleteRenderbuffers = gl_info->glDeleteRenderbuffers;
2577 gl_info->fbo_ops.glGenRenderbuffers = gl_info->glGenRenderbuffers;
2578 gl_info->fbo_ops.glRenderbufferStorage = gl_info->glRenderbufferStorage;
2579 gl_info->fbo_ops.glRenderbufferStorageMultisample = gl_info->glRenderbufferStorageMultisample;
2580 gl_info->fbo_ops.glGetRenderbufferParameteriv = gl_info->glGetRenderbufferParameteriv;
2581 gl_info->fbo_ops.glIsFramebuffer = gl_info->glIsFramebuffer;
2582 gl_info->fbo_ops.glBindFramebuffer = gl_info->glBindFramebuffer;
2583 gl_info->fbo_ops.glDeleteFramebuffers = gl_info->glDeleteFramebuffers;
2584 gl_info->fbo_ops.glGenFramebuffers = gl_info->glGenFramebuffers;
2585 gl_info->fbo_ops.glCheckFramebufferStatus = gl_info->glCheckFramebufferStatus;
2586 gl_info->fbo_ops.glFramebufferTexture1D = gl_info->glFramebufferTexture1D;
2587 gl_info->fbo_ops.glFramebufferTexture2D = gl_info->glFramebufferTexture2D;
2588 gl_info->fbo_ops.glFramebufferTexture3D = gl_info->glFramebufferTexture3D;
2589 gl_info->fbo_ops.glFramebufferRenderbuffer = gl_info->glFramebufferRenderbuffer;
2590 gl_info->fbo_ops.glGetFramebufferAttachmentParameteriv = gl_info->glGetFramebufferAttachmentParameteriv;
2591 gl_info->fbo_ops.glBlitFramebuffer = gl_info->glBlitFramebuffer;
2592 gl_info->fbo_ops.glGenerateMipmap = gl_info->glGenerateMipmap;
2596 if (gl_info->supported[EXT_FRAMEBUFFER_OBJECT])
2598 gl_info->fbo_ops.glIsRenderbuffer = gl_info->glIsRenderbufferEXT;
2599 gl_info->fbo_ops.glBindRenderbuffer = gl_info->glBindRenderbufferEXT;
2600 gl_info->fbo_ops.glDeleteRenderbuffers = gl_info->glDeleteRenderbuffersEXT;
2601 gl_info->fbo_ops.glGenRenderbuffers = gl_info->glGenRenderbuffersEXT;
2602 gl_info->fbo_ops.glRenderbufferStorage = gl_info->glRenderbufferStorageEXT;
2603 gl_info->fbo_ops.glGetRenderbufferParameteriv = gl_info->glGetRenderbufferParameterivEXT;
2604 gl_info->fbo_ops.glIsFramebuffer = gl_info->glIsFramebufferEXT;
2605 gl_info->fbo_ops.glBindFramebuffer = gl_info->glBindFramebufferEXT;
2606 gl_info->fbo_ops.glDeleteFramebuffers = gl_info->glDeleteFramebuffersEXT;
2607 gl_info->fbo_ops.glGenFramebuffers = gl_info->glGenFramebuffersEXT;
2608 gl_info->fbo_ops.glCheckFramebufferStatus = gl_info->glCheckFramebufferStatusEXT;
2609 gl_info->fbo_ops.glFramebufferTexture1D = gl_info->glFramebufferTexture1DEXT;
2610 gl_info->fbo_ops.glFramebufferTexture2D = gl_info->glFramebufferTexture2DEXT;
2611 gl_info->fbo_ops.glFramebufferTexture3D = gl_info->glFramebufferTexture3DEXT;
2612 gl_info->fbo_ops.glFramebufferRenderbuffer = gl_info->glFramebufferRenderbufferEXT;
2613 gl_info->fbo_ops.glGetFramebufferAttachmentParameteriv = gl_info->glGetFramebufferAttachmentParameterivEXT;
2614 gl_info->fbo_ops.glGenerateMipmap = gl_info->glGenerateMipmapEXT;
2616 else if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
2618 WARN_(d3d_caps)("Framebuffer objects not supported, falling back to backbuffer offscreen rendering mode.\n");
2619 wined3d_settings.offscreen_rendering_mode = ORM_BACKBUFFER;
2621 if (gl_info->supported[EXT_FRAMEBUFFER_BLIT])
2623 gl_info->fbo_ops.glBlitFramebuffer = gl_info->glBlitFramebufferEXT;
2625 if (gl_info->supported[EXT_FRAMEBUFFER_MULTISAMPLE])
2627 gl_info->fbo_ops.glRenderbufferStorageMultisample = gl_info->glRenderbufferStorageMultisampleEXT;
2631 /* MRTs are currently only supported when FBOs are used. */
2632 if (wined3d_settings.offscreen_rendering_mode != ORM_FBO)
2634 gl_info->limits.buffers = 1;
2637 gl_vendor = wined3d_guess_gl_vendor(gl_info, gl_vendor_str, gl_renderer_str);
2638 card_vendor = wined3d_guess_card_vendor(gl_vendor_str, gl_renderer_str);
2639 TRACE_(d3d_caps)("found GL_VENDOR (%s)->(0x%04x/0x%04x)\n", debugstr_a(gl_vendor_str), gl_vendor, card_vendor);
2641 device = wined3d_guess_card(gl_info, gl_renderer_str, &gl_vendor, &card_vendor, &vidmem);
2642 TRACE_(d3d_caps)("FOUND (fake) card: 0x%x (vendor id), 0x%x (device id)\n", card_vendor, device);
2644 /* If we have an estimate use it, else default to 64MB; */
2646 gl_info->vidmem = vidmem*1024*1024; /* convert from MBs to bytes */
2648 gl_info->vidmem = WINE_DEFAULT_VIDMEM;
2650 gl_info->wrap_lookup[WINED3DTADDRESS_WRAP - WINED3DTADDRESS_WRAP] = GL_REPEAT;
2651 gl_info->wrap_lookup[WINED3DTADDRESS_MIRROR - WINED3DTADDRESS_WRAP] =
2652 gl_info->supported[ARB_TEXTURE_MIRRORED_REPEAT] ? GL_MIRRORED_REPEAT_ARB : GL_REPEAT;
2653 gl_info->wrap_lookup[WINED3DTADDRESS_CLAMP - WINED3DTADDRESS_WRAP] = GL_CLAMP_TO_EDGE;
2654 gl_info->wrap_lookup[WINED3DTADDRESS_BORDER - WINED3DTADDRESS_WRAP] =
2655 gl_info->supported[ARB_TEXTURE_BORDER_CLAMP] ? GL_CLAMP_TO_BORDER_ARB : GL_REPEAT;
2656 gl_info->wrap_lookup[WINED3DTADDRESS_MIRRORONCE - WINED3DTADDRESS_WRAP] =
2657 gl_info->supported[ATI_TEXTURE_MIRROR_ONCE] ? GL_MIRROR_CLAMP_TO_EDGE_ATI : GL_REPEAT;
2659 /* Make sure there's an active HDC else the WGL extensions will fail */
2660 hdc = pwglGetCurrentDC();
2662 /* Not all GL drivers might offer WGL extensions e.g. VirtualBox */
2663 if(GL_EXTCALL(wglGetExtensionsStringARB))
2664 WGL_Extensions = GL_EXTCALL(wglGetExtensionsStringARB(hdc));
2666 if (NULL == WGL_Extensions) {
2667 ERR(" WGL_Extensions returns NULL\n");
2669 TRACE_(d3d_caps)("WGL_Extensions reported:\n");
2670 while (*WGL_Extensions != 0x00) {
2674 while (isspace(*WGL_Extensions)) WGL_Extensions++;
2675 Start = WGL_Extensions;
2676 while (!isspace(*WGL_Extensions) && *WGL_Extensions != 0x00) {
2680 len = WGL_Extensions - Start;
2681 if (len == 0 || len >= sizeof(ThisExtn))
2684 memcpy(ThisExtn, Start, len);
2685 ThisExtn[len] = '\0';
2686 TRACE_(d3d_caps)("- %s\n", debugstr_a(ThisExtn));
2688 if (!strcmp(ThisExtn, "WGL_ARB_pixel_format")) {
2689 gl_info->supported[WGL_ARB_PIXEL_FORMAT] = TRUE;
2690 TRACE_(d3d_caps)("FOUND: WGL_ARB_pixel_format support\n");
2692 if (!strcmp(ThisExtn, "WGL_WINE_pixel_format_passthrough")) {
2693 gl_info->supported[WGL_WINE_PIXEL_FORMAT_PASSTHROUGH] = TRUE;
2694 TRACE_(d3d_caps)("FOUND: WGL_WINE_pixel_format_passthrough support\n");
2700 fixup_extensions(gl_info, gl_renderer_str, gl_vendor, card_vendor, device);
2701 init_driver_info(driver_info, card_vendor, device);
2702 add_gl_compat_wrappers(gl_info);
2707 /**********************************************************
2708 * IWineD3D implementation follows
2709 **********************************************************/
2711 static UINT WINAPI IWineD3DImpl_GetAdapterCount (IWineD3D *iface) {
2712 IWineD3DImpl *This = (IWineD3DImpl *)iface;
2714 TRACE_(d3d_caps)("(%p): Reporting %u adapters\n", This, This->adapter_count);
2716 return This->adapter_count;
2719 static HRESULT WINAPI IWineD3DImpl_RegisterSoftwareDevice(IWineD3D *iface, void *init_function)
2721 FIXME("iface %p, init_function %p stub!\n", iface, init_function);
2726 static HMONITOR WINAPI IWineD3DImpl_GetAdapterMonitor(IWineD3D *iface, UINT Adapter) {
2727 IWineD3DImpl *This = (IWineD3DImpl *)iface;
2729 TRACE_(d3d_caps)("(%p)->(%d)\n", This, Adapter);
2731 if (Adapter >= IWineD3DImpl_GetAdapterCount(iface)) {
2735 return MonitorFromPoint(This->adapters[Adapter].monitorPoint, MONITOR_DEFAULTTOPRIMARY);
2738 /* FIXME: GetAdapterModeCount and EnumAdapterModes currently only returns modes
2739 of the same bpp but different resolutions */
2741 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */
2742 static UINT WINAPI IWineD3DImpl_GetAdapterModeCount(IWineD3D *iface, UINT Adapter, WINED3DFORMAT Format) {
2743 IWineD3DImpl *This = (IWineD3DImpl *)iface;
2744 TRACE_(d3d_caps)("(%p}->(Adapter: %d, Format: %s)\n", This, Adapter, debug_d3dformat(Format));
2746 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
2750 /* TODO: Store modes per adapter and read it from the adapter structure */
2751 if (Adapter == 0) { /* Display */
2752 const struct wined3d_format_desc *format_desc = getFormatDescEntry(Format, &This->adapters[Adapter].gl_info);
2753 UINT format_bits = format_desc->byte_count * CHAR_BIT;
2758 memset(&mode, 0, sizeof(mode));
2759 mode.dmSize = sizeof(mode);
2761 while (EnumDisplaySettingsExW(NULL, j, &mode, 0))
2765 if (Format == WINED3DFMT_UNKNOWN)
2767 /* This is for D3D8, do not enumerate P8 here */
2768 if (mode.dmBitsPerPel == 32 || mode.dmBitsPerPel == 16) ++i;
2770 else if (mode.dmBitsPerPel == format_bits)
2776 TRACE_(d3d_caps)("(%p}->(Adapter: %d) => %d (out of %d)\n", This, Adapter, i, j);
2779 FIXME_(d3d_caps)("Adapter not primary display\n");
2784 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */
2785 static HRESULT WINAPI IWineD3DImpl_EnumAdapterModes(IWineD3D *iface, UINT Adapter, WINED3DFORMAT Format, UINT Mode, WINED3DDISPLAYMODE* pMode) {
2786 IWineD3DImpl *This = (IWineD3DImpl *)iface;
2787 TRACE_(d3d_caps)("(%p}->(Adapter:%d, mode:%d, pMode:%p, format:%s)\n", This, Adapter, Mode, pMode, debug_d3dformat(Format));
2789 /* Validate the parameters as much as possible */
2790 if (NULL == pMode ||
2791 Adapter >= IWineD3DImpl_GetAdapterCount(iface) ||
2792 Mode >= IWineD3DImpl_GetAdapterModeCount(iface, Adapter, Format)) {
2793 return WINED3DERR_INVALIDCALL;
2796 /* TODO: Store modes per adapter and read it from the adapter structure */
2799 const struct wined3d_format_desc *format_desc = getFormatDescEntry(Format, &This->adapters[Adapter].gl_info);
2800 UINT format_bits = format_desc->byte_count * CHAR_BIT;
2806 ZeroMemory(&DevModeW, sizeof(DevModeW));
2807 DevModeW.dmSize = sizeof(DevModeW);
2809 /* If we are filtering to a specific format (D3D9), then need to skip
2810 all unrelated modes, but if mode is irrelevant (D3D8), then we can
2811 just count through the ones with valid bit depths */
2812 while ((i<=Mode) && EnumDisplaySettingsExW(NULL, j++, &DevModeW, 0))
2814 if (Format == WINED3DFMT_UNKNOWN)
2816 /* This is for D3D8, do not enumerate P8 here */
2817 if (DevModeW.dmBitsPerPel == 32 || DevModeW.dmBitsPerPel == 16) ++i;
2819 else if (DevModeW.dmBitsPerPel == format_bits)
2826 TRACE_(d3d_caps)("No modes found for format (%x - %s)\n", Format, debug_d3dformat(Format));
2827 return WINED3DERR_INVALIDCALL;
2831 /* Now get the display mode via the calculated index */
2832 if (EnumDisplaySettingsExW(NULL, ModeIdx, &DevModeW, 0)) {
2833 pMode->Width = DevModeW.dmPelsWidth;
2834 pMode->Height = DevModeW.dmPelsHeight;
2835 pMode->RefreshRate = DEFAULT_REFRESH_RATE;
2836 if (DevModeW.dmFields & DM_DISPLAYFREQUENCY)
2837 pMode->RefreshRate = DevModeW.dmDisplayFrequency;
2839 if (Format == WINED3DFMT_UNKNOWN) {
2840 pMode->Format = pixelformat_for_depth(DevModeW.dmBitsPerPel);
2842 pMode->Format = Format;
2845 TRACE_(d3d_caps)("Requested mode out of range %d\n", Mode);
2846 return WINED3DERR_INVALIDCALL;
2849 TRACE_(d3d_caps)("W %d H %d rr %d fmt (%x - %s) bpp %u\n", pMode->Width, pMode->Height,
2850 pMode->RefreshRate, pMode->Format, debug_d3dformat(pMode->Format),
2851 DevModeW.dmBitsPerPel);
2856 FIXME_(d3d_caps)("Adapter not primary display\n");
2862 static HRESULT WINAPI IWineD3DImpl_GetAdapterDisplayMode(IWineD3D *iface, UINT Adapter, WINED3DDISPLAYMODE *pMode)
2864 TRACE("iface %p, adapter_idx %u, display_mode %p.\n", iface, Adapter, pMode);
2866 if (NULL == pMode ||
2867 Adapter >= IWineD3D_GetAdapterCount(iface)) {
2868 return WINED3DERR_INVALIDCALL;
2871 if (Adapter == 0) { /* Display */
2875 ZeroMemory(&DevModeW, sizeof(DevModeW));
2876 DevModeW.dmSize = sizeof(DevModeW);
2878 EnumDisplaySettingsExW(NULL, ENUM_CURRENT_SETTINGS, &DevModeW, 0);
2879 pMode->Width = DevModeW.dmPelsWidth;
2880 pMode->Height = DevModeW.dmPelsHeight;
2881 bpp = DevModeW.dmBitsPerPel;
2882 pMode->RefreshRate = DEFAULT_REFRESH_RATE;
2883 if (DevModeW.dmFields&DM_DISPLAYFREQUENCY)
2885 pMode->RefreshRate = DevModeW.dmDisplayFrequency;
2888 pMode->Format = pixelformat_for_depth(bpp);
2890 FIXME_(d3d_caps)("Adapter not primary display\n");
2893 TRACE_(d3d_caps)("returning w:%d, h:%d, ref:%d, fmt:%s\n", pMode->Width,
2894 pMode->Height, pMode->RefreshRate, debug_d3dformat(pMode->Format));
2898 /* NOTE: due to structure differences between dx8 and dx9 D3DADAPTER_IDENTIFIER,
2899 and fields being inserted in the middle, a new structure is used in place */
2900 static HRESULT WINAPI IWineD3DImpl_GetAdapterIdentifier(IWineD3D *iface, UINT Adapter, DWORD Flags,
2901 WINED3DADAPTER_IDENTIFIER* pIdentifier) {
2902 IWineD3DImpl *This = (IWineD3DImpl *)iface;
2903 struct wined3d_adapter *adapter;
2906 TRACE_(d3d_caps)("(%p}->(Adapter: %d, Flags: %x, pId=%p)\n", This, Adapter, Flags, pIdentifier);
2908 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
2909 return WINED3DERR_INVALIDCALL;
2912 adapter = &This->adapters[Adapter];
2914 /* Return the information requested */
2915 TRACE_(d3d_caps)("device/Vendor Name and Version detection using FillGLCaps\n");
2917 if (pIdentifier->driver_size)
2919 const char *name = adapter->driver_info.name;
2920 len = min(strlen(name), pIdentifier->driver_size - 1);
2921 memcpy(pIdentifier->driver, name, len);
2922 pIdentifier->driver[len] = '\0';
2925 if (pIdentifier->description_size)
2927 const char *description = adapter->driver_info.description;
2928 len = min(strlen(description), pIdentifier->description_size - 1);
2929 memcpy(pIdentifier->description, description, len);
2930 pIdentifier->description[len] = '\0';
2933 /* Note that d3d8 doesn't supply a device name. */
2934 if (pIdentifier->device_name_size)
2936 static const char *device_name = "\\\\.\\DISPLAY1"; /* FIXME: May depend on desktop? */
2938 len = strlen(device_name);
2939 if (len >= pIdentifier->device_name_size)
2941 ERR("Device name size too small.\n");
2942 return WINED3DERR_INVALIDCALL;
2945 memcpy(pIdentifier->device_name, device_name, len);
2946 pIdentifier->device_name[len] = '\0';
2949 pIdentifier->driver_version.u.HighPart = adapter->driver_info.version_high;
2950 pIdentifier->driver_version.u.LowPart = adapter->driver_info.version_low;
2951 pIdentifier->vendor_id = adapter->driver_info.vendor;
2952 pIdentifier->device_id = adapter->driver_info.device;
2953 pIdentifier->subsystem_id = 0;
2954 pIdentifier->revision = 0;
2955 memcpy(&pIdentifier->device_identifier, &IID_D3DDEVICE_D3DUID, sizeof(pIdentifier->device_identifier));
2956 pIdentifier->whql_level = (Flags & WINED3DENUM_NO_WHQL_LEVEL) ? 0 : 1;
2957 memcpy(&pIdentifier->adapter_luid, &adapter->luid, sizeof(pIdentifier->adapter_luid));
2958 pIdentifier->video_memory = adapter->TextureRam;
2963 static BOOL IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(const struct wined3d_gl_info *gl_info,
2964 const WineD3D_PixelFormat *cfg, const struct wined3d_format_desc *format_desc)
2966 short redSize, greenSize, blueSize, alphaSize, colorBits;
2971 /* Float formats need FBOs. If FBOs are used this function isn't called */
2972 if (format_desc->Flags & WINED3DFMT_FLAG_FLOAT) return FALSE;
2974 if(cfg->iPixelType == WGL_TYPE_RGBA_ARB) { /* Integer RGBA formats */
2975 if (!getColorBits(format_desc, &redSize, &greenSize, &blueSize, &alphaSize, &colorBits))
2977 ERR("Unable to check compatibility for Format=%s\n", debug_d3dformat(format_desc->format));
2981 if(cfg->redSize < redSize)
2984 if(cfg->greenSize < greenSize)
2987 if(cfg->blueSize < blueSize)
2990 if(cfg->alphaSize < alphaSize)
2996 /* Probably a RGBA_float or color index mode */
3000 static BOOL IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(const struct wined3d_gl_info *gl_info,
3001 const WineD3D_PixelFormat *cfg, const struct wined3d_format_desc *format_desc)
3003 short depthSize, stencilSize;
3004 BOOL lockable = FALSE;
3009 if (!getDepthStencilBits(format_desc, &depthSize, &stencilSize))
3011 ERR("Unable to check compatibility for Format=%s\n", debug_d3dformat(format_desc->format));
3015 /* Float formats need FBOs. If FBOs are used this function isn't called */
3016 if (format_desc->Flags & WINED3DFMT_FLAG_FLOAT) return FALSE;
3018 if ((format_desc->format == WINED3DFMT_D16_LOCKABLE) || (format_desc->format == WINED3DFMT_D32_FLOAT))
3021 /* On some modern cards like the Geforce8/9 GLX doesn't offer some dephthstencil formats which D3D9 reports.
3022 * We can safely report 'compatible' formats (e.g. D24 can be used for D16) as long as we aren't dealing with
3023 * a lockable format. This also helps D3D <= 7 as they expect D16 which isn't offered without this on Geforce8 cards. */
3024 if(!(cfg->depthSize == depthSize || (!lockable && cfg->depthSize > depthSize)))
3027 /* Some cards like Intel i915 ones only offer D24S8 but lots of games also need a format without stencil, so
3028 * allow more stencil bits than requested. */
3029 if(cfg->stencilSize < stencilSize)
3035 static HRESULT WINAPI IWineD3DImpl_CheckDepthStencilMatch(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
3036 WINED3DFORMAT AdapterFormat,
3037 WINED3DFORMAT RenderTargetFormat,
3038 WINED3DFORMAT DepthStencilFormat) {
3039 IWineD3DImpl *This = (IWineD3DImpl *)iface;
3041 const WineD3D_PixelFormat *cfgs;
3042 const struct wined3d_adapter *adapter;
3043 const struct wined3d_format_desc *rt_format_desc;
3044 const struct wined3d_format_desc *ds_format_desc;
3047 WARN_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, DevType:(%x,%s), AdptFmt:(%x,%s), RendrTgtFmt:(%x,%s), DepthStencilFmt:(%x,%s))\n",
3049 DeviceType, debug_d3ddevicetype(DeviceType),
3050 AdapterFormat, debug_d3dformat(AdapterFormat),
3051 RenderTargetFormat, debug_d3dformat(RenderTargetFormat),
3052 DepthStencilFormat, debug_d3dformat(DepthStencilFormat));
3054 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
3055 TRACE("(%p) Failed: Atapter (%u) higher than supported adapters (%u) returning WINED3DERR_INVALIDCALL\n", This, Adapter, IWineD3D_GetAdapterCount(iface));
3056 return WINED3DERR_INVALIDCALL;
3059 adapter = &This->adapters[Adapter];
3060 rt_format_desc = getFormatDescEntry(RenderTargetFormat, &adapter->gl_info);
3061 ds_format_desc = getFormatDescEntry(DepthStencilFormat, &adapter->gl_info);
3062 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
3064 if ((rt_format_desc->Flags & WINED3DFMT_FLAG_RENDERTARGET) &&
3065 (ds_format_desc->Flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL))) {
3066 TRACE_(d3d_caps)("(%p) : Formats matched\n", This);
3072 cfgs = adapter->cfgs;
3073 nCfgs = adapter->nCfgs;
3074 for (it = 0; it < nCfgs; ++it) {
3075 if (IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&adapter->gl_info, &cfgs[it], rt_format_desc))
3077 if (IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&adapter->gl_info, &cfgs[it], ds_format_desc))
3079 TRACE_(d3d_caps)("(%p) : Formats matched\n", This);
3085 WARN_(d3d_caps)("unsupported format pair: %s and %s\n", debug_d3dformat(RenderTargetFormat), debug_d3dformat(DepthStencilFormat));
3087 return WINED3DERR_NOTAVAILABLE;
3090 static HRESULT WINAPI IWineD3DImpl_CheckDeviceMultiSampleType(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
3091 WINED3DFORMAT SurfaceFormat, BOOL Windowed, WINED3DMULTISAMPLE_TYPE MultiSampleType, DWORD *pQualityLevels)
3093 IWineD3DImpl *This = (IWineD3DImpl *)iface;
3094 const struct wined3d_format_desc *glDesc;
3095 const struct wined3d_adapter *adapter;
3097 TRACE_(d3d_caps)("(%p)-> (Adptr:%d, DevType:(%x,%s), SurfFmt:(%x,%s), Win?%d, MultiSamp:%x, pQual:%p)\n",
3100 DeviceType, debug_d3ddevicetype(DeviceType),
3101 SurfaceFormat, debug_d3dformat(SurfaceFormat),
3106 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
3107 return WINED3DERR_INVALIDCALL;
3110 /* TODO: handle Windowed, add more quality levels */
3112 if (WINED3DMULTISAMPLE_NONE == MultiSampleType) {
3113 if(pQualityLevels) *pQualityLevels = 1;
3117 /* By default multisampling is disabled right now as it causes issues
3118 * on some Nvidia driver versions and it doesn't work well in combination
3120 if(!wined3d_settings.allow_multisampling)
3121 return WINED3DERR_NOTAVAILABLE;
3123 adapter = &This->adapters[Adapter];
3124 glDesc = getFormatDescEntry(SurfaceFormat, &adapter->gl_info);
3125 if (!glDesc) return WINED3DERR_INVALIDCALL;
3127 if(glDesc->Flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL)) {
3129 const WineD3D_PixelFormat *cfgs;
3131 cfgs = adapter->cfgs;
3132 nCfgs = adapter->nCfgs;
3133 for(i=0; i<nCfgs; i++) {
3134 if(cfgs[i].numSamples != MultiSampleType)
3137 if (!IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&adapter->gl_info, &cfgs[i], glDesc))
3140 TRACE("Found iPixelFormat=%d to support MultiSampleType=%d for format %s\n", cfgs[i].iPixelFormat, MultiSampleType, debug_d3dformat(SurfaceFormat));
3143 *pQualityLevels = 1; /* Guess at a value! */
3147 else if(glDesc->Flags & WINED3DFMT_FLAG_RENDERTARGET) {
3148 short redSize, greenSize, blueSize, alphaSize, colorBits;
3150 const WineD3D_PixelFormat *cfgs;
3152 if (!getColorBits(glDesc, &redSize, &greenSize, &blueSize, &alphaSize, &colorBits))
3154 ERR("Unable to color bits for format %#x, can't check multisampling capability!\n", SurfaceFormat);
3155 return WINED3DERR_NOTAVAILABLE;
3158 cfgs = adapter->cfgs;
3159 nCfgs = adapter->nCfgs;
3160 for(i=0; i<nCfgs; i++) {
3161 if(cfgs[i].numSamples != MultiSampleType)
3163 if(cfgs[i].redSize != redSize)
3165 if(cfgs[i].greenSize != greenSize)
3167 if(cfgs[i].blueSize != blueSize)
3169 /* Not all drivers report alpha-less formats since they use 32-bit anyway, so accept alpha even if we didn't ask for it. */
3170 if(alphaSize && cfgs[i].alphaSize != alphaSize)
3172 if(cfgs[i].colorSize != (glDesc->byte_count << 3))
3175 TRACE("Found iPixelFormat=%d to support MultiSampleType=%d for format %s\n", cfgs[i].iPixelFormat, MultiSampleType, debug_d3dformat(SurfaceFormat));
3178 *pQualityLevels = 1; /* Guess at a value! */
3182 return WINED3DERR_NOTAVAILABLE;
3185 static HRESULT WINAPI IWineD3DImpl_CheckDeviceType(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
3186 WINED3DFORMAT DisplayFormat, WINED3DFORMAT BackBufferFormat, BOOL Windowed)
3188 HRESULT hr = WINED3DERR_NOTAVAILABLE;
3191 TRACE("iface %p, adapter_idx %u, device_type %s, display_format %s, backbuffer_format %s, windowed %#x.\n",
3192 iface, Adapter, debug_d3ddevicetype(DeviceType), debug_d3dformat(DisplayFormat),
3193 debug_d3dformat(BackBufferFormat), Windowed);
3195 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
3196 WARN_(d3d_caps)("Adapter >= IWineD3D_GetAdapterCount(iface), returning WINED3DERR_INVALIDCALL\n");
3197 return WINED3DERR_INVALIDCALL;
3200 /* The task of this function is to check whether a certain display / backbuffer format
3201 * combination is available on the given adapter. In fullscreen mode microsoft specified
3202 * that the display format shouldn't provide alpha and that ignoring alpha the backbuffer
3203 * and display format should match exactly.
3204 * In windowed mode format conversion can occur and this depends on the driver. When format
3205 * conversion is done, this function should nevertheless fail and applications need to use
3206 * CheckDeviceFormatConversion.
3207 * At the moment we assume that fullscreen and windowed have the same capabilities */
3209 /* There are only 4 display formats */
3210 if (!(DisplayFormat == WINED3DFMT_B5G6R5_UNORM
3211 || DisplayFormat == WINED3DFMT_B5G5R5X1_UNORM
3212 || DisplayFormat == WINED3DFMT_B8G8R8X8_UNORM
3213 || DisplayFormat == WINED3DFMT_B10G10R10A2_UNORM))
3215 TRACE_(d3d_caps)("Format %s unsupported as display format\n", debug_d3dformat(DisplayFormat));
3216 return WINED3DERR_NOTAVAILABLE;
3219 /* If the requested DisplayFormat is not available, don't continue */
3220 nmodes = IWineD3DImpl_GetAdapterModeCount(iface, Adapter, DisplayFormat);
3222 TRACE_(d3d_caps)("No available modes for display format %s\n", debug_d3dformat(DisplayFormat));
3223 return WINED3DERR_NOTAVAILABLE;
3226 /* Windowed mode allows you to specify WINED3DFMT_UNKNOWN for the backbufferformat, it means 'reuse' the display format for the backbuffer */
3227 if(!Windowed && BackBufferFormat == WINED3DFMT_UNKNOWN) {
3228 TRACE_(d3d_caps)("BackBufferFormat WINED3FMT_UNKNOWN not available in Windowed mode\n");
3229 return WINED3DERR_NOTAVAILABLE;
3232 /* In FULLSCREEN mode R5G6B5 can only be mixed with backbuffer format R5G6B5 */
3233 if (DisplayFormat == WINED3DFMT_B5G6R5_UNORM && BackBufferFormat != WINED3DFMT_B5G6R5_UNORM)
3235 TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat), debug_d3dformat(BackBufferFormat));
3236 return WINED3DERR_NOTAVAILABLE;
3239 /* In FULLSCREEN mode X1R5G5B5 can only be mixed with backbuffer format *1R5G5B5 */
3240 if (DisplayFormat == WINED3DFMT_B5G5R5X1_UNORM
3241 && !(BackBufferFormat == WINED3DFMT_B5G5R5X1_UNORM || BackBufferFormat == WINED3DFMT_B5G5R5A1_UNORM))
3243 TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat), debug_d3dformat(BackBufferFormat));
3244 return WINED3DERR_NOTAVAILABLE;
3247 /* In FULLSCREEN mode X8R8G8B8 can only be mixed with backbuffer format *8R8G8B8 */
3248 if (DisplayFormat == WINED3DFMT_B8G8R8X8_UNORM
3249 && !(BackBufferFormat == WINED3DFMT_B8G8R8X8_UNORM || BackBufferFormat == WINED3DFMT_B8G8R8A8_UNORM))
3251 TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat), debug_d3dformat(BackBufferFormat));
3252 return WINED3DERR_NOTAVAILABLE;
3255 /* A2R10G10B10 is only allowed in fullscreen mode and it can only be mixed with backbuffer format A2R10G10B10 */
3256 if (DisplayFormat == WINED3DFMT_B10G10R10A2_UNORM
3257 && (BackBufferFormat != WINED3DFMT_B10G10R10A2_UNORM || Windowed))
3259 TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat), debug_d3dformat(BackBufferFormat));
3260 return WINED3DERR_NOTAVAILABLE;
3263 /* Use CheckDeviceFormat to see if the BackBufferFormat is usable with the given DisplayFormat */
3264 hr = IWineD3DImpl_CheckDeviceFormat(iface, Adapter, DeviceType, DisplayFormat, WINED3DUSAGE_RENDERTARGET, WINED3DRTYPE_SURFACE, BackBufferFormat, SURFACE_OPENGL);
3266 TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat), debug_d3dformat(BackBufferFormat));
3272 /* Check if we support bumpmapping for a format */
3273 static BOOL CheckBumpMapCapability(struct wined3d_adapter *adapter, const struct wined3d_format_desc *format_desc)
3275 /* Ask the fixed function pipeline implementation if it can deal
3276 * with the conversion. If we've got a GL extension giving native
3277 * support this will be an identity conversion. */
3278 return (format_desc->Flags & WINED3DFMT_FLAG_BUMPMAP)
3279 && adapter->fragment_pipe->color_fixup_supported(format_desc->color_fixup);
3282 /* Check if the given DisplayFormat + DepthStencilFormat combination is valid for the Adapter */
3283 static BOOL CheckDepthStencilCapability(struct wined3d_adapter *adapter,
3284 const struct wined3d_format_desc *display_format_desc, const struct wined3d_format_desc *ds_format_desc)
3288 /* Only allow depth/stencil formats */
3289 if (!(ds_format_desc->depth_size || ds_format_desc->stencil_size)) return FALSE;
3291 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
3293 /* With FBOs WGL limitations do not apply, but the format needs to be FBO attachable */
3294 if (ds_format_desc->Flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL)) return TRUE;
3298 /* Walk through all WGL pixel formats to find a match */
3299 for (it = 0; it < adapter->nCfgs; ++it)
3301 WineD3D_PixelFormat *cfg = &adapter->cfgs[it];
3302 if (IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&adapter->gl_info, cfg, display_format_desc))
3304 if (IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&adapter->gl_info, cfg, ds_format_desc))
3315 static BOOL CheckFilterCapability(struct wined3d_adapter *adapter, const struct wined3d_format_desc *format_desc)
3317 /* The flags entry of a format contains the filtering capability */
3318 if (format_desc->Flags & WINED3DFMT_FLAG_FILTERING) return TRUE;
3323 /* Check the render target capabilities of a format */
3324 static BOOL CheckRenderTargetCapability(struct wined3d_adapter *adapter,
3325 const struct wined3d_format_desc *adapter_format_desc, const struct wined3d_format_desc *check_format_desc)
3327 /* Filter out non-RT formats */
3328 if (!(check_format_desc->Flags & WINED3DFMT_FLAG_RENDERTARGET)) return FALSE;
3329 if(wined3d_settings.offscreen_rendering_mode == ORM_BACKBUFFER) {
3330 WineD3D_PixelFormat *cfgs = adapter->cfgs;
3332 short AdapterRed, AdapterGreen, AdapterBlue, AdapterAlpha, AdapterTotalSize;
3333 short CheckRed, CheckGreen, CheckBlue, CheckAlpha, CheckTotalSize;
3335 getColorBits(adapter_format_desc, &AdapterRed, &AdapterGreen, &AdapterBlue, &AdapterAlpha, &AdapterTotalSize);
3336 getColorBits(check_format_desc, &CheckRed, &CheckGreen, &CheckBlue, &CheckAlpha, &CheckTotalSize);
3338 /* In backbuffer mode the front and backbuffer share the same WGL pixelformat.
3339 * The format must match in RGB, alpha is allowed to be different. (Only the backbuffer can have alpha) */
3340 if(!((AdapterRed == CheckRed) && (AdapterGreen == CheckGreen) && (AdapterBlue == CheckBlue))) {
3341 TRACE_(d3d_caps)("[FAILED]\n");
3345 /* Check if there is a WGL pixel format matching the requirements, the format should also be window
3346 * drawable (not offscreen; e.g. Nvidia offers R5G6B5 for pbuffers even when X is running at 24bit) */
3347 for (it = 0; it < adapter->nCfgs; ++it)
3349 if (cfgs[it].windowDrawable && IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&adapter->gl_info,
3350 &cfgs[it], check_format_desc))
3352 TRACE_(d3d_caps)("iPixelFormat=%d is compatible with CheckFormat=%s\n",
3353 cfgs[it].iPixelFormat, debug_d3dformat(check_format_desc->format));
3358 else if(wined3d_settings.offscreen_rendering_mode == ORM_FBO)
3360 /* For now return TRUE for FBOs until we have some proper checks.
3361 * Note that this function will only be called when the format is around for texturing. */
3367 static BOOL CheckSrgbReadCapability(struct wined3d_adapter *adapter, const struct wined3d_format_desc *format_desc)
3369 return adapter->gl_info.supported[EXT_TEXTURE_SRGB]
3370 && (format_desc->Flags & WINED3DFMT_FLAG_SRGB_READ);
3373 static BOOL CheckSrgbWriteCapability(struct wined3d_adapter *adapter, const struct wined3d_format_desc *format_desc)
3375 /* Only offer SRGB writing on X8R8G8B8/A8R8G8B8 when we use ARB or GLSL shaders as we are
3376 * doing the color fixup in shaders.
3377 * Note Windows drivers (at least on the Geforce 8800) also offer this on R5G6B5. */
3378 if (format_desc->Flags & WINED3DFMT_FLAG_SRGB_WRITE)
3380 int vs_selected_mode;
3381 int ps_selected_mode;
3382 select_shader_mode(&adapter->gl_info, &ps_selected_mode, &vs_selected_mode);
3384 if((ps_selected_mode == SHADER_ARB) || (ps_selected_mode == SHADER_GLSL)) {
3385 TRACE_(d3d_caps)("[OK]\n");
3390 TRACE_(d3d_caps)("[FAILED] - no SRGB writing support on format=%s\n", debug_d3dformat(format_desc->format));
3394 /* Check if a format support blending in combination with pixel shaders */
3395 static BOOL CheckPostPixelShaderBlendingCapability(struct wined3d_adapter *adapter,
3396 const struct wined3d_format_desc *format_desc)
3398 /* The flags entry of a format contains the post pixel shader blending capability */
3399 if (format_desc->Flags & WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING) return TRUE;
3404 static BOOL CheckWrapAndMipCapability(struct wined3d_adapter *adapter, const struct wined3d_format_desc *format_desc)
3406 /* OpenGL supports mipmapping on all formats basically. Wrapping is unsupported,
3407 * but we have to report mipmapping so we cannot reject this flag. Tests show that
3408 * windows reports WRAPANDMIP on unfilterable surfaces as well, apparently to show
3409 * that wrapping is supported. The lack of filtering will sort out the mipmapping
3410 * capability anyway.
3412 * For now lets report this on all formats, but in the future we may want to
3413 * restrict it to some should games need that
3418 /* Check if a texture format is supported on the given adapter */
3419 static BOOL CheckTextureCapability(struct wined3d_adapter *adapter, const struct wined3d_format_desc *format_desc)
3421 const struct wined3d_gl_info *gl_info = &adapter->gl_info;
3423 switch (format_desc->format)
3426 * supported: RGB(A) formats
3428 case WINED3DFMT_B8G8R8_UNORM: /* Enable for dx7, blacklisted for 8 and 9 above */
3429 case WINED3DFMT_B8G8R8A8_UNORM:
3430 case WINED3DFMT_B8G8R8X8_UNORM:
3431 case WINED3DFMT_B5G6R5_UNORM:
3432 case WINED3DFMT_B5G5R5X1_UNORM:
3433 case WINED3DFMT_B5G5R5A1_UNORM:
3434 case WINED3DFMT_B4G4R4A4_UNORM:
3435 case WINED3DFMT_A8_UNORM:
3436 case WINED3DFMT_B4G4R4X4_UNORM:
3437 case WINED3DFMT_R8G8B8A8_UNORM:
3438 case WINED3DFMT_R8G8B8X8_UNORM:
3439 case WINED3DFMT_B10G10R10A2_UNORM:
3440 case WINED3DFMT_R10G10B10A2_UNORM:
3441 case WINED3DFMT_R16G16_UNORM:
3442 TRACE_(d3d_caps)("[OK]\n");
3445 case WINED3DFMT_B2G3R3_UNORM:
3446 TRACE_(d3d_caps)("[FAILED] - Not supported on Windows\n");
3450 * Not supported: Palettized
3451 * Only some Geforce/Voodoo3/G400 cards offer 8-bit textures in case of <=Direct3D7.
3452 * Since it is not widely available, don't offer it. Further no Windows driver offers
3453 * WINED3DFMT_P8_UINT_A8_NORM, so don't offer it either.
3455 case WINED3DFMT_P8_UINT:
3456 case WINED3DFMT_P8_UINT_A8_UNORM:
3460 * Supported: (Alpha)-Luminance
3462 case WINED3DFMT_L8_UNORM:
3463 case WINED3DFMT_L8A8_UNORM:
3464 case WINED3DFMT_L16_UNORM:
3465 TRACE_(d3d_caps)("[OK]\n");
3468 /* Not supported on Windows, thus disabled */
3469 case WINED3DFMT_L4A4_UNORM:
3470 TRACE_(d3d_caps)("[FAILED] - not supported on windows\n");
3474 * Supported: Depth/Stencil formats
3476 case WINED3DFMT_D16_LOCKABLE:
3477 case WINED3DFMT_D16_UNORM:
3478 case WINED3DFMT_S1_UINT_D15_UNORM:
3479 case WINED3DFMT_X8D24_UNORM:
3480 case WINED3DFMT_S4X4_UINT_D24_UNORM:
3481 case WINED3DFMT_D24_UNORM_S8_UINT:
3482 case WINED3DFMT_S8_UINT_D24_FLOAT:
3483 case WINED3DFMT_D32_UNORM:
3484 case WINED3DFMT_D32_FLOAT:
3488 * Not supported everywhere(depends on GL_ATI_envmap_bumpmap or
3489 * GL_NV_texture_shader). Emulated by shaders
3491 case WINED3DFMT_R8G8_SNORM:
3492 case WINED3DFMT_R8G8_SNORM_L8X8_UNORM:
3493 case WINED3DFMT_R5G5_SNORM_L6_UNORM:
3494 case WINED3DFMT_R8G8B8A8_SNORM:
3495 case WINED3DFMT_R16G16_SNORM:
3496 /* Ask the shader backend if it can deal with the conversion. If
3497 * we've got a GL extension giving native support this will be an
3498 * identity conversion. */
3499 if (adapter->shader_backend->shader_color_fixup_supported(format_desc->color_fixup))
3501 TRACE_(d3d_caps)("[OK]\n");
3504 TRACE_(d3d_caps)("[FAILED]\n");
3507 case WINED3DFMT_DXT1:
3508 case WINED3DFMT_DXT2:
3509 case WINED3DFMT_DXT3:
3510 case WINED3DFMT_DXT4:
3511 case WINED3DFMT_DXT5:
3512 if (gl_info->supported[EXT_TEXTURE_COMPRESSION_S3TC])
3514 TRACE_(d3d_caps)("[OK]\n");
3517 TRACE_(d3d_caps)("[FAILED]\n");
3522 * Odd formats - not supported
3524 case WINED3DFMT_VERTEXDATA:
3525 case WINED3DFMT_R16_UINT:
3526 case WINED3DFMT_R32_UINT:
3527 case WINED3DFMT_R16G16B16A16_SNORM:
3528 case WINED3DFMT_R10G10B10_SNORM_A2_UNORM:
3529 case WINED3DFMT_R10G11B11_SNORM:
3530 TRACE_(d3d_caps)("[FAILED]\n"); /* Enable when implemented */
3534 * WINED3DFMT_R8G8_SNORM_Cx: Not supported right now
3536 case WINED3DFMT_R8G8_SNORM_Cx:
3537 TRACE_(d3d_caps)("[FAILED]\n"); /* Enable when implemented */
3541 case WINED3DFMT_UYVY:
3542 case WINED3DFMT_YUY2:
3543 if (gl_info->supported[APPLE_YCBCR_422])
3545 TRACE_(d3d_caps)("[OK]\n");
3548 TRACE_(d3d_caps)("[FAILED]\n");
3550 case WINED3DFMT_YV12:
3551 TRACE_(d3d_caps)("[FAILED]\n");
3555 case WINED3DFMT_R16G16B16A16_UNORM:
3556 case WINED3DFMT_B2G3R3A8_UNORM:
3557 TRACE_(d3d_caps)("[FAILED]\n"); /* Enable when implemented */
3560 /* Floating point formats */
3561 case WINED3DFMT_R16_FLOAT:
3562 case WINED3DFMT_R16G16_FLOAT:
3563 case WINED3DFMT_R16G16B16A16_FLOAT:
3564 if (gl_info->supported[ARB_TEXTURE_FLOAT] && gl_info->supported[ARB_HALF_FLOAT_PIXEL])
3566 TRACE_(d3d_caps)("[OK]\n");
3569 TRACE_(d3d_caps)("[FAILED]\n");
3572 case WINED3DFMT_R32_FLOAT:
3573 case WINED3DFMT_R32G32_FLOAT:
3574 case WINED3DFMT_R32G32B32A32_FLOAT:
3575 if (gl_info->supported[ARB_TEXTURE_FLOAT])
3577 TRACE_(d3d_caps)("[OK]\n");
3580 TRACE_(d3d_caps)("[FAILED]\n");
3583 /* ATI instancing hack: Although ATI cards do not support Shader Model 3.0, they support
3584 * instancing. To query if the card supports instancing CheckDeviceFormat with the special format
3585 * MAKEFOURCC('I','N','S','T') is used. Should a (broken) app check for this provide a proper return value.
3586 * We can do instancing with all shader versions, but we need vertex shaders.
3588 * Additionally applications have to set the D3DRS_POINTSIZE render state to MAKEFOURCC('I','N','S','T') once
3589 * to enable instancing. WineD3D doesn't need that and just ignores it.
3591 * With Shader Model 3.0 capable cards Instancing 'just works' in Windows.
3593 case WINED3DFMT_INST:
3594 TRACE("ATI Instancing check hack\n");
3595 if (gl_info->supported[ARB_VERTEX_PROGRAM] || gl_info->supported[ARB_VERTEX_SHADER])
3597 TRACE_(d3d_caps)("[OK]\n");
3600 TRACE_(d3d_caps)("[FAILED]\n");
3603 /* Some weird FOURCC formats */
3604 case WINED3DFMT_R8G8_B8G8:
3605 case WINED3DFMT_G8R8_G8B8:
3606 case WINED3DFMT_MULTI2_ARGB8:
3607 TRACE_(d3d_caps)("[FAILED]\n");
3610 /* Vendor specific formats */
3611 case WINED3DFMT_ATI2N:
3612 if (gl_info->supported[ATI_TEXTURE_COMPRESSION_3DC]
3613 || gl_info->supported[EXT_TEXTURE_COMPRESSION_RGTC])
3615 if (adapter->shader_backend->shader_color_fixup_supported(format_desc->color_fixup)
3616 && adapter->fragment_pipe->color_fixup_supported(format_desc->color_fixup))
3618 TRACE_(d3d_caps)("[OK]\n");
3622 TRACE_(d3d_caps)("[OK]\n");
3625 TRACE_(d3d_caps)("[FAILED]\n");
3628 case WINED3DFMT_NVHU:
3629 case WINED3DFMT_NVHS:
3630 /* These formats seem to be similar to the HILO formats in GL_NV_texture_shader. NVHU
3631 * is said to be GL_UNSIGNED_HILO16, NVHS GL_SIGNED_HILO16. Rumours say that d3d computes
3632 * a 3rd channel similarly to D3DFMT_CxV8U8(So NVHS could be called D3DFMT_CxV16U16).
3633 * ATI refused to support formats which can easilly be emulated with pixel shaders, so
3634 * Applications have to deal with not having NVHS and NVHU.
3636 TRACE_(d3d_caps)("[FAILED]\n");
3639 case WINED3DFMT_UNKNOWN:
3643 ERR("Unhandled format=%s\n", debug_d3dformat(format_desc->format));
3649 static BOOL CheckSurfaceCapability(struct wined3d_adapter *adapter,
3650 const struct wined3d_format_desc *adapter_format_desc,
3651 const struct wined3d_format_desc *check_format_desc,
3652 WINED3DSURFTYPE SurfaceType)
3654 if(SurfaceType == SURFACE_GDI) {
3655 switch(check_format_desc->format)
3657 case WINED3DFMT_B8G8R8_UNORM:
3658 case WINED3DFMT_B8G8R8A8_UNORM:
3659 case WINED3DFMT_B8G8R8X8_UNORM:
3660 case WINED3DFMT_B5G6R5_UNORM:
3661 case WINED3DFMT_B5G5R5X1_UNORM:
3662 case WINED3DFMT_B5G5R5A1_UNORM:
3663 case WINED3DFMT_B4G4R4A4_UNORM:
3664 case WINED3DFMT_B2G3R3_UNORM:
3665 case WINED3DFMT_A8_UNORM:
3666 case WINED3DFMT_B2G3R3A8_UNORM:
3667 case WINED3DFMT_B4G4R4X4_UNORM:
3668 case WINED3DFMT_R10G10B10A2_UNORM:
3669 case WINED3DFMT_R8G8B8A8_UNORM:
3670 case WINED3DFMT_R8G8B8X8_UNORM:
3671 case WINED3DFMT_R16G16_UNORM:
3672 case WINED3DFMT_B10G10R10A2_UNORM:
3673 case WINED3DFMT_R16G16B16A16_UNORM:
3674 case WINED3DFMT_P8_UINT:
3675 TRACE_(d3d_caps)("[OK]\n");
3678 TRACE_(d3d_caps)("[FAILED] - not available on GDI surfaces\n");
3683 /* All format that are supported for textures are supported for surfaces as well */
3684 if (CheckTextureCapability(adapter, check_format_desc)) return TRUE;
3685 /* All depth stencil formats are supported on surfaces */
3686 if (CheckDepthStencilCapability(adapter, adapter_format_desc, check_format_desc)) return TRUE;
3688 /* If opengl can't process the format natively, the blitter may be able to convert it */
3689 if (adapter->blitter->blit_supported(&adapter->gl_info, BLIT_OP_BLIT,
3690 NULL, WINED3DPOOL_DEFAULT, 0, check_format_desc,
3691 NULL, WINED3DPOOL_DEFAULT, 0, adapter_format_desc))
3693 TRACE_(d3d_caps)("[OK]\n");
3697 /* Reject other formats */
3698 TRACE_(d3d_caps)("[FAILED]\n");
3702 static BOOL CheckVertexTextureCapability(struct wined3d_adapter *adapter,
3703 const struct wined3d_format_desc *format_desc)
3705 return adapter->gl_info.limits.vertex_samplers
3706 && (format_desc->Flags & WINED3DFMT_FLAG_VTF);
3709 static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
3710 WINED3DFORMAT AdapterFormat, DWORD Usage, WINED3DRESOURCETYPE RType, WINED3DFORMAT CheckFormat,
3711 WINED3DSURFTYPE SurfaceType)
3713 IWineD3DImpl *This = (IWineD3DImpl *)iface;
3714 struct wined3d_adapter *adapter = &This->adapters[Adapter];
3715 const struct wined3d_gl_info *gl_info = &adapter->gl_info;
3716 const struct wined3d_format_desc *format_desc = getFormatDescEntry(CheckFormat, gl_info);
3717 const struct wined3d_format_desc *adapter_format_desc = getFormatDescEntry(AdapterFormat, gl_info);
3718 DWORD UsageCaps = 0;
3720 TRACE_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, DevType:(%u,%s), AdptFmt:(%u,%s), Use:(%u,%s,%s), ResTyp:(%x,%s), CheckFmt:(%u,%s))\n",
3723 DeviceType, debug_d3ddevicetype(DeviceType),
3724 AdapterFormat, debug_d3dformat(AdapterFormat),
3725 Usage, debug_d3dusage(Usage), debug_d3dusagequery(Usage),
3726 RType, debug_d3dresourcetype(RType),
3727 CheckFormat, debug_d3dformat(CheckFormat));
3729 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
3730 return WINED3DERR_INVALIDCALL;
3735 case WINED3DRTYPE_CUBETEXTURE:
3736 /* Cubetexture allows:
3737 * - WINED3DUSAGE_AUTOGENMIPMAP
3738 * - WINED3DUSAGE_DEPTHSTENCIL
3739 * - WINED3DUSAGE_DYNAMIC
3740 * - WINED3DUSAGE_NONSECURE (d3d9ex)
3741 * - WINED3DUSAGE_RENDERTARGET
3742 * - WINED3DUSAGE_SOFTWAREPROCESSING
3743 * - WINED3DUSAGE_QUERY_WRAPANDMIP
3745 if (SurfaceType != SURFACE_OPENGL)
3747 TRACE_(d3d_caps)("[FAILED]\n");
3748 return WINED3DERR_NOTAVAILABLE;
3751 if (!gl_info->supported[ARB_TEXTURE_CUBE_MAP])
3753 TRACE_(d3d_caps)("[FAILED] - No cube texture support\n");
3754 return WINED3DERR_NOTAVAILABLE;
3757 if (!CheckTextureCapability(adapter, format_desc))
3759 TRACE_(d3d_caps)("[FAILED] - Cube texture format not supported\n");
3760 return WINED3DERR_NOTAVAILABLE;
3763 if (Usage & WINED3DUSAGE_AUTOGENMIPMAP)
3765 if (!gl_info->supported[SGIS_GENERATE_MIPMAP])
3766 /* When autogenmipmap isn't around continue and return
3767 * WINED3DOK_NOAUTOGEN instead of D3D_OK. */
3768 TRACE_(d3d_caps)("[FAILED] - No autogenmipmap support, but continuing\n");
3770 UsageCaps |= WINED3DUSAGE_AUTOGENMIPMAP;
3773 /* Always report dynamic locking. */
3774 if (Usage & WINED3DUSAGE_DYNAMIC)
3775 UsageCaps |= WINED3DUSAGE_DYNAMIC;
3777 if (Usage & WINED3DUSAGE_RENDERTARGET)
3779 if (!CheckRenderTargetCapability(adapter, adapter_format_desc, format_desc))
3781 TRACE_(d3d_caps)("[FAILED] - No rendertarget support\n");
3782 return WINED3DERR_NOTAVAILABLE;
3784 UsageCaps |= WINED3DUSAGE_RENDERTARGET;
3787 /* Always report software processing. */
3788 if (Usage & WINED3DUSAGE_SOFTWAREPROCESSING)
3789 UsageCaps |= WINED3DUSAGE_SOFTWAREPROCESSING;
3791 if (Usage & WINED3DUSAGE_QUERY_FILTER)
3793 if (!CheckFilterCapability(adapter, format_desc))
3795 TRACE_(d3d_caps)("[FAILED] - No query filter support\n");
3796 return WINED3DERR_NOTAVAILABLE;
3798 UsageCaps |= WINED3DUSAGE_QUERY_FILTER;
3801 if (Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING)
3803 if (!CheckPostPixelShaderBlendingCapability(adapter, format_desc))
3805 TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
3806 return WINED3DERR_NOTAVAILABLE;
3808 UsageCaps |= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
3811 if (Usage & WINED3DUSAGE_QUERY_SRGBREAD)
3813 if (!CheckSrgbReadCapability(adapter, format_desc))
3815 TRACE_(d3d_caps)("[FAILED] - No query srgbread support\n");
3816 return WINED3DERR_NOTAVAILABLE;
3818 UsageCaps |= WINED3DUSAGE_QUERY_SRGBREAD;
3821 if (Usage & WINED3DUSAGE_QUERY_SRGBWRITE)
3823 if (!CheckSrgbWriteCapability(adapter, format_desc))
3825 TRACE_(d3d_caps)("[FAILED] - No query srgbwrite support\n");
3826 return WINED3DERR_NOTAVAILABLE;
3828 UsageCaps |= WINED3DUSAGE_QUERY_SRGBWRITE;
3831 if (Usage & WINED3DUSAGE_QUERY_VERTEXTEXTURE)
3833 if (!CheckVertexTextureCapability(adapter, format_desc))
3835 TRACE_(d3d_caps)("[FAILED] - No query vertextexture support\n");
3836 return WINED3DERR_NOTAVAILABLE;
3838 UsageCaps |= WINED3DUSAGE_QUERY_VERTEXTEXTURE;
3841 if (Usage & WINED3DUSAGE_QUERY_WRAPANDMIP)
3843 if (!CheckWrapAndMipCapability(adapter, format_desc))
3845 TRACE_(d3d_caps)("[FAILED] - No wrapping and mipmapping support\n");
3846 return WINED3DERR_NOTAVAILABLE;
3848 UsageCaps |= WINED3DUSAGE_QUERY_WRAPANDMIP;
3852 case WINED3DRTYPE_SURFACE:
3854 * - WINED3DUSAGE_DEPTHSTENCIL
3855 * - WINED3DUSAGE_NONSECURE (d3d9ex)
3856 * - WINED3DUSAGE_RENDERTARGET
3858 if (!CheckSurfaceCapability(adapter, adapter_format_desc, format_desc, SurfaceType))
3860 TRACE_(d3d_caps)("[FAILED] - Not supported for plain surfaces\n");
3861 return WINED3DERR_NOTAVAILABLE;
3864 if (Usage & WINED3DUSAGE_DEPTHSTENCIL)
3866 if (!CheckDepthStencilCapability(adapter, adapter_format_desc, format_desc))
3868 TRACE_(d3d_caps)("[FAILED] - No depthstencil support\n");
3869 return WINED3DERR_NOTAVAILABLE;
3871 UsageCaps |= WINED3DUSAGE_DEPTHSTENCIL;
3874 if (Usage & WINED3DUSAGE_RENDERTARGET)
3876 if (!CheckRenderTargetCapability(adapter, adapter_format_desc, format_desc))
3878 TRACE_(d3d_caps)("[FAILED] - No rendertarget support\n");
3879 return WINED3DERR_NOTAVAILABLE;
3881 UsageCaps |= WINED3DUSAGE_RENDERTARGET;
3884 if (Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING)
3886 if (!CheckPostPixelShaderBlendingCapability(adapter, format_desc))
3888 TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
3889 return WINED3DERR_NOTAVAILABLE;
3891 UsageCaps |= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
3895 case WINED3DRTYPE_TEXTURE:
3897 * - WINED3DUSAGE_AUTOGENMIPMAP
3898 * - WINED3DUSAGE_DEPTHSTENCIL
3899 * - WINED3DUSAGE_DMAP
3900 * - WINED3DUSAGE_DYNAMIC
3901 * - WINED3DUSAGE_NONSECURE (d3d9ex)
3902 * - WINED3DUSAGE_RENDERTARGET
3903 * - WINED3DUSAGE_SOFTWAREPROCESSING
3904 * - WINED3DUSAGE_TEXTAPI (d3d9ex)
3905 * - WINED3DUSAGE_QUERY_WRAPANDMIP
3907 if (SurfaceType != SURFACE_OPENGL)
3909 TRACE_(d3d_caps)("[FAILED]\n");
3910 return WINED3DERR_NOTAVAILABLE;
3913 if (!CheckTextureCapability(adapter, format_desc))
3915 TRACE_(d3d_caps)("[FAILED] - Texture format not supported\n");
3916 return WINED3DERR_NOTAVAILABLE;
3919 if (Usage & WINED3DUSAGE_AUTOGENMIPMAP)
3921 if (!gl_info->supported[SGIS_GENERATE_MIPMAP])
3922 /* When autogenmipmap isn't around continue and return
3923 * WINED3DOK_NOAUTOGEN instead of D3D_OK. */
3924 TRACE_(d3d_caps)("[FAILED] - No autogenmipmap support, but continuing\n");
3926 UsageCaps |= WINED3DUSAGE_AUTOGENMIPMAP;
3929 /* Always report dynamic locking. */
3930 if (Usage & WINED3DUSAGE_DYNAMIC)
3931 UsageCaps |= WINED3DUSAGE_DYNAMIC;
3933 if (Usage & WINED3DUSAGE_RENDERTARGET)
3935 if (!CheckRenderTargetCapability(adapter, adapter_format_desc, format_desc))
3937 TRACE_(d3d_caps)("[FAILED] - No rendertarget support\n");
3938 return WINED3DERR_NOTAVAILABLE;
3940 UsageCaps |= WINED3DUSAGE_RENDERTARGET;
3943 /* Always report software processing. */
3944 if (Usage & WINED3DUSAGE_SOFTWAREPROCESSING)
3945 UsageCaps |= WINED3DUSAGE_SOFTWAREPROCESSING;
3947 if (Usage & WINED3DUSAGE_QUERY_FILTER)
3949 if (!CheckFilterCapability(adapter, format_desc))
3951 TRACE_(d3d_caps)("[FAILED] - No query filter support\n");
3952 return WINED3DERR_NOTAVAILABLE;
3954 UsageCaps |= WINED3DUSAGE_QUERY_FILTER;
3957 if (Usage & WINED3DUSAGE_QUERY_LEGACYBUMPMAP)
3959 if (!CheckBumpMapCapability(adapter, format_desc))
3961 TRACE_(d3d_caps)("[FAILED] - No legacy bumpmap support\n");
3962 return WINED3DERR_NOTAVAILABLE;
3964 UsageCaps |= WINED3DUSAGE_QUERY_LEGACYBUMPMAP;
3967 if (Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING)
3969 if (!CheckPostPixelShaderBlendingCapability(adapter, format_desc))
3971 TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
3972 return WINED3DERR_NOTAVAILABLE;
3974 UsageCaps |= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
3977 if (Usage & WINED3DUSAGE_QUERY_SRGBREAD)
3979 if (!CheckSrgbReadCapability(adapter, format_desc))
3981 TRACE_(d3d_caps)("[FAILED] - No query srgbread support\n");
3982 return WINED3DERR_NOTAVAILABLE;
3984 UsageCaps |= WINED3DUSAGE_QUERY_SRGBREAD;
3987 if (Usage & WINED3DUSAGE_QUERY_SRGBWRITE)
3989 if (!CheckSrgbWriteCapability(adapter, format_desc))
3991 TRACE_(d3d_caps)("[FAILED] - No query srgbwrite support\n");
3992 return WINED3DERR_NOTAVAILABLE;
3994 UsageCaps |= WINED3DUSAGE_QUERY_SRGBWRITE;
3997 if (Usage & WINED3DUSAGE_QUERY_VERTEXTEXTURE)
3999 if (!CheckVertexTextureCapability(adapter, format_desc))
4001 TRACE_(d3d_caps)("[FAILED] - No query vertextexture support\n");
4002 return WINED3DERR_NOTAVAILABLE;
4004 UsageCaps |= WINED3DUSAGE_QUERY_VERTEXTEXTURE;
4007 if (Usage & WINED3DUSAGE_QUERY_WRAPANDMIP)
4009 if (!CheckWrapAndMipCapability(adapter, format_desc))
4011 TRACE_(d3d_caps)("[FAILED] - No wrapping and mipmapping support\n");
4012 return WINED3DERR_NOTAVAILABLE;
4014 UsageCaps |= WINED3DUSAGE_QUERY_WRAPANDMIP;
4017 if (Usage & WINED3DUSAGE_DEPTHSTENCIL)
4019 if (!CheckDepthStencilCapability(adapter, adapter_format_desc, format_desc))
4021 TRACE_(d3d_caps)("[FAILED] - No depth stencil support\n");
4022 return WINED3DERR_NOTAVAILABLE;
4024 if ((format_desc->Flags & WINED3DFMT_FLAG_SHADOW) && !gl_info->supported[ARB_SHADOW])
4026 TRACE_(d3d_caps)("[FAILED] - No shadow sampler support.\n");
4027 return WINED3DERR_NOTAVAILABLE;
4029 UsageCaps |= WINED3DUSAGE_DEPTHSTENCIL;
4033 case WINED3DRTYPE_VOLUMETEXTURE:
4034 case WINED3DRTYPE_VOLUME:
4035 /* Volume is to VolumeTexture what Surface is to Texture, but its
4036 * usage caps are not documented. Most driver seem to offer
4037 * (nearly) the same on Volume and VolumeTexture, so do that too.
4039 * Volumetexture allows:
4040 * - D3DUSAGE_DYNAMIC
4041 * - D3DUSAGE_NONSECURE (d3d9ex)
4042 * - D3DUSAGE_SOFTWAREPROCESSING
4043 * - D3DUSAGE_QUERY_WRAPANDMIP
4045 if (SurfaceType != SURFACE_OPENGL)
4047 TRACE_(d3d_caps)("[FAILED]\n");
4048 return WINED3DERR_NOTAVAILABLE;
4051 if (!gl_info->supported[EXT_TEXTURE3D])
4053 TRACE_(d3d_caps)("[FAILED] - No volume texture support\n");
4054 return WINED3DERR_NOTAVAILABLE;
4057 if (!CheckTextureCapability(adapter, format_desc))
4059 TRACE_(d3d_caps)("[FAILED] - Format not supported\n");
4060 return WINED3DERR_NOTAVAILABLE;
4063 /* Filter formats that need conversion; For one part, this
4064 * conversion is unimplemented, and volume textures are huge, so
4065 * it would be a big performance hit. Unless we hit an application
4066 * needing one of those formats, don't advertize them to avoid
4067 * leading applications into temptation. The windows drivers don't
4068 * support most of those formats on volumes anyway, except for
4069 * WINED3DFMT_R32_FLOAT. */
4070 switch (CheckFormat)
4072 case WINED3DFMT_P8_UINT:
4073 case WINED3DFMT_L4A4_UNORM:
4074 case WINED3DFMT_R32_FLOAT:
4075 case WINED3DFMT_R16_FLOAT:
4076 case WINED3DFMT_R8G8_SNORM_L8X8_UNORM:
4077 case WINED3DFMT_R5G5_SNORM_L6_UNORM:
4078 case WINED3DFMT_R16G16_UNORM:
4079 TRACE_(d3d_caps)("[FAILED] - No converted formats on volumes\n");
4080 return WINED3DERR_NOTAVAILABLE;
4082 case WINED3DFMT_R8G8B8A8_SNORM:
4083 case WINED3DFMT_R16G16_SNORM:
4084 if (!gl_info->supported[NV_TEXTURE_SHADER])
4086 TRACE_(d3d_caps)("[FAILED] - No converted formats on volumes\n");
4087 return WINED3DERR_NOTAVAILABLE;
4091 case WINED3DFMT_R8G8_SNORM:
4092 if (!gl_info->supported[NV_TEXTURE_SHADER])
4094 TRACE_(d3d_caps)("[FAILED] - No converted formats on volumes\n");
4095 return WINED3DERR_NOTAVAILABLE;
4099 case WINED3DFMT_DXT1:
4100 case WINED3DFMT_DXT2:
4101 case WINED3DFMT_DXT3:
4102 case WINED3DFMT_DXT4:
4103 case WINED3DFMT_DXT5:
4104 /* The GL_EXT_texture_compression_s3tc spec requires that
4105 * loading an s3tc compressed texture results in an error.
4106 * While the D3D refrast does support s3tc volumes, at
4107 * least the nvidia windows driver does not, so we're free
4108 * not to support this format. */
4109 TRACE_(d3d_caps)("[FAILED] - DXTn does not support 3D textures\n");
4110 return WINED3DERR_NOTAVAILABLE;
4113 /* Do nothing, continue with checking the format below */
4117 /* Always report dynamic locking. */
4118 if (Usage & WINED3DUSAGE_DYNAMIC)
4119 UsageCaps |= WINED3DUSAGE_DYNAMIC;
4121 /* Always report software processing. */
4122 if (Usage & WINED3DUSAGE_SOFTWAREPROCESSING)
4123 UsageCaps |= WINED3DUSAGE_SOFTWAREPROCESSING;
4125 if (Usage & WINED3DUSAGE_QUERY_FILTER)
4127 if (!CheckFilterCapability(adapter, format_desc))
4129 TRACE_(d3d_caps)("[FAILED] - No query filter support\n");
4130 return WINED3DERR_NOTAVAILABLE;
4132 UsageCaps |= WINED3DUSAGE_QUERY_FILTER;
4135 if (Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING)
4137 if (!CheckPostPixelShaderBlendingCapability(adapter, format_desc))
4139 TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
4140 return WINED3DERR_NOTAVAILABLE;
4142 UsageCaps |= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
4145 if (Usage & WINED3DUSAGE_QUERY_SRGBREAD)
4147 if (!CheckSrgbReadCapability(adapter, format_desc))
4149 TRACE_(d3d_caps)("[FAILED] - No query srgbread support\n");
4150 return WINED3DERR_NOTAVAILABLE;
4152 UsageCaps |= WINED3DUSAGE_QUERY_SRGBREAD;
4155 if (Usage & WINED3DUSAGE_QUERY_SRGBWRITE)
4157 if (!CheckSrgbWriteCapability(adapter, format_desc))
4159 TRACE_(d3d_caps)("[FAILED] - No query srgbwrite support\n");
4160 return WINED3DERR_NOTAVAILABLE;
4162 UsageCaps |= WINED3DUSAGE_QUERY_SRGBWRITE;
4165 if (Usage & WINED3DUSAGE_QUERY_VERTEXTEXTURE)
4167 if (!CheckVertexTextureCapability(adapter, format_desc))
4169 TRACE_(d3d_caps)("[FAILED] - No query vertextexture support\n");
4170 return WINED3DERR_NOTAVAILABLE;
4172 UsageCaps |= WINED3DUSAGE_QUERY_VERTEXTEXTURE;
4175 if (Usage & WINED3DUSAGE_QUERY_WRAPANDMIP)
4177 if (!CheckWrapAndMipCapability(adapter, format_desc))
4179 TRACE_(d3d_caps)("[FAILED] - No wrapping and mipmapping support\n");
4180 return WINED3DERR_NOTAVAILABLE;
4182 UsageCaps |= WINED3DUSAGE_QUERY_WRAPANDMIP;
4187 FIXME_(d3d_caps)("Unhandled resource type %s.\n", debug_d3dresourcetype(RType));
4188 return WINED3DERR_NOTAVAILABLE;
4191 /* When the UsageCaps exactly matches Usage return WINED3D_OK except for
4192 * the situation in which WINED3DUSAGE_AUTOGENMIPMAP isn't around, then
4193 * WINED3DOK_NOAUTOGEN is returned if all the other usage flags match. */
4194 if (UsageCaps == Usage)
4196 if (UsageCaps == (Usage & ~WINED3DUSAGE_AUTOGENMIPMAP))
4197 return WINED3DOK_NOAUTOGEN;
4199 TRACE_(d3d_caps)("[FAILED] - Usage %#x requested for CheckFormat %s and RType %s but only %#x is available\n",
4200 Usage, debug_d3dformat(CheckFormat), debug_d3dresourcetype(RType), UsageCaps);
4202 return WINED3DERR_NOTAVAILABLE;
4205 static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormatConversion(IWineD3D *iface, UINT adapter_idx,
4206 WINED3DDEVTYPE device_type, WINED3DFORMAT src_format, WINED3DFORMAT dst_format)
4208 FIXME("iface %p, adapter_idx %u, device_type %s, src_format %s, dst_format %s stub!\n",
4209 iface, adapter_idx, debug_d3ddevicetype(device_type), debug_d3dformat(src_format),
4210 debug_d3dformat(dst_format));
4215 /* Note: d3d8 passes in a pointer to a D3DCAPS8 structure, which is a true
4216 subset of a D3DCAPS9 structure. However, it has to come via a void *
4217 as the d3d8 interface cannot import the d3d9 header */
4218 static HRESULT WINAPI IWineD3DImpl_GetDeviceCaps(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType, WINED3DCAPS* pCaps) {
4220 IWineD3DImpl *This = (IWineD3DImpl *)iface;
4221 struct wined3d_adapter *adapter = &This->adapters[Adapter];
4222 const struct wined3d_gl_info *gl_info = &adapter->gl_info;
4223 int vs_selected_mode;
4224 int ps_selected_mode;
4225 struct shader_caps shader_caps;
4226 struct fragment_caps fragment_caps;
4227 DWORD ckey_caps, blit_caps, fx_caps;
4229 TRACE_(d3d_caps)("(%p)->(Adptr:%d, DevType: %x, pCaps: %p)\n", This, Adapter, DeviceType, pCaps);
4231 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
4232 return WINED3DERR_INVALIDCALL;
4235 select_shader_mode(&adapter->gl_info, &ps_selected_mode, &vs_selected_mode);
4237 /* ------------------------------------------------
4238 The following fields apply to both d3d8 and d3d9
4239 ------------------------------------------------ */
4240 pCaps->DeviceType = (DeviceType == WINED3DDEVTYPE_HAL) ? WINED3DDEVTYPE_HAL : WINED3DDEVTYPE_REF; /* Not quite true, but use h/w supported by opengl I suppose */
4241 pCaps->AdapterOrdinal = Adapter;
4244 pCaps->Caps2 = WINED3DCAPS2_CANRENDERWINDOWED |
4245 WINED3DCAPS2_FULLSCREENGAMMA |
4246 WINED3DCAPS2_DYNAMICTEXTURES;
4247 if (gl_info->supported[SGIS_GENERATE_MIPMAP])
4249 pCaps->Caps2 |= WINED3DCAPS2_CANAUTOGENMIPMAP;
4252 pCaps->Caps3 = WINED3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD |
4253 WINED3DCAPS3_COPY_TO_VIDMEM |
4254 WINED3DCAPS3_COPY_TO_SYSTEMMEM;
4256 pCaps->PresentationIntervals = WINED3DPRESENT_INTERVAL_IMMEDIATE |
4257 WINED3DPRESENT_INTERVAL_ONE;
4259 pCaps->CursorCaps = WINED3DCURSORCAPS_COLOR |
4260 WINED3DCURSORCAPS_LOWRES;
4262 pCaps->DevCaps = WINED3DDEVCAPS_FLOATTLVERTEX |
4263 WINED3DDEVCAPS_EXECUTESYSTEMMEMORY |
4264 WINED3DDEVCAPS_TLVERTEXSYSTEMMEMORY|
4265 WINED3DDEVCAPS_TLVERTEXVIDEOMEMORY |
4266 WINED3DDEVCAPS_DRAWPRIMTLVERTEX |
4267 WINED3DDEVCAPS_HWTRANSFORMANDLIGHT |
4268 WINED3DDEVCAPS_EXECUTEVIDEOMEMORY |
4269 WINED3DDEVCAPS_PUREDEVICE |
4270 WINED3DDEVCAPS_HWRASTERIZATION |
4271 WINED3DDEVCAPS_TEXTUREVIDEOMEMORY |
4272 WINED3DDEVCAPS_TEXTURESYSTEMMEMORY |
4273 WINED3DDEVCAPS_CANRENDERAFTERFLIP |
4274 WINED3DDEVCAPS_DRAWPRIMITIVES2 |
4275 WINED3DDEVCAPS_DRAWPRIMITIVES2EX |
4276 WINED3DDEVCAPS_RTPATCHES;
4278 pCaps->PrimitiveMiscCaps = WINED3DPMISCCAPS_CULLNONE |
4279 WINED3DPMISCCAPS_CULLCCW |
4280 WINED3DPMISCCAPS_CULLCW |
4281 WINED3DPMISCCAPS_COLORWRITEENABLE |
4282 WINED3DPMISCCAPS_CLIPTLVERTS |
4283 WINED3DPMISCCAPS_CLIPPLANESCALEDPOINTS |
4284 WINED3DPMISCCAPS_MASKZ |
4285 WINED3DPMISCCAPS_BLENDOP |
4286 WINED3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING;
4288 WINED3DPMISCCAPS_NULLREFERENCE
4289 WINED3DPMISCCAPS_FOGANDSPECULARALPHA
4290 WINED3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS
4291 WINED3DPMISCCAPS_FOGVERTEXCLAMPED */
4293 if (gl_info->supported[EXT_BLEND_EQUATION_SEPARATE] && gl_info->supported[EXT_BLEND_FUNC_SEPARATE])
4294 pCaps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_SEPARATEALPHABLEND;
4295 if (gl_info->supported[EXT_DRAW_BUFFERS2])
4296 pCaps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_INDEPENDENTWRITEMASKS;
4298 pCaps->RasterCaps = WINED3DPRASTERCAPS_DITHER |
4299 WINED3DPRASTERCAPS_PAT |
4300 WINED3DPRASTERCAPS_WFOG |
4301 WINED3DPRASTERCAPS_ZFOG |
4302 WINED3DPRASTERCAPS_FOGVERTEX |
4303 WINED3DPRASTERCAPS_FOGTABLE |
4304 WINED3DPRASTERCAPS_STIPPLE |
4305 WINED3DPRASTERCAPS_SUBPIXEL |
4306 WINED3DPRASTERCAPS_ZTEST |
4307 WINED3DPRASTERCAPS_SCISSORTEST |
4308 WINED3DPRASTERCAPS_SLOPESCALEDEPTHBIAS |
4309 WINED3DPRASTERCAPS_DEPTHBIAS;
4311 if (gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC])
4313 pCaps->RasterCaps |= WINED3DPRASTERCAPS_ANISOTROPY |
4314 WINED3DPRASTERCAPS_ZBIAS |
4315 WINED3DPRASTERCAPS_MIPMAPLODBIAS;
4317 if (gl_info->supported[NV_FOG_DISTANCE])
4319 pCaps->RasterCaps |= WINED3DPRASTERCAPS_FOGRANGE;
4322 WINED3DPRASTERCAPS_COLORPERSPECTIVE
4323 WINED3DPRASTERCAPS_STRETCHBLTMULTISAMPLE
4324 WINED3DPRASTERCAPS_ANTIALIASEDGES
4325 WINED3DPRASTERCAPS_ZBUFFERLESSHSR
4326 WINED3DPRASTERCAPS_WBUFFER */
4328 pCaps->ZCmpCaps = WINED3DPCMPCAPS_ALWAYS |
4329 WINED3DPCMPCAPS_EQUAL |
4330 WINED3DPCMPCAPS_GREATER |
4331 WINED3DPCMPCAPS_GREATEREQUAL |
4332 WINED3DPCMPCAPS_LESS |
4333 WINED3DPCMPCAPS_LESSEQUAL |
4334 WINED3DPCMPCAPS_NEVER |
4335 WINED3DPCMPCAPS_NOTEQUAL;
4337 pCaps->SrcBlendCaps = WINED3DPBLENDCAPS_BOTHINVSRCALPHA |
4338 WINED3DPBLENDCAPS_BOTHSRCALPHA |
4339 WINED3DPBLENDCAPS_DESTALPHA |
4340 WINED3DPBLENDCAPS_DESTCOLOR |
4341 WINED3DPBLENDCAPS_INVDESTALPHA |
4342 WINED3DPBLENDCAPS_INVDESTCOLOR |
4343 WINED3DPBLENDCAPS_INVSRCALPHA |
4344 WINED3DPBLENDCAPS_INVSRCCOLOR |
4345 WINED3DPBLENDCAPS_ONE |
4346 WINED3DPBLENDCAPS_SRCALPHA |
4347 WINED3DPBLENDCAPS_SRCALPHASAT |
4348 WINED3DPBLENDCAPS_SRCCOLOR |
4349 WINED3DPBLENDCAPS_ZERO;
4351 pCaps->DestBlendCaps = WINED3DPBLENDCAPS_DESTALPHA |
4352 WINED3DPBLENDCAPS_DESTCOLOR |
4353 WINED3DPBLENDCAPS_INVDESTALPHA |
4354 WINED3DPBLENDCAPS_INVDESTCOLOR |
4355 WINED3DPBLENDCAPS_INVSRCALPHA |
4356 WINED3DPBLENDCAPS_INVSRCCOLOR |
4357 WINED3DPBLENDCAPS_ONE |
4358 WINED3DPBLENDCAPS_SRCALPHA |
4359 WINED3DPBLENDCAPS_SRCCOLOR |
4360 WINED3DPBLENDCAPS_ZERO;
4361 /* NOTE: WINED3DPBLENDCAPS_SRCALPHASAT is not supported as dest blend factor,
4362 * according to the glBlendFunc manpage
4364 * WINED3DPBLENDCAPS_BOTHINVSRCALPHA and WINED3DPBLENDCAPS_BOTHSRCALPHA are
4365 * legacy settings for srcblend only
4368 if (gl_info->supported[EXT_BLEND_COLOR])
4370 pCaps->SrcBlendCaps |= WINED3DPBLENDCAPS_BLENDFACTOR;
4371 pCaps->DestBlendCaps |= WINED3DPBLENDCAPS_BLENDFACTOR;
4375 pCaps->AlphaCmpCaps = WINED3DPCMPCAPS_ALWAYS |
4376 WINED3DPCMPCAPS_EQUAL |
4377 WINED3DPCMPCAPS_GREATER |
4378 WINED3DPCMPCAPS_GREATEREQUAL |
4379 WINED3DPCMPCAPS_LESS |
4380 WINED3DPCMPCAPS_LESSEQUAL |
4381 WINED3DPCMPCAPS_NEVER |
4382 WINED3DPCMPCAPS_NOTEQUAL;
4384 pCaps->ShadeCaps = WINED3DPSHADECAPS_SPECULARGOURAUDRGB |
4385 WINED3DPSHADECAPS_COLORGOURAUDRGB |
4386 WINED3DPSHADECAPS_ALPHAFLATBLEND |
4387 WINED3DPSHADECAPS_ALPHAGOURAUDBLEND |
4388 WINED3DPSHADECAPS_COLORFLATRGB |
4389 WINED3DPSHADECAPS_FOGFLAT |
4390 WINED3DPSHADECAPS_FOGGOURAUD |
4391 WINED3DPSHADECAPS_SPECULARFLATRGB;
4393 pCaps->TextureCaps = WINED3DPTEXTURECAPS_ALPHA |
4394 WINED3DPTEXTURECAPS_ALPHAPALETTE |
4395 WINED3DPTEXTURECAPS_TRANSPARENCY |
4396 WINED3DPTEXTURECAPS_BORDER |
4397 WINED3DPTEXTURECAPS_MIPMAP |
4398 WINED3DPTEXTURECAPS_PROJECTED |
4399 WINED3DPTEXTURECAPS_PERSPECTIVE;
4401 if (!gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO])
4403 pCaps->TextureCaps |= WINED3DPTEXTURECAPS_POW2 |
4404 WINED3DPTEXTURECAPS_NONPOW2CONDITIONAL;
4407 if (gl_info->supported[EXT_TEXTURE3D])
4409 pCaps->TextureCaps |= WINED3DPTEXTURECAPS_VOLUMEMAP |
4410 WINED3DPTEXTURECAPS_MIPVOLUMEMAP |
4411 WINED3DPTEXTURECAPS_VOLUMEMAP_POW2;
4414 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
4416 pCaps->TextureCaps |= WINED3DPTEXTURECAPS_CUBEMAP |
4417 WINED3DPTEXTURECAPS_MIPCUBEMAP |
4418 WINED3DPTEXTURECAPS_CUBEMAP_POW2;
4422 pCaps->TextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR |
4423 WINED3DPTFILTERCAPS_MAGFPOINT |
4424 WINED3DPTFILTERCAPS_MINFLINEAR |
4425 WINED3DPTFILTERCAPS_MINFPOINT |
4426 WINED3DPTFILTERCAPS_MIPFLINEAR |
4427 WINED3DPTFILTERCAPS_MIPFPOINT |
4428 WINED3DPTFILTERCAPS_LINEAR |
4429 WINED3DPTFILTERCAPS_LINEARMIPLINEAR |
4430 WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
4431 WINED3DPTFILTERCAPS_MIPLINEAR |
4432 WINED3DPTFILTERCAPS_MIPNEAREST |
4433 WINED3DPTFILTERCAPS_NEAREST;
4435 if (gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC])
4437 pCaps->TextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC |
4438 WINED3DPTFILTERCAPS_MINFANISOTROPIC;
4441 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
4443 pCaps->CubeTextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR |
4444 WINED3DPTFILTERCAPS_MAGFPOINT |
4445 WINED3DPTFILTERCAPS_MINFLINEAR |
4446 WINED3DPTFILTERCAPS_MINFPOINT |
4447 WINED3DPTFILTERCAPS_MIPFLINEAR |
4448 WINED3DPTFILTERCAPS_MIPFPOINT |
4449 WINED3DPTFILTERCAPS_LINEAR |
4450 WINED3DPTFILTERCAPS_LINEARMIPLINEAR |
4451 WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
4452 WINED3DPTFILTERCAPS_MIPLINEAR |
4453 WINED3DPTFILTERCAPS_MIPNEAREST |
4454 WINED3DPTFILTERCAPS_NEAREST;
4456 if (gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC])
4458 pCaps->CubeTextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC |
4459 WINED3DPTFILTERCAPS_MINFANISOTROPIC;
4462 pCaps->CubeTextureFilterCaps = 0;
4464 if (gl_info->supported[EXT_TEXTURE3D])
4466 pCaps->VolumeTextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR |
4467 WINED3DPTFILTERCAPS_MAGFPOINT |
4468 WINED3DPTFILTERCAPS_MINFLINEAR |
4469 WINED3DPTFILTERCAPS_MINFPOINT |
4470 WINED3DPTFILTERCAPS_MIPFLINEAR |
4471 WINED3DPTFILTERCAPS_MIPFPOINT |
4472 WINED3DPTFILTERCAPS_LINEAR |
4473 WINED3DPTFILTERCAPS_LINEARMIPLINEAR |
4474 WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
4475 WINED3DPTFILTERCAPS_MIPLINEAR |
4476 WINED3DPTFILTERCAPS_MIPNEAREST |
4477 WINED3DPTFILTERCAPS_NEAREST;
4479 pCaps->VolumeTextureFilterCaps = 0;
4481 pCaps->TextureAddressCaps = WINED3DPTADDRESSCAPS_INDEPENDENTUV |
4482 WINED3DPTADDRESSCAPS_CLAMP |
4483 WINED3DPTADDRESSCAPS_WRAP;
4485 if (gl_info->supported[ARB_TEXTURE_BORDER_CLAMP])
4487 pCaps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_BORDER;
4489 if (gl_info->supported[ARB_TEXTURE_MIRRORED_REPEAT])
4491 pCaps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRROR;
4493 if (gl_info->supported[ATI_TEXTURE_MIRROR_ONCE])
4495 pCaps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRRORONCE;
4498 if (gl_info->supported[EXT_TEXTURE3D])
4500 pCaps->VolumeTextureAddressCaps = WINED3DPTADDRESSCAPS_INDEPENDENTUV |
4501 WINED3DPTADDRESSCAPS_CLAMP |
4502 WINED3DPTADDRESSCAPS_WRAP;
4503 if (gl_info->supported[ARB_TEXTURE_BORDER_CLAMP])
4505 pCaps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_BORDER;
4507 if (gl_info->supported[ARB_TEXTURE_MIRRORED_REPEAT])
4509 pCaps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRROR;
4511 if (gl_info->supported[ATI_TEXTURE_MIRROR_ONCE])
4513 pCaps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRRORONCE;
4516 pCaps->VolumeTextureAddressCaps = 0;
4518 pCaps->LineCaps = WINED3DLINECAPS_TEXTURE |
4519 WINED3DLINECAPS_ZTEST |
4520 WINED3DLINECAPS_BLEND |
4521 WINED3DLINECAPS_ALPHACMP |
4522 WINED3DLINECAPS_FOG;
4523 /* WINED3DLINECAPS_ANTIALIAS is not supported on Windows, and dx and gl seem to have a different
4524 * idea how generating the smoothing alpha values works; the result is different
4527 pCaps->MaxTextureWidth = gl_info->limits.texture_size;
4528 pCaps->MaxTextureHeight = gl_info->limits.texture_size;
4530 if (gl_info->supported[EXT_TEXTURE3D])
4531 pCaps->MaxVolumeExtent = gl_info->limits.texture3d_size;
4533 pCaps->MaxVolumeExtent = 0;
4535 pCaps->MaxTextureRepeat = 32768;
4536 pCaps->MaxTextureAspectRatio = gl_info->limits.texture_size;
4537 pCaps->MaxVertexW = 1.0f;
4539 pCaps->GuardBandLeft = 0.0f;
4540 pCaps->GuardBandTop = 0.0f;
4541 pCaps->GuardBandRight = 0.0f;
4542 pCaps->GuardBandBottom = 0.0f;
4544 pCaps->ExtentsAdjust = 0.0f;
4546 pCaps->StencilCaps = WINED3DSTENCILCAPS_DECRSAT |
4547 WINED3DSTENCILCAPS_INCRSAT |
4548 WINED3DSTENCILCAPS_INVERT |
4549 WINED3DSTENCILCAPS_KEEP |
4550 WINED3DSTENCILCAPS_REPLACE |
4551 WINED3DSTENCILCAPS_ZERO;
4552 if (gl_info->supported[EXT_STENCIL_WRAP])
4554 pCaps->StencilCaps |= WINED3DSTENCILCAPS_DECR |
4555 WINED3DSTENCILCAPS_INCR;
4557 if (gl_info->supported[EXT_STENCIL_TWO_SIDE] || gl_info->supported[ATI_SEPARATE_STENCIL])
4559 pCaps->StencilCaps |= WINED3DSTENCILCAPS_TWOSIDED;
4562 pCaps->FVFCaps = WINED3DFVFCAPS_PSIZE | 0x0008; /* 8 texture coords */
4564 pCaps->MaxUserClipPlanes = gl_info->limits.clipplanes;
4565 pCaps->MaxActiveLights = gl_info->limits.lights;
4567 pCaps->MaxVertexBlendMatrices = gl_info->limits.blends;
4568 pCaps->MaxVertexBlendMatrixIndex = 0;
4570 pCaps->MaxAnisotropy = gl_info->limits.anisotropy;
4571 pCaps->MaxPointSize = gl_info->limits.pointsize_max;
4574 /* FIXME: Add D3DVTXPCAPS_TWEENING, D3DVTXPCAPS_TEXGEN_SPHEREMAP */
4575 pCaps->VertexProcessingCaps = WINED3DVTXPCAPS_DIRECTIONALLIGHTS |
4576 WINED3DVTXPCAPS_MATERIALSOURCE7 |
4577 WINED3DVTXPCAPS_POSITIONALLIGHTS |
4578 WINED3DVTXPCAPS_LOCALVIEWER |
4579 WINED3DVTXPCAPS_VERTEXFOG |
4580 WINED3DVTXPCAPS_TEXGEN;
4582 pCaps->MaxPrimitiveCount = 0xFFFFF; /* For now set 2^20-1 which is used by most >=Geforce3/Radeon8500 cards */
4583 pCaps->MaxVertexIndex = 0xFFFFF;
4584 pCaps->MaxStreams = MAX_STREAMS;
4585 pCaps->MaxStreamStride = 1024;
4587 /* d3d9.dll sets D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES here because StretchRects is implemented in d3d9 */
4588 pCaps->DevCaps2 = WINED3DDEVCAPS2_STREAMOFFSET |
4589 WINED3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET;
4590 pCaps->MaxNpatchTessellationLevel = 0;
4591 pCaps->MasterAdapterOrdinal = 0;
4592 pCaps->AdapterOrdinalInGroup = 0;
4593 pCaps->NumberOfAdaptersInGroup = 1;
4595 pCaps->NumSimultaneousRTs = gl_info->limits.buffers;
4597 pCaps->StretchRectFilterCaps = WINED3DPTFILTERCAPS_MINFPOINT |
4598 WINED3DPTFILTERCAPS_MAGFPOINT |
4599 WINED3DPTFILTERCAPS_MINFLINEAR |
4600 WINED3DPTFILTERCAPS_MAGFLINEAR;
4601 pCaps->VertexTextureFilterCaps = 0;
4603 adapter->shader_backend->shader_get_caps(&adapter->gl_info, &shader_caps);
4604 adapter->fragment_pipe->get_caps(&adapter->gl_info, &fragment_caps);
4606 /* Add shader misc caps. Only some of them belong to the shader parts of the pipeline */
4607 pCaps->PrimitiveMiscCaps |= fragment_caps.PrimitiveMiscCaps;
4609 /* This takes care for disabling vertex shader or pixel shader caps while leaving the other one enabled.
4610 * Ignore shader model capabilities if disabled in config
4612 if(vs_selected_mode == SHADER_NONE) {
4613 TRACE_(d3d_caps)("Vertex shader disabled in config, reporting version 0.0\n");
4614 pCaps->VertexShaderVersion = WINED3DVS_VERSION(0,0);
4615 pCaps->MaxVertexShaderConst = 0;
4617 pCaps->VertexShaderVersion = shader_caps.VertexShaderVersion;
4618 pCaps->MaxVertexShaderConst = shader_caps.MaxVertexShaderConst;
4621 if(ps_selected_mode == SHADER_NONE) {
4622 TRACE_(d3d_caps)("Pixel shader disabled in config, reporting version 0.0\n");
4623 pCaps->PixelShaderVersion = WINED3DPS_VERSION(0,0);
4624 pCaps->PixelShader1xMaxValue = 0.0f;
4626 pCaps->PixelShaderVersion = shader_caps.PixelShaderVersion;
4627 pCaps->PixelShader1xMaxValue = shader_caps.PixelShader1xMaxValue;
4630 pCaps->TextureOpCaps = fragment_caps.TextureOpCaps;
4631 pCaps->MaxTextureBlendStages = fragment_caps.MaxTextureBlendStages;
4632 pCaps->MaxSimultaneousTextures = fragment_caps.MaxSimultaneousTextures;
4634 /* The following caps are shader specific, but they are things we cannot detect, or which
4635 * are the same among all shader models. So to avoid code duplication set the shader version
4636 * specific, but otherwise constant caps here
4638 if(pCaps->VertexShaderVersion == WINED3DVS_VERSION(3,0)) {
4639 /* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering)
4640 use the VS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum VS3.0 value. */
4641 pCaps->VS20Caps.Caps = WINED3DVS20CAPS_PREDICATION;
4642 pCaps->VS20Caps.DynamicFlowControlDepth = WINED3DVS20_MAX_DYNAMICFLOWCONTROLDEPTH; /* VS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
4643 pCaps->VS20Caps.NumTemps = max(32, adapter->gl_info.limits.arb_vs_temps);
4644 pCaps->VS20Caps.StaticFlowControlDepth = WINED3DVS20_MAX_STATICFLOWCONTROLDEPTH ; /* level of nesting in loops / if-statements; VS 3.0 requires MAX (4) */
4646 pCaps->MaxVShaderInstructionsExecuted = 65535; /* VS 3.0 needs at least 65535, some cards even use 2^32-1 */
4647 pCaps->MaxVertexShader30InstructionSlots = max(512, adapter->gl_info.limits.arb_vs_instructions);
4649 else if (pCaps->VertexShaderVersion == WINED3DVS_VERSION(2,0))
4651 pCaps->VS20Caps.Caps = 0;
4652 pCaps->VS20Caps.DynamicFlowControlDepth = WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH;
4653 pCaps->VS20Caps.NumTemps = max(12, adapter->gl_info.limits.arb_vs_temps);
4654 pCaps->VS20Caps.StaticFlowControlDepth = 1;
4656 pCaps->MaxVShaderInstructionsExecuted = 65535;
4657 pCaps->MaxVertexShader30InstructionSlots = 0;
4658 } else { /* VS 1.x */
4659 pCaps->VS20Caps.Caps = 0;
4660 pCaps->VS20Caps.DynamicFlowControlDepth = 0;
4661 pCaps->VS20Caps.NumTemps = 0;
4662 pCaps->VS20Caps.StaticFlowControlDepth = 0;
4664 pCaps->MaxVShaderInstructionsExecuted = 0;
4665 pCaps->MaxVertexShader30InstructionSlots = 0;
4668 if(pCaps->PixelShaderVersion == WINED3DPS_VERSION(3,0)) {
4669 /* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering)
4670 use the PS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum PS 3.0 value. */
4672 /* 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 */
4673 pCaps->PS20Caps.Caps = WINED3DPS20CAPS_ARBITRARYSWIZZLE |
4674 WINED3DPS20CAPS_GRADIENTINSTRUCTIONS |
4675 WINED3DPS20CAPS_PREDICATION |
4676 WINED3DPS20CAPS_NODEPENDENTREADLIMIT |
4677 WINED3DPS20CAPS_NOTEXINSTRUCTIONLIMIT;
4678 pCaps->PS20Caps.DynamicFlowControlDepth = WINED3DPS20_MAX_DYNAMICFLOWCONTROLDEPTH; /* PS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
4679 pCaps->PS20Caps.NumTemps = max(32, adapter->gl_info.limits.arb_ps_temps);
4680 pCaps->PS20Caps.StaticFlowControlDepth = WINED3DPS20_MAX_STATICFLOWCONTROLDEPTH; /* PS 3.0 requires MAX_STATICFLOWCONTROLDEPTH (4) */
4681 pCaps->PS20Caps.NumInstructionSlots = WINED3DPS20_MAX_NUMINSTRUCTIONSLOTS; /* PS 3.0 requires MAX_NUMINSTRUCTIONSLOTS (512) */
4683 pCaps->MaxPShaderInstructionsExecuted = 65535;
4684 pCaps->MaxPixelShader30InstructionSlots = max(WINED3DMIN30SHADERINSTRUCTIONS,
4685 adapter->gl_info.limits.arb_ps_instructions);
4687 else if(pCaps->PixelShaderVersion == WINED3DPS_VERSION(2,0))
4689 /* Below we assume PS2.0 specs, not extended 2.0a(GeforceFX)/2.0b(Radeon R3xx) ones */
4690 pCaps->PS20Caps.Caps = 0;
4691 pCaps->PS20Caps.DynamicFlowControlDepth = 0; /* WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH = 0 */
4692 pCaps->PS20Caps.NumTemps = max(12, adapter->gl_info.limits.arb_ps_temps);
4693 pCaps->PS20Caps.StaticFlowControlDepth = WINED3DPS20_MIN_STATICFLOWCONTROLDEPTH; /* Minimum: 1 */
4694 pCaps->PS20Caps.NumInstructionSlots = WINED3DPS20_MIN_NUMINSTRUCTIONSLOTS; /* Minimum number (64 ALU + 32 Texture), a GeforceFX uses 512 */
4696 pCaps->MaxPShaderInstructionsExecuted = 512; /* Minimum value, a GeforceFX uses 1024 */
4697 pCaps->MaxPixelShader30InstructionSlots = 0;
4698 } else { /* PS 1.x */
4699 pCaps->PS20Caps.Caps = 0;
4700 pCaps->PS20Caps.DynamicFlowControlDepth = 0;
4701 pCaps->PS20Caps.NumTemps = 0;
4702 pCaps->PS20Caps.StaticFlowControlDepth = 0;
4703 pCaps->PS20Caps.NumInstructionSlots = 0;
4705 pCaps->MaxPShaderInstructionsExecuted = 0;
4706 pCaps->MaxPixelShader30InstructionSlots = 0;
4709 if(pCaps->VertexShaderVersion >= WINED3DVS_VERSION(2,0)) {
4710 /* OpenGL supports all the formats below, perhaps not always
4711 * without conversion, but it supports them.
4712 * Further GLSL doesn't seem to have an official unsigned type so
4713 * don't advertise it yet as I'm not sure how we handle it.
4714 * We might need to add some clamping in the shader engine to
4716 * TODO: WINED3DDTCAPS_USHORT2N, WINED3DDTCAPS_USHORT4N, WINED3DDTCAPS_UDEC3, WINED3DDTCAPS_DEC3N */
4717 pCaps->DeclTypes = WINED3DDTCAPS_UBYTE4 |
4718 WINED3DDTCAPS_UBYTE4N |
4719 WINED3DDTCAPS_SHORT2N |
4720 WINED3DDTCAPS_SHORT4N;
4721 if (gl_info->supported[ARB_HALF_FLOAT_VERTEX])
4723 pCaps->DeclTypes |= WINED3DDTCAPS_FLOAT16_2 |
4724 WINED3DDTCAPS_FLOAT16_4;
4727 pCaps->DeclTypes = 0;
4729 /* Set DirectDraw helper Caps */
4730 ckey_caps = WINEDDCKEYCAPS_DESTBLT |
4731 WINEDDCKEYCAPS_SRCBLT;
4732 fx_caps = WINEDDFXCAPS_BLTALPHA |
4733 WINEDDFXCAPS_BLTMIRRORLEFTRIGHT |
4734 WINEDDFXCAPS_BLTMIRRORUPDOWN |
4735 WINEDDFXCAPS_BLTROTATION90 |
4736 WINEDDFXCAPS_BLTSHRINKX |
4737 WINEDDFXCAPS_BLTSHRINKXN |
4738 WINEDDFXCAPS_BLTSHRINKY |
4739 WINEDDFXCAPS_BLTSHRINKXN |
4740 WINEDDFXCAPS_BLTSTRETCHX |
4741 WINEDDFXCAPS_BLTSTRETCHXN |
4742 WINEDDFXCAPS_BLTSTRETCHY |
4743 WINEDDFXCAPS_BLTSTRETCHYN;
4744 blit_caps = WINEDDCAPS_BLT |
4745 WINEDDCAPS_BLTCOLORFILL |
4746 WINEDDCAPS_BLTDEPTHFILL |
4747 WINEDDCAPS_BLTSTRETCH |
4748 WINEDDCAPS_CANBLTSYSMEM |
4749 WINEDDCAPS_CANCLIP |
4750 WINEDDCAPS_CANCLIPSTRETCHED |
4751 WINEDDCAPS_COLORKEY |
4752 WINEDDCAPS_COLORKEYHWASSIST |
4753 WINEDDCAPS_ALIGNBOUNDARYSRC;
4755 /* Fill the ddraw caps structure */
4756 pCaps->DirectDrawCaps.Caps = WINEDDCAPS_GDI |
4757 WINEDDCAPS_PALETTE |
4759 pCaps->DirectDrawCaps.Caps2 = WINEDDCAPS2_CERTIFIED |
4760 WINEDDCAPS2_NOPAGELOCKREQUIRED |
4761 WINEDDCAPS2_PRIMARYGAMMA |
4762 WINEDDCAPS2_WIDESURFACES |
4763 WINEDDCAPS2_CANRENDERWINDOWED;
4764 pCaps->DirectDrawCaps.SVBCaps = blit_caps;
4765 pCaps->DirectDrawCaps.SVBCKeyCaps = ckey_caps;
4766 pCaps->DirectDrawCaps.SVBFXCaps = fx_caps;
4767 pCaps->DirectDrawCaps.VSBCaps = blit_caps;
4768 pCaps->DirectDrawCaps.VSBCKeyCaps = ckey_caps;
4769 pCaps->DirectDrawCaps.VSBFXCaps = fx_caps;
4770 pCaps->DirectDrawCaps.SSBCaps = blit_caps;
4771 pCaps->DirectDrawCaps.SSBCKeyCaps = ckey_caps;
4772 pCaps->DirectDrawCaps.SSBFXCaps = fx_caps;
4774 pCaps->DirectDrawCaps.ddsCaps = WINEDDSCAPS_ALPHA |
4775 WINEDDSCAPS_BACKBUFFER |
4777 WINEDDSCAPS_FRONTBUFFER |
4778 WINEDDSCAPS_OFFSCREENPLAIN |
4779 WINEDDSCAPS_PALETTE |
4780 WINEDDSCAPS_PRIMARYSURFACE |
4781 WINEDDSCAPS_SYSTEMMEMORY |
4782 WINEDDSCAPS_VIDEOMEMORY |
4783 WINEDDSCAPS_VISIBLE;
4784 pCaps->DirectDrawCaps.StrideAlign = DDRAW_PITCH_ALIGNMENT;
4786 /* Set D3D caps if OpenGL is available. */
4787 if (adapter->opengl)
4789 pCaps->DirectDrawCaps.ddsCaps |=WINEDDSCAPS_3DDEVICE |
4790 WINEDDSCAPS_MIPMAP |
4791 WINEDDSCAPS_TEXTURE |
4792 WINEDDSCAPS_ZBUFFER;
4793 pCaps->DirectDrawCaps.Caps |= WINEDDCAPS_3D;
4799 static HRESULT WINAPI IWineD3DImpl_CreateDevice(IWineD3D *iface, UINT adapter_idx,
4800 WINED3DDEVTYPE device_type, HWND focus_window, DWORD flags, IUnknown *parent,
4801 IWineD3DDeviceParent *device_parent, IWineD3DDevice **device)
4803 IWineD3DImpl *This = (IWineD3DImpl *)iface;
4804 IWineD3DDeviceImpl *object;
4807 TRACE("iface %p, adapter_idx %u, device_type %#x, focus_window %p, flags %#x.\n"
4808 "parent %p, device_parent %p, device %p.\n",
4809 iface, adapter_idx, device_type, focus_window, flags,
4810 parent, device_parent, device);
4812 /* Validate the adapter number. If no adapters are available(no GL), ignore the adapter
4813 * number and create a device without a 3D adapter for 2D only operation. */
4814 if (IWineD3D_GetAdapterCount(iface) && adapter_idx >= IWineD3D_GetAdapterCount(iface))
4816 return WINED3DERR_INVALIDCALL;
4819 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
4822 ERR("Failed to allocate device memory.\n");
4823 return E_OUTOFMEMORY;
4826 hr = device_init(object, This, adapter_idx, device_type, focus_window, flags, parent, device_parent);
4829 WARN("Failed to initialize device, hr %#x.\n", hr);
4830 HeapFree(GetProcessHeap(), 0, object);
4834 TRACE("Created device %p.\n", object);
4835 *device = (IWineD3DDevice *)object;
4837 IWineD3DDeviceParent_WineD3DDeviceCreated(device_parent, *device);
4842 static HRESULT WINAPI IWineD3DImpl_GetParent(IWineD3D *iface, IUnknown **pParent) {
4843 IWineD3DImpl *This = (IWineD3DImpl *)iface;
4844 IUnknown_AddRef(This->parent);
4845 *pParent = This->parent;
4849 static void WINE_GLAPI invalid_func(const void *data)
4851 ERR("Invalid vertex attribute function called\n");
4855 static void WINE_GLAPI invalid_texcoord_func(GLenum unit, const void *data)
4857 ERR("Invalid texcoord function called\n");
4861 /* Helper functions for providing vertex data to opengl. The arrays are initialized based on
4862 * the extension detection and are used in drawStridedSlow
4864 static void WINE_GLAPI position_d3dcolor(const void *data)
4866 DWORD pos = *((const DWORD *)data);
4868 FIXME("Add a test for fixed function position from d3dcolor type\n");
4869 glVertex4s(D3DCOLOR_B_R(pos),
4875 static void WINE_GLAPI position_float4(const void *data)
4877 const GLfloat *pos = data;
4879 if (pos[3] != 0.0f && pos[3] != 1.0f)
4881 float w = 1.0f / pos[3];
4883 glVertex4f(pos[0] * w, pos[1] * w, pos[2] * w, w);
4891 static void WINE_GLAPI diffuse_d3dcolor(const void *data)
4893 DWORD diffuseColor = *((const DWORD *)data);
4895 glColor4ub(D3DCOLOR_B_R(diffuseColor),
4896 D3DCOLOR_B_G(diffuseColor),
4897 D3DCOLOR_B_B(diffuseColor),
4898 D3DCOLOR_B_A(diffuseColor));
4901 static void WINE_GLAPI specular_d3dcolor(const void *data)
4903 DWORD specularColor = *((const DWORD *)data);
4904 GLbyte d[] = {D3DCOLOR_B_R(specularColor),
4905 D3DCOLOR_B_G(specularColor),
4906 D3DCOLOR_B_B(specularColor)};
4908 specular_func_3ubv(d);
4911 static void WINE_GLAPI warn_no_specular_func(const void *data)
4913 WARN("GL_EXT_secondary_color not supported\n");
4916 static void fillGLAttribFuncs(const struct wined3d_gl_info *gl_info)
4918 position_funcs[WINED3D_FFP_EMIT_FLOAT1] = invalid_func;
4919 position_funcs[WINED3D_FFP_EMIT_FLOAT2] = invalid_func;
4920 position_funcs[WINED3D_FFP_EMIT_FLOAT3] = (glAttribFunc)glVertex3fv;
4921 position_funcs[WINED3D_FFP_EMIT_FLOAT4] = position_float4;
4922 position_funcs[WINED3D_FFP_EMIT_D3DCOLOR] = position_d3dcolor;
4923 position_funcs[WINED3D_FFP_EMIT_UBYTE4] = invalid_func;
4924 position_funcs[WINED3D_FFP_EMIT_SHORT2] = invalid_func;
4925 position_funcs[WINED3D_FFP_EMIT_SHORT4] = (glAttribFunc)glVertex2sv;
4926 position_funcs[WINED3D_FFP_EMIT_UBYTE4N] = invalid_func;
4927 position_funcs[WINED3D_FFP_EMIT_SHORT2N] = invalid_func;
4928 position_funcs[WINED3D_FFP_EMIT_SHORT4N] = invalid_func;
4929 position_funcs[WINED3D_FFP_EMIT_USHORT2N] = invalid_func;
4930 position_funcs[WINED3D_FFP_EMIT_USHORT4N] = invalid_func;
4931 position_funcs[WINED3D_FFP_EMIT_UDEC3] = invalid_func;
4932 position_funcs[WINED3D_FFP_EMIT_DEC3N] = invalid_func;
4933 position_funcs[WINED3D_FFP_EMIT_FLOAT16_2] = invalid_func;
4934 position_funcs[WINED3D_FFP_EMIT_FLOAT16_4] = invalid_func;
4936 diffuse_funcs[WINED3D_FFP_EMIT_FLOAT1] = invalid_func;
4937 diffuse_funcs[WINED3D_FFP_EMIT_FLOAT2] = invalid_func;
4938 diffuse_funcs[WINED3D_FFP_EMIT_FLOAT3] = (glAttribFunc)glColor3fv;
4939 diffuse_funcs[WINED3D_FFP_EMIT_FLOAT4] = (glAttribFunc)glColor4fv;
4940 diffuse_funcs[WINED3D_FFP_EMIT_D3DCOLOR] = diffuse_d3dcolor;
4941 diffuse_funcs[WINED3D_FFP_EMIT_UBYTE4] = invalid_func;
4942 diffuse_funcs[WINED3D_FFP_EMIT_SHORT2] = invalid_func;
4943 diffuse_funcs[WINED3D_FFP_EMIT_SHORT4] = invalid_func;
4944 diffuse_funcs[WINED3D_FFP_EMIT_UBYTE4N] = (glAttribFunc)glColor4ubv;
4945 diffuse_funcs[WINED3D_FFP_EMIT_SHORT2N] = invalid_func;
4946 diffuse_funcs[WINED3D_FFP_EMIT_SHORT4N] = (glAttribFunc)glColor4sv;
4947 diffuse_funcs[WINED3D_FFP_EMIT_USHORT2N] = invalid_func;
4948 diffuse_funcs[WINED3D_FFP_EMIT_USHORT4N] = (glAttribFunc)glColor4usv;
4949 diffuse_funcs[WINED3D_FFP_EMIT_UDEC3] = invalid_func;
4950 diffuse_funcs[WINED3D_FFP_EMIT_DEC3N] = invalid_func;
4951 diffuse_funcs[WINED3D_FFP_EMIT_FLOAT16_2] = invalid_func;
4952 diffuse_funcs[WINED3D_FFP_EMIT_FLOAT16_4] = invalid_func;
4954 /* No 4 component entry points here */
4955 specular_funcs[WINED3D_FFP_EMIT_FLOAT1] = invalid_func;
4956 specular_funcs[WINED3D_FFP_EMIT_FLOAT2] = invalid_func;
4957 if (gl_info->supported[EXT_SECONDARY_COLOR])
4959 specular_funcs[WINED3D_FFP_EMIT_FLOAT3] = (glAttribFunc)GL_EXTCALL(glSecondaryColor3fvEXT);
4963 specular_funcs[WINED3D_FFP_EMIT_FLOAT3] = warn_no_specular_func;
4965 specular_funcs[WINED3D_FFP_EMIT_FLOAT4] = invalid_func;
4966 if (gl_info->supported[EXT_SECONDARY_COLOR])
4968 specular_func_3ubv = (glAttribFunc)GL_EXTCALL(glSecondaryColor3ubvEXT);
4969 specular_funcs[WINED3D_FFP_EMIT_D3DCOLOR] = specular_d3dcolor;
4973 specular_funcs[WINED3D_FFP_EMIT_D3DCOLOR] = warn_no_specular_func;
4975 specular_funcs[WINED3D_FFP_EMIT_UBYTE4] = invalid_func;
4976 specular_funcs[WINED3D_FFP_EMIT_SHORT2] = invalid_func;
4977 specular_funcs[WINED3D_FFP_EMIT_SHORT4] = invalid_func;
4978 specular_funcs[WINED3D_FFP_EMIT_UBYTE4N] = invalid_func;
4979 specular_funcs[WINED3D_FFP_EMIT_SHORT2N] = invalid_func;
4980 specular_funcs[WINED3D_FFP_EMIT_SHORT4N] = invalid_func;
4981 specular_funcs[WINED3D_FFP_EMIT_USHORT2N] = invalid_func;
4982 specular_funcs[WINED3D_FFP_EMIT_USHORT4N] = invalid_func;
4983 specular_funcs[WINED3D_FFP_EMIT_UDEC3] = invalid_func;
4984 specular_funcs[WINED3D_FFP_EMIT_DEC3N] = invalid_func;
4985 specular_funcs[WINED3D_FFP_EMIT_FLOAT16_2] = invalid_func;
4986 specular_funcs[WINED3D_FFP_EMIT_FLOAT16_4] = invalid_func;
4988 /* Only 3 component entry points here. Test how others behave. Float4 normals are used
4989 * by one of our tests, trying to pass it to the pixel shader, which fails on Windows.
4991 normal_funcs[WINED3D_FFP_EMIT_FLOAT1] = invalid_func;
4992 normal_funcs[WINED3D_FFP_EMIT_FLOAT2] = invalid_func;
4993 normal_funcs[WINED3D_FFP_EMIT_FLOAT3] = (glAttribFunc)glNormal3fv;
4994 normal_funcs[WINED3D_FFP_EMIT_FLOAT4] = (glAttribFunc)glNormal3fv; /* Just ignore the 4th value */
4995 normal_funcs[WINED3D_FFP_EMIT_D3DCOLOR] = invalid_func;
4996 normal_funcs[WINED3D_FFP_EMIT_UBYTE4] = invalid_func;
4997 normal_funcs[WINED3D_FFP_EMIT_SHORT2] = invalid_func;
4998 normal_funcs[WINED3D_FFP_EMIT_SHORT4] = invalid_func;
4999 normal_funcs[WINED3D_FFP_EMIT_UBYTE4N] = invalid_func;
5000 normal_funcs[WINED3D_FFP_EMIT_SHORT2N] = invalid_func;
5001 normal_funcs[WINED3D_FFP_EMIT_SHORT4N] = invalid_func;
5002 normal_funcs[WINED3D_FFP_EMIT_USHORT2N] = invalid_func;
5003 normal_funcs[WINED3D_FFP_EMIT_USHORT4N] = invalid_func;
5004 normal_funcs[WINED3D_FFP_EMIT_UDEC3] = invalid_func;
5005 normal_funcs[WINED3D_FFP_EMIT_DEC3N] = invalid_func;
5006 normal_funcs[WINED3D_FFP_EMIT_FLOAT16_2] = invalid_func;
5007 normal_funcs[WINED3D_FFP_EMIT_FLOAT16_4] = invalid_func;
5009 multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT1] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord1fvARB);
5010 multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT2] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord2fvARB);
5011 multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT3] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord3fvARB);
5012 multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT4] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord4fvARB);
5013 multi_texcoord_funcs[WINED3D_FFP_EMIT_D3DCOLOR] = invalid_texcoord_func;
5014 multi_texcoord_funcs[WINED3D_FFP_EMIT_UBYTE4] = invalid_texcoord_func;
5015 multi_texcoord_funcs[WINED3D_FFP_EMIT_SHORT2] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord2svARB);
5016 multi_texcoord_funcs[WINED3D_FFP_EMIT_SHORT4] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord4svARB);
5017 multi_texcoord_funcs[WINED3D_FFP_EMIT_UBYTE4N] = invalid_texcoord_func;
5018 multi_texcoord_funcs[WINED3D_FFP_EMIT_SHORT2N] = invalid_texcoord_func;
5019 multi_texcoord_funcs[WINED3D_FFP_EMIT_SHORT4N] = invalid_texcoord_func;
5020 multi_texcoord_funcs[WINED3D_FFP_EMIT_USHORT2N] = invalid_texcoord_func;
5021 multi_texcoord_funcs[WINED3D_FFP_EMIT_USHORT4N] = invalid_texcoord_func;
5022 multi_texcoord_funcs[WINED3D_FFP_EMIT_UDEC3] = invalid_texcoord_func;
5023 multi_texcoord_funcs[WINED3D_FFP_EMIT_DEC3N] = invalid_texcoord_func;
5024 if (gl_info->supported[NV_HALF_FLOAT])
5026 /* Not supported by ARB_HALF_FLOAT_VERTEX, so check for NV_HALF_FLOAT */
5027 multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT16_2] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord2hvNV);
5028 multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT16_4] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord4hvNV);
5030 multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT16_2] = invalid_texcoord_func;
5031 multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT16_4] = invalid_texcoord_func;
5035 static BOOL InitAdapters(IWineD3DImpl *This)
5037 static HMODULE mod_gl;
5039 int ps_selected_mode, vs_selected_mode;
5041 /* No need to hold any lock. The calling library makes sure only one thread calls
5042 * wined3d simultaneously
5045 TRACE("Initializing adapters\n");
5048 #ifdef USE_WIN32_OPENGL
5049 #define USE_GL_FUNC(pfn) pfn = (void*)GetProcAddress(mod_gl, #pfn);
5050 mod_gl = LoadLibraryA("opengl32.dll");
5052 ERR("Can't load opengl32.dll!\n");
5056 #define USE_GL_FUNC(pfn) pfn = (void*)pwglGetProcAddress(#pfn);
5057 /* To bypass the opengl32 thunks load wglGetProcAddress from gdi32 (glXGetProcAddress wrapper) instead of opengl32's */
5058 mod_gl = GetModuleHandleA("gdi32.dll");
5062 /* Load WGL core functions from opengl32.dll */
5063 #define USE_WGL_FUNC(pfn) p##pfn = (void*)GetProcAddress(mod_gl, #pfn);
5067 if(!pwglGetProcAddress) {
5068 ERR("Unable to load wglGetProcAddress!\n");
5072 /* Dynamically load all GL core functions */
5076 /* Load glFinish and glFlush from opengl32.dll even if we're not using WIN32 opengl
5077 * otherwise because we have to use winex11.drv's override
5079 #ifdef USE_WIN32_OPENGL
5080 wglFinish = (void*)GetProcAddress(mod_gl, "glFinish");
5081 wglFlush = (void*)GetProcAddress(mod_gl, "glFlush");
5083 wglFinish = (void*)pwglGetProcAddress("wglFinish");
5084 wglFlush = (void*)pwglGetProcAddress("wglFlush");
5087 glEnableWINE = glEnable;
5088 glDisableWINE = glDisable;
5090 /* For now only one default adapter */
5092 struct wined3d_adapter *adapter = &This->adapters[0];
5093 const struct wined3d_gl_info *gl_info = &adapter->gl_info;
5094 struct wined3d_fake_gl_ctx fake_gl_ctx = {0};
5098 WineD3D_PixelFormat *cfgs;
5099 DISPLAY_DEVICEW DisplayDevice;
5102 TRACE("Initializing default adapter\n");
5103 adapter->ordinal = 0;
5104 adapter->monitorPoint.x = -1;
5105 adapter->monitorPoint.y = -1;
5107 if (!AllocateLocallyUniqueId(&adapter->luid))
5109 DWORD err = GetLastError();
5110 ERR("Failed to set adapter LUID (%#x).\n", err);
5113 TRACE("Allocated LUID %08x:%08x for adapter.\n",
5114 adapter->luid.HighPart, adapter->luid.LowPart);
5116 if (!WineD3D_CreateFakeGLContext(&fake_gl_ctx))
5118 ERR("Failed to get a gl context for default adapter\n");
5122 ret = IWineD3DImpl_FillGLCaps(adapter);
5124 ERR("Failed to initialize gl caps for default adapter\n");
5125 WineD3D_ReleaseFakeGLContext(&fake_gl_ctx);
5128 ret = initPixelFormats(&adapter->gl_info, adapter->driver_info.vendor);
5130 ERR("Failed to init gl formats\n");
5131 WineD3D_ReleaseFakeGLContext(&fake_gl_ctx);
5135 hdc = fake_gl_ctx.dc;
5137 /* Use the VideoRamSize registry setting when set */
5138 if(wined3d_settings.emulated_textureram)
5139 adapter->TextureRam = wined3d_settings.emulated_textureram;
5141 adapter->TextureRam = adapter->gl_info.vidmem;
5142 adapter->UsedTextureRam = 0;
5143 TRACE("Emulating %dMB of texture ram\n", adapter->TextureRam/(1024*1024));
5145 /* Initialize the Adapter's DeviceName which is required for ChangeDisplaySettings and friends */
5146 DisplayDevice.cb = sizeof(DisplayDevice);
5147 EnumDisplayDevicesW(NULL, 0 /* Adapter 0 = iDevNum 0 */, &DisplayDevice, 0);
5148 TRACE("DeviceName: %s\n", debugstr_w(DisplayDevice.DeviceName));
5149 strcpyW(adapter->DeviceName, DisplayDevice.DeviceName);
5151 if (gl_info->supported[WGL_ARB_PIXEL_FORMAT])
5158 attribute = WGL_NUMBER_PIXEL_FORMATS_ARB;
5159 GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc, 0, 0, 1, &attribute, &adapter->nCfgs));
5161 adapter->cfgs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, adapter->nCfgs *sizeof(WineD3D_PixelFormat));
5162 cfgs = adapter->cfgs;
5163 attribs[nAttribs++] = WGL_RED_BITS_ARB;
5164 attribs[nAttribs++] = WGL_GREEN_BITS_ARB;
5165 attribs[nAttribs++] = WGL_BLUE_BITS_ARB;
5166 attribs[nAttribs++] = WGL_ALPHA_BITS_ARB;
5167 attribs[nAttribs++] = WGL_COLOR_BITS_ARB;
5168 attribs[nAttribs++] = WGL_DEPTH_BITS_ARB;
5169 attribs[nAttribs++] = WGL_STENCIL_BITS_ARB;
5170 attribs[nAttribs++] = WGL_DRAW_TO_WINDOW_ARB;
5171 attribs[nAttribs++] = WGL_PIXEL_TYPE_ARB;
5172 attribs[nAttribs++] = WGL_DOUBLE_BUFFER_ARB;
5173 attribs[nAttribs++] = WGL_AUX_BUFFERS_ARB;
5175 for (iPixelFormat=1; iPixelFormat <= adapter->nCfgs; ++iPixelFormat)
5177 res = GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc, iPixelFormat, 0, nAttribs, attribs, values));
5182 /* Cache the pixel format */
5183 cfgs->iPixelFormat = iPixelFormat;
5184 cfgs->redSize = values[0];
5185 cfgs->greenSize = values[1];
5186 cfgs->blueSize = values[2];
5187 cfgs->alphaSize = values[3];
5188 cfgs->colorSize = values[4];
5189 cfgs->depthSize = values[5];
5190 cfgs->stencilSize = values[6];
5191 cfgs->windowDrawable = values[7];
5192 cfgs->iPixelType = values[8];
5193 cfgs->doubleBuffer = values[9];
5194 cfgs->auxBuffers = values[10];
5196 cfgs->numSamples = 0;
5197 /* Check multisample support */
5198 if (gl_info->supported[ARB_MULTISAMPLE])
5200 int attrib[2] = {WGL_SAMPLE_BUFFERS_ARB, WGL_SAMPLES_ARB};
5202 if(GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc, iPixelFormat, 0, 2, attrib, value))) {
5203 /* value[0] = WGL_SAMPLE_BUFFERS_ARB which tells whether multisampling is supported.
5204 * value[1] = number of multi sample buffers*/
5206 cfgs->numSamples = value[1];
5210 TRACE("iPixelFormat=%d, iPixelType=%#x, doubleBuffer=%d, RGBA=%d/%d/%d/%d, "
5211 "depth=%d, stencil=%d, samples=%d, windowDrawable=%d\n",
5212 cfgs->iPixelFormat, cfgs->iPixelType, cfgs->doubleBuffer,
5213 cfgs->redSize, cfgs->greenSize, cfgs->blueSize, cfgs->alphaSize,
5214 cfgs->depthSize, cfgs->stencilSize, cfgs->numSamples, cfgs->windowDrawable);
5220 int nCfgs = DescribePixelFormat(hdc, 0, 0, 0);
5221 adapter->cfgs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, nCfgs*sizeof(WineD3D_PixelFormat));
5222 adapter->nCfgs = 0; /* We won't accept all formats e.g. software accelerated ones will be skipped */
5224 cfgs = adapter->cfgs;
5225 for(iPixelFormat=1; iPixelFormat<=nCfgs; iPixelFormat++)
5227 PIXELFORMATDESCRIPTOR ppfd;
5229 res = DescribePixelFormat(hdc, iPixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &ppfd);
5233 /* We only want HW acceleration using an OpenGL ICD driver.
5234 * PFD_GENERIC_FORMAT = slow opengl 1.1 gdi software rendering
5235 * PFD_GENERIC_ACCELERATED = partial hw acceleration using a MCD driver (e.g. 3dfx minigl)
5237 if(ppfd.dwFlags & (PFD_GENERIC_FORMAT | PFD_GENERIC_ACCELERATED))
5239 TRACE("Skipping iPixelFormat=%d because it isn't ICD accelerated\n", iPixelFormat);
5243 cfgs->iPixelFormat = iPixelFormat;
5244 cfgs->redSize = ppfd.cRedBits;
5245 cfgs->greenSize = ppfd.cGreenBits;
5246 cfgs->blueSize = ppfd.cBlueBits;
5247 cfgs->alphaSize = ppfd.cAlphaBits;
5248 cfgs->colorSize = ppfd.cColorBits;
5249 cfgs->depthSize = ppfd.cDepthBits;
5250 cfgs->stencilSize = ppfd.cStencilBits;
5251 cfgs->windowDrawable = (ppfd.dwFlags & PFD_DRAW_TO_WINDOW) ? 1 : 0;
5252 cfgs->iPixelType = (ppfd.iPixelType == PFD_TYPE_RGBA) ? WGL_TYPE_RGBA_ARB : WGL_TYPE_COLORINDEX_ARB;
5253 cfgs->doubleBuffer = (ppfd.dwFlags & PFD_DOUBLEBUFFER) ? 1 : 0;
5254 cfgs->auxBuffers = ppfd.cAuxBuffers;
5255 cfgs->numSamples = 0;
5257 TRACE("iPixelFormat=%d, iPixelType=%#x, doubleBuffer=%d, RGBA=%d/%d/%d/%d, "
5258 "depth=%d, stencil=%d, windowDrawable=%d\n",
5259 cfgs->iPixelFormat, cfgs->iPixelType, cfgs->doubleBuffer,
5260 cfgs->redSize, cfgs->greenSize, cfgs->blueSize, cfgs->alphaSize,
5261 cfgs->depthSize, cfgs->stencilSize, cfgs->windowDrawable);
5266 /* 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 */
5269 ERR("Disabling Direct3D because no hardware accelerated pixel formats have been found!\n");
5271 WineD3D_ReleaseFakeGLContext(&fake_gl_ctx);
5272 HeapFree(GetProcessHeap(), 0, adapter->cfgs);
5277 /* D16, D24X8 and D24S8 are common depth / depth+stencil formats. All drivers support them though this doesn't
5278 * mean that the format is offered in hardware. For instance Geforce8 cards don't have offer D16 in hardware
5279 * but just fake it using D24(X8?) which is fine. D3D also allows that.
5280 * Some display drivers (i915 on Linux) only report mixed depth+stencil formats like D24S8. MSDN clearly mentions
5281 * that only on lockable formats (e.g. D16_locked) the bit order is guaranteed and that on other formats the
5282 * driver is allowed to consume more bits EXCEPT for stencil bits.
5284 * Mark an adapter with this broken stencil behavior.
5286 adapter->brokenStencil = TRUE;
5287 for (i = 0, cfgs = adapter->cfgs; i < adapter->nCfgs; ++i)
5289 /* Nearly all drivers offer depth formats without stencil, only on i915 this if-statement won't be entered. */
5290 if(cfgs[i].depthSize && !cfgs[i].stencilSize) {
5291 adapter->brokenStencil = FALSE;
5296 WineD3D_ReleaseFakeGLContext(&fake_gl_ctx);
5298 select_shader_mode(&adapter->gl_info, &ps_selected_mode, &vs_selected_mode);
5299 fillGLAttribFuncs(&adapter->gl_info);
5300 adapter->opengl = TRUE;
5302 This->adapter_count = 1;
5303 TRACE("%u adapters successfully initialized\n", This->adapter_count);
5308 /* Initialize an adapter for ddraw-only memory counting */
5309 memset(This->adapters, 0, sizeof(This->adapters));
5310 This->adapters[0].ordinal = 0;
5311 This->adapters[0].opengl = FALSE;
5312 This->adapters[0].monitorPoint.x = -1;
5313 This->adapters[0].monitorPoint.y = -1;
5315 This->adapters[0].driver_info.name = "Display";
5316 This->adapters[0].driver_info.description = "WineD3D DirectDraw Emulation";
5317 if(wined3d_settings.emulated_textureram) {
5318 This->adapters[0].TextureRam = wined3d_settings.emulated_textureram;
5320 This->adapters[0].TextureRam = 8 * 1024 * 1024; /* This is plenty for a DDraw-only card */
5323 initPixelFormatsNoGL(&This->adapters[0].gl_info);
5325 This->adapter_count = 1;
5329 /**********************************************************
5330 * IWineD3D VTbl follows
5331 **********************************************************/
5333 static const struct IWineD3DVtbl IWineD3D_Vtbl =
5336 IWineD3DImpl_QueryInterface,
5337 IWineD3DImpl_AddRef,
5338 IWineD3DImpl_Release,
5340 IWineD3DImpl_GetParent,
5341 IWineD3DImpl_GetAdapterCount,
5342 IWineD3DImpl_RegisterSoftwareDevice,
5343 IWineD3DImpl_GetAdapterMonitor,
5344 IWineD3DImpl_GetAdapterModeCount,
5345 IWineD3DImpl_EnumAdapterModes,
5346 IWineD3DImpl_GetAdapterDisplayMode,
5347 IWineD3DImpl_GetAdapterIdentifier,
5348 IWineD3DImpl_CheckDeviceMultiSampleType,
5349 IWineD3DImpl_CheckDepthStencilMatch,
5350 IWineD3DImpl_CheckDeviceType,
5351 IWineD3DImpl_CheckDeviceFormat,
5352 IWineD3DImpl_CheckDeviceFormatConversion,
5353 IWineD3DImpl_GetDeviceCaps,
5354 IWineD3DImpl_CreateDevice
5357 static void STDMETHODCALLTYPE wined3d_null_wined3d_object_destroyed(void *parent) {}
5359 const struct wined3d_parent_ops wined3d_null_parent_ops =
5361 wined3d_null_wined3d_object_destroyed,
5364 HRESULT wined3d_init(IWineD3DImpl *wined3d, UINT version, IUnknown *parent)
5366 wined3d->lpVtbl = &IWineD3D_Vtbl;
5367 wined3d->dxVersion = version;
5369 wined3d->parent = parent;
5371 if (!InitAdapters(wined3d))
5373 WARN("Failed to initialize adapters.\n");
5376 MESSAGE("Direct3D%u is not available without OpenGL.\n", version);