wined3d: Use RECT instead of WINED3DRECT in fb_copy_to_texture_hwstretch.
[wine] / dlls / wined3d / directx.c
1 /*
2  * IWineD3D implementation
3  *
4  * Copyright 2002-2004 Jason Edmeades
5  * Copyright 2003-2004 Raphael Junqueira
6  * Copyright 2004 Christian Costa
7  * Copyright 2005 Oliver Stieber
8  * Copyright 2007-2008 Stefan Dösinger for CodeWeavers
9  * Copyright 2009 Henri Verbeet for CodeWeavers
10  *
11  * This library is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU Lesser General Public
13  * License as published by the Free Software Foundation; either
14  * version 2.1 of the License, or (at your option) any later version.
15  *
16  * This library is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19  * Lesser General Public License for more details.
20  *
21  * You should have received a copy of the GNU Lesser General Public
22  * License along with this library; if not, write to the Free Software
23  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24  */
25
26 #include "config.h"
27 #include "wined3d_private.h"
28
29 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
30 WINE_DECLARE_DEBUG_CHANNEL(d3d_caps);
31
32 #define GLINFO_LOCATION (*gl_info)
33 #define WINE_DEFAULT_VIDMEM (64 * 1024 * 1024)
34 #define MAKEDWORD_VERSION(maj, min)  ((maj & 0xffff) << 16) | (min & 0xffff)
35
36 /* The d3d device ID */
37 static const GUID IID_D3DDEVICE_D3DUID = { 0xaeb2cdd4, 0x6e41, 0x43ea, { 0x94,0x1c,0x83,0x61,0xcc,0x76,0x07,0x81 } };
38
39 /* Extension detection */
40 static const struct {
41     const char *extension_string;
42     GL_SupportedExt extension;
43     DWORD version;
44 } EXTENSION_MAP[] = {
45     /* APPLE */
46     {"GL_APPLE_client_storage",             APPLE_CLIENT_STORAGE,           0                           },
47     {"GL_APPLE_fence",                      APPLE_FENCE,                    0                           },
48     {"GL_APPLE_float_pixels",               APPLE_FLOAT_PIXELS,             0                           },
49     {"GL_APPLE_flush_buffer_range",         APPLE_FLUSH_BUFFER_RANGE,       0                           },
50     {"GL_APPLE_flush_render",               APPLE_FLUSH_RENDER,             0                           },
51     {"GL_APPLE_ycbcr_422",                  APPLE_YCBCR_422,                0                           },
52
53     /* ARB */
54     {"GL_ARB_color_buffer_float",           ARB_COLOR_BUFFER_FLOAT,         0                           },
55     {"GL_ARB_depth_buffer_float",           ARB_DEPTH_BUFFER_FLOAT,         0                           },
56     {"GL_ARB_depth_clamp",                  ARB_DEPTH_CLAMP,                0                           },
57     {"GL_ARB_depth_texture",                ARB_DEPTH_TEXTURE,              0                           },
58     {"GL_ARB_draw_buffers",                 ARB_DRAW_BUFFERS,               0                           },
59     {"GL_ARB_fragment_program",             ARB_FRAGMENT_PROGRAM,           0                           },
60     {"GL_ARB_fragment_shader",              ARB_FRAGMENT_SHADER,            0                           },
61     {"GL_ARB_framebuffer_object",           ARB_FRAMEBUFFER_OBJECT,         0                           },
62     {"GL_ARB_geometry_shader4",             ARB_GEOMETRY_SHADER4,           0                           },
63     {"GL_ARB_half_float_pixel",             ARB_HALF_FLOAT_PIXEL,           0                           },
64     {"GL_ARB_half_float_vertex",            ARB_HALF_FLOAT_VERTEX,          0                           },
65     {"GL_ARB_imaging",                      ARB_IMAGING,                    0                           },
66     {"GL_ARB_map_buffer_range",             ARB_MAP_BUFFER_RANGE,           0                           },
67     {"GL_ARB_multisample",                  ARB_MULTISAMPLE,                0                           }, /* needs GLX_ARB_MULTISAMPLE as well */
68     {"GL_ARB_multitexture",                 ARB_MULTITEXTURE,               0                           },
69     {"GL_ARB_occlusion_query",              ARB_OCCLUSION_QUERY,            0                           },
70     {"GL_ARB_pixel_buffer_object",          ARB_PIXEL_BUFFER_OBJECT,        0                           },
71     {"GL_ARB_point_parameters",             ARB_POINT_PARAMETERS,           0                           },
72     {"GL_ARB_point_sprite",                 ARB_POINT_SPRITE,               0                           },
73     {"GL_ARB_provoking_vertex",             ARB_PROVOKING_VERTEX,           0                           },
74     {"GL_ARB_shader_objects",               ARB_SHADER_OBJECTS,             0                           },
75     {"GL_ARB_shader_texture_lod",           ARB_SHADER_TEXTURE_LOD,         0                           },
76     {"GL_ARB_shading_language_100",         ARB_SHADING_LANGUAGE_100,       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                           },
94
95     /* ATI */
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                           },
101
102     /* EXT */
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                           },
131
132     /* NV */
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                           },
152
153     /* SGI */
154     {"GL_SGIS_generate_mipmap",             SGIS_GENERATE_MIPMAP,           0                           },
155 };
156
157 /**********************************************************
158  * Utility functions follow
159  **********************************************************/
160
161 static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType, WINED3DFORMAT AdapterFormat, DWORD Usage, WINED3DRESOURCETYPE RType, WINED3DFORMAT CheckFormat, WINED3DSURFTYPE SurfaceType);
162
163 const struct min_lookup minMipLookup[] =
164 {
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 */
169 };
170
171 const struct min_lookup minMipLookup_noFilter[] =
172 {
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 */
177 };
178
179 const struct min_lookup minMipLookup_noMip[] =
180 {
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 */
185 };
186
187 const GLenum magLookup[] =
188 {
189     /* NONE     POINT       LINEAR */
190     GL_NEAREST, GL_NEAREST, GL_LINEAR,
191 };
192
193 const GLenum magLookup_noFilter[] =
194 {
195     /* NONE     POINT       LINEAR */
196     GL_NEAREST, GL_NEAREST, GL_NEAREST,
197 };
198
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];
206
207 /**
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.
211  */
212
213 struct wined3d_fake_gl_ctx
214 {
215     HDC dc;
216     HWND wnd;
217     HGLRC gl_ctx;
218     HDC restore_dc;
219     HGLRC restore_gl_ctx;
220 };
221
222 static void WineD3D_ReleaseFakeGLContext(struct wined3d_fake_gl_ctx *ctx)
223 {
224     TRACE_(d3d_caps)("Destroying fake GL context.\n");
225
226     if (!pwglMakeCurrent(NULL, NULL))
227     {
228         ERR_(d3d_caps)("Failed to disable fake GL context.\n");
229     }
230
231     if (!pwglDeleteContext(ctx->gl_ctx))
232     {
233         DWORD err = GetLastError();
234         ERR("wglDeleteContext(%p) failed, last error %#x.\n", ctx->gl_ctx, err);
235     }
236
237     ReleaseDC(ctx->wnd, ctx->dc);
238     DestroyWindow(ctx->wnd);
239
240     if (ctx->restore_gl_ctx && !pwglMakeCurrent(ctx->restore_dc, ctx->restore_gl_ctx))
241     {
242         ERR_(d3d_caps)("Failed to restore previous GL context.\n");
243     }
244 }
245
246 static BOOL WineD3D_CreateFakeGLContext(struct wined3d_fake_gl_ctx *ctx)
247 {
248     PIXELFORMATDESCRIPTOR pfd;
249     int iPixelFormat;
250
251     TRACE("getting context...\n");
252
253     ctx->restore_dc = pwglGetCurrentDC();
254     ctx->restore_gl_ctx = pwglGetCurrentContext();
255
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);
259     if (!ctx->wnd)
260     {
261         ERR_(d3d_caps)("Failed to create a window.\n");
262         goto fail;
263     }
264
265     ctx->dc = GetDC(ctx->wnd);
266     if (!ctx->dc)
267     {
268         ERR_(d3d_caps)("Failed to get a DC.\n");
269         goto fail;
270     }
271
272     /* PixelFormat selection */
273     ZeroMemory(&pfd, sizeof(pfd));
274     pfd.nSize = sizeof(pfd);
275     pfd.nVersion = 1;
276     pfd.dwFlags = PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER | PFD_DRAW_TO_WINDOW; /* PFD_GENERIC_ACCELERATED */
277     pfd.iPixelType = PFD_TYPE_RGBA;
278     pfd.cColorBits = 32;
279     pfd.iLayerType = PFD_MAIN_PLANE;
280
281     iPixelFormat = ChoosePixelFormat(ctx->dc, &pfd);
282     if (!iPixelFormat)
283     {
284         /* If this happens something is very wrong as ChoosePixelFormat barely fails. */
285         ERR_(d3d_caps)("Can't find a suitable iPixelFormat.\n");
286         goto fail;
287     }
288     DescribePixelFormat(ctx->dc, iPixelFormat, sizeof(pfd), &pfd);
289     SetPixelFormat(ctx->dc, iPixelFormat, &pfd);
290
291     /* Create a GL context. */
292     ctx->gl_ctx = pwglCreateContext(ctx->dc);
293     if (!ctx->gl_ctx)
294     {
295         WARN_(d3d_caps)("Error creating default context for capabilities initialization.\n");
296         goto fail;
297     }
298
299     /* Make it the current GL context. */
300     if (!context_set_current(NULL))
301     {
302         ERR_(d3d_caps)("Failed to clear current D3D context.\n");
303     }
304
305     if (!pwglMakeCurrent(ctx->dc, ctx->gl_ctx))
306     {
307         ERR_(d3d_caps)("Failed to make fake GL context current.\n");
308         goto fail;
309     }
310
311     return TRUE;
312
313 fail:
314     if (ctx->gl_ctx) pwglDeleteContext(ctx->gl_ctx);
315     ctx->gl_ctx = NULL;
316     if (ctx->dc) ReleaseDC(ctx->wnd, ctx->dc);
317     ctx->dc = NULL;
318     if (ctx->wnd) DestroyWindow(ctx->wnd);
319     ctx->wnd = NULL;
320     if (ctx->restore_gl_ctx && !pwglMakeCurrent(ctx->restore_dc, ctx->restore_gl_ctx))
321     {
322         ERR_(d3d_caps)("Failed to restore previous GL context.\n");
323     }
324
325     return FALSE;
326 }
327
328 /* Adjust the amount of used texture memory */
329 long WineD3DAdapterChangeGLRam(IWineD3DDeviceImpl *D3DDevice, long glram)
330 {
331     struct wined3d_adapter *adapter = D3DDevice->adapter;
332
333     adapter->UsedTextureRam += glram;
334     TRACE("Adjusted gl ram by %ld to %d\n", glram, adapter->UsedTextureRam);
335     return adapter->UsedTextureRam;
336 }
337
338 static void wined3d_adapter_cleanup(struct wined3d_adapter *adapter)
339 {
340     HeapFree(GetProcessHeap(), 0, adapter->gl_info.gl_formats);
341     HeapFree(GetProcessHeap(), 0, adapter->cfgs);
342 }
343
344 /**********************************************************
345  * IUnknown parts follows
346  **********************************************************/
347
348 static HRESULT WINAPI IWineD3DImpl_QueryInterface(IWineD3D *iface,REFIID riid,LPVOID *ppobj)
349 {
350     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
351
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);
357         *ppobj = This;
358         return S_OK;
359     }
360     *ppobj = NULL;
361     return E_NOINTERFACE;
362 }
363
364 static ULONG WINAPI IWineD3DImpl_AddRef(IWineD3D *iface) {
365     IWineD3DImpl *This = (IWineD3DImpl *)iface;
366     ULONG refCount = InterlockedIncrement(&This->ref);
367
368     TRACE("(%p) : AddRef increasing from %d\n", This, refCount - 1);
369     return refCount;
370 }
371
372 static ULONG WINAPI IWineD3DImpl_Release(IWineD3D *iface) {
373     IWineD3DImpl *This = (IWineD3DImpl *)iface;
374     ULONG ref;
375     TRACE("(%p) : Releasing from %d\n", This, This->ref);
376     ref = InterlockedDecrement(&This->ref);
377     if (ref == 0) {
378         unsigned int i;
379
380         for (i = 0; i < This->adapter_count; ++i)
381         {
382             wined3d_adapter_cleanup(&This->adapters[i]);
383         }
384         HeapFree(GetProcessHeap(), 0, This);
385     }
386
387     return ref;
388 }
389
390 /**********************************************************
391  * IWineD3D parts follows
392  **********************************************************/
393
394 /* GL locking is done by the caller */
395 static inline BOOL test_arb_vs_offset_limit(const struct wined3d_gl_info *gl_info)
396 {
397     GLuint prog;
398     BOOL ret = FALSE;
399     const char *testcode =
400         "!!ARBvp1.0\n"
401         "PARAM C[66] = { program.env[0..65] };\n"
402         "ADDRESS A0;"
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"
406         "END\n";
407
408     while(glGetError());
409     GL_EXTCALL(glGenProgramsARB(1, &prog));
410     if(!prog) {
411         ERR("Failed to create an ARB offset limit test program\n");
412     }
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)));
419         ret = TRUE;
420     } else TRACE("OpenGL implementation allows offsets > 63\n");
421
422     GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, 0));
423     GL_EXTCALL(glDeleteProgramsARB(1, &prog));
424     checkGLcall("ARB vp offset limit test cleanup");
425
426     return ret;
427 }
428
429 static DWORD ver_for_ext(GL_SupportedExt ext)
430 {
431     unsigned int i;
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;
435         }
436     }
437     return 0;
438 }
439
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)
442 {
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;
447     return FALSE;
448 }
449
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)
452 {
453     if (card_vendor == HW_VENDOR_NVIDIA)
454     {
455         if (device == CARD_NVIDIA_GEFORCEFX_5800 || device == CARD_NVIDIA_GEFORCEFX_5600)
456         {
457             return TRUE;
458         }
459     }
460     return FALSE;
461 }
462
463 static BOOL match_apple(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
464         enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
465 {
466     /* MacOS has various specialities in the extensions it advertises. Some have to be loaded from
467      * the opengl 1.2+ core, while other extensions are advertised, but software emulated. So try to
468      * detect the Apple OpenGL implementation to apply some extension fixups afterwards.
469      *
470      * Detecting this isn't really easy. The vendor string doesn't mention Apple. Compile-time checks
471      * aren't sufficient either because a Linux binary may display on a macos X server via remote X11.
472      * So try to detect the GL implementation by looking at certain Apple extensions. Some extensions
473      * like client storage might be supported on other implementations too, but GL_APPLE_flush_render
474      * is specific to the Mac OS X window management, and GL_APPLE_ycbcr_422 is QuickTime specific. So
475      * the chance that other implementations support them is rather small since Win32 QuickTime uses
476      * DirectDraw, not OpenGL.
477      *
478      * This test has been moved into wined3d_guess_gl_vendor()
479      */
480     if (gl_vendor == GL_VENDOR_APPLE)
481     {
482         return TRUE;
483     }
484     return FALSE;
485 }
486
487 /* Context activation is done by the caller. */
488 static void test_pbo_functionality(struct wined3d_gl_info *gl_info)
489 {
490     /* Some OpenGL implementations, namely Apple's Geforce 8 driver, advertises PBOs,
491      * but glTexSubImage from a PBO fails miserably, with the first line repeated over
492      * all the texture. This function detects this bug by its symptom and disables PBOs
493      * if the test fails.
494      *
495      * The test uploads a 4x4 texture via the PBO in the "native" format GL_BGRA,
496      * GL_UNSIGNED_INT_8_8_8_8_REV. This format triggers the bug, and it is what we use
497      * for D3DFMT_A8R8G8B8. Then the texture is read back without any PBO and the data
498      * read back is compared to the original. If they are equal PBOs are assumed to work,
499      * otherwise the PBO extension is disabled. */
500     GLuint texture, pbo;
501     static const unsigned int pattern[] =
502     {
503         0x00000000, 0x000000ff, 0x0000ff00, 0x40ff0000,
504         0x80ffffff, 0x40ffff00, 0x00ff00ff, 0x0000ffff,
505         0x00ffff00, 0x00ff00ff, 0x0000ffff, 0x000000ff,
506         0x80ff00ff, 0x0000ffff, 0x00ff00ff, 0x40ff00ff
507     };
508     unsigned int check[sizeof(pattern) / sizeof(pattern[0])];
509
510     /* No PBO -> No point in testing them. */
511     if (!gl_info->supported[ARB_PIXEL_BUFFER_OBJECT]) return;
512
513     ENTER_GL();
514
515     while (glGetError());
516     glGenTextures(1, &texture);
517     glBindTexture(GL_TEXTURE_2D, texture);
518
519     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
520     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 4, 4, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, 0);
521     checkGLcall("Specifying the PBO test texture");
522
523     GL_EXTCALL(glGenBuffersARB(1, &pbo));
524     GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pbo));
525     GL_EXTCALL(glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, sizeof(pattern), pattern, GL_STREAM_DRAW_ARB));
526     checkGLcall("Specifying the PBO test pbo");
527
528     glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL);
529     checkGLcall("Loading the PBO test texture");
530
531     GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
532     wglFinish(); /* just to be sure */
533
534     memset(check, 0, sizeof(check));
535     glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, check);
536     checkGLcall("Reading back the PBO test texture");
537
538     glDeleteTextures(1, &texture);
539     GL_EXTCALL(glDeleteBuffersARB(1, &pbo));
540     checkGLcall("PBO test cleanup");
541
542     LEAVE_GL();
543
544     if (memcmp(check, pattern, sizeof(check)))
545     {
546         WARN_(d3d_caps)("PBO test failed, read back data doesn't match original.\n");
547         WARN_(d3d_caps)("Disabling PBOs. This may result in slower performance.\n");
548         gl_info->supported[ARB_PIXEL_BUFFER_OBJECT] = FALSE;
549     }
550     else
551     {
552         TRACE_(d3d_caps)("PBO test successful.\n");
553     }
554 }
555
556 static BOOL match_apple_intel(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
557         enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
558 {
559     return (card_vendor == HW_VENDOR_INTEL) && (gl_vendor == GL_VENDOR_APPLE);
560 }
561
562 static BOOL match_apple_nonr500ati(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
563         enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
564 {
565     if (gl_vendor != GL_VENDOR_APPLE) return FALSE;
566     if (card_vendor != HW_VENDOR_ATI) return FALSE;
567     if (device == CARD_ATI_RADEON_X1600) return FALSE;
568     return TRUE;
569 }
570
571 static BOOL match_fglrx(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
572         enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
573 {
574     return (gl_vendor == GL_VENDOR_ATI);
575
576 }
577
578 static BOOL match_dx10_capable(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
579         enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
580 {
581     /* DX9 cards support 40 single float varyings in hardware, most drivers report 32. ATI misreports
582      * 44 varyings. So assume that if we have more than 44 varyings we have a dx10 card.
583      * This detection is for the gl_ClipPos varying quirk. If a d3d9 card really supports more than 44
584      * varyings and we subtract one in dx9 shaders its not going to hurt us because the dx9 limit is
585      * hardcoded
586      *
587      * dx10 cards usually have 64 varyings */
588     return gl_info->limits.glsl_varyings > 44;
589 }
590
591 /* A GL context is provided by the caller */
592 static BOOL match_allows_spec_alpha(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
593         enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
594 {
595     GLenum error;
596     DWORD data[16];
597
598     if (!gl_info->supported[EXT_SECONDARY_COLOR]) return FALSE;
599
600     ENTER_GL();
601     while(glGetError());
602     GL_EXTCALL(glSecondaryColorPointerEXT)(4, GL_UNSIGNED_BYTE, 4, data);
603     error = glGetError();
604     LEAVE_GL();
605
606     if(error == GL_NO_ERROR)
607     {
608         TRACE("GL Implementation accepts 4 component specular color pointers\n");
609         return TRUE;
610     }
611     else
612     {
613         TRACE("GL implementation does not accept 4 component specular colors, error %s\n",
614               debug_glerror(error));
615         return FALSE;
616     }
617 }
618
619 static BOOL match_apple_nvts(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
620         enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
621 {
622     if (!match_apple(gl_info, gl_renderer, gl_vendor, card_vendor, device)) return FALSE;
623     return gl_info->supported[NV_TEXTURE_SHADER];
624 }
625
626 /* A GL context is provided by the caller */
627 static BOOL match_broken_nv_clip(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
628         enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
629 {
630     GLuint prog;
631     BOOL ret = FALSE;
632     GLint pos;
633     const char *testcode =
634         "!!ARBvp1.0\n"
635         "OPTION NV_vertex_program2;\n"
636         "MOV result.clip[0], 0.0;\n"
637         "MOV result.position, 0.0;\n"
638         "END\n";
639
640     if (!gl_info->supported[NV_VERTEX_PROGRAM2_OPTION]) return FALSE;
641
642     ENTER_GL();
643     while(glGetError());
644
645     GL_EXTCALL(glGenProgramsARB(1, &prog));
646     if(!prog)
647     {
648         ERR("Failed to create the NVvp clip test program\n");
649         LEAVE_GL();
650         return FALSE;
651     }
652     GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, prog));
653     GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
654                                   strlen(testcode), testcode));
655     glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &pos);
656     if(pos != -1)
657     {
658         WARN("GL_NV_vertex_program2_option result.clip[] test failed\n");
659         TRACE("error: %s\n", debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
660         ret = TRUE;
661         while(glGetError());
662     }
663     else TRACE("GL_NV_vertex_program2_option result.clip[] test passed\n");
664
665     GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, 0));
666     GL_EXTCALL(glDeleteProgramsARB(1, &prog));
667     checkGLcall("GL_NV_vertex_program2_option result.clip[] test cleanup");
668
669     LEAVE_GL();
670     return ret;
671 }
672
673 /* Context activation is done by the caller. */
674 static BOOL match_fbo_tex_update(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
675         enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
676 {
677     char data[4 * 4 * 4];
678     GLuint tex, fbo;
679     GLenum status;
680
681     if (wined3d_settings.offscreen_rendering_mode != ORM_FBO) return FALSE;
682
683     memset(data, 0xcc, sizeof(data));
684
685     ENTER_GL();
686
687     glGenTextures(1, &tex);
688     glBindTexture(GL_TEXTURE_2D, tex);
689     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
690     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
691     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 4, 4, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL);
692     checkGLcall("glTexImage2D");
693
694     gl_info->fbo_ops.glGenFramebuffers(1, &fbo);
695     gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
696     gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0);
697     checkGLcall("glFramebufferTexture2D");
698
699     status = gl_info->fbo_ops.glCheckFramebufferStatus(GL_FRAMEBUFFER);
700     if (status != GL_FRAMEBUFFER_COMPLETE) ERR("FBO status %#x\n", status);
701     checkGLcall("glCheckFramebufferStatus");
702
703     memset(data, 0x11, sizeof(data));
704     glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, data);
705     checkGLcall("glTexSubImage2D");
706
707     glClearColor(0.996, 0.729, 0.745, 0.792);
708     glClear(GL_COLOR_BUFFER_BIT);
709     checkGLcall("glClear");
710
711     glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, data);
712     checkGLcall("glGetTexImage");
713
714     gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
715     gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, 0);
716     glBindTexture(GL_TEXTURE_2D, 0);
717     checkGLcall("glBindTexture");
718
719     gl_info->fbo_ops.glDeleteFramebuffers(1, &fbo);
720     glDeleteTextures(1, &tex);
721     checkGLcall("glDeleteTextures");
722
723     LEAVE_GL();
724
725     return *(DWORD *)data == 0x11111111;
726 }
727
728 static void quirk_arb_constants(struct wined3d_gl_info *gl_info)
729 {
730     TRACE_(d3d_caps)("Using ARB vs constant limit(=%u) for GLSL.\n", gl_info->limits.arb_vs_native_constants);
731     gl_info->limits.glsl_vs_float_constants = gl_info->limits.arb_vs_native_constants;
732     TRACE_(d3d_caps)("Using ARB ps constant limit(=%u) for GLSL.\n", gl_info->limits.arb_ps_native_constants);
733     gl_info->limits.glsl_ps_float_constants = gl_info->limits.arb_ps_native_constants;
734 }
735
736 static void quirk_apple_glsl_constants(struct wined3d_gl_info *gl_info)
737 {
738     quirk_arb_constants(gl_info);
739     /* MacOS needs uniforms for relative addressing offsets. This can accumulate to quite a few uniforms.
740      * Beyond that the general uniform isn't optimal, so reserve a number of uniforms. 12 vec4's should
741      * allow 48 different offsets or other helper immediate values. */
742     TRACE_(d3d_caps)("Reserving 12 GLSL constants for compiler private use.\n");
743     gl_info->reserved_glsl_constants = max(gl_info->reserved_glsl_constants, 12);
744 }
745
746 /* fglrx crashes with a very bad kernel panic if GL_POINT_SPRITE_ARB is set to GL_COORD_REPLACE_ARB
747  * on more than one texture unit. This means that the d3d9 visual point size test will cause a
748  * kernel panic on any machine running fglrx 9.3(latest that supports r300 to r500 cards). This
749  * quirk only enables point sprites on the first texture unit. This keeps point sprites working in
750  * most games, but avoids the crash
751  *
752  * A more sophisticated way would be to find all units that need texture coordinates and enable
753  * point sprites for one if only one is found, and software emulate point sprites in drawStridedSlow
754  * if more than one unit needs texture coordinates(This requires software ffp and vertex shaders though)
755  *
756  * Note that disabling the extension entirely does not gain predictability because there is no point
757  * sprite capability flag in d3d, so the potential rendering bugs are the same if we disable the extension. */
758 static void quirk_one_point_sprite(struct wined3d_gl_info *gl_info)
759 {
760     if (gl_info->supported[ARB_POINT_SPRITE])
761     {
762         TRACE("Limiting point sprites to one texture unit.\n");
763         gl_info->limits.point_sprite_units = 1;
764     }
765 }
766
767 static void quirk_ati_dx9(struct wined3d_gl_info *gl_info)
768 {
769     quirk_arb_constants(gl_info);
770
771     /* MacOS advertises GL_ARB_texture_non_power_of_two on ATI r500 and earlier cards, although
772      * these cards only support GL_ARB_texture_rectangle(D3DPTEXTURECAPS_NONPOW2CONDITIONAL).
773      * If real NP2 textures are used, the driver falls back to software. We could just remove the
774      * extension and use GL_ARB_texture_rectangle instead, but texture_rectangle is inconventient
775      * due to the non-normalized texture coordinates. Thus set an internal extension flag,
776      * GL_WINE_normalized_texrect, which signals the code that it can use non power of two textures
777      * as per GL_ARB_texture_non_power_of_two, but has to stick to the texture_rectangle limits.
778      *
779      * fglrx doesn't advertise GL_ARB_texture_non_power_of_two, but it advertises opengl 2.0 which
780      * has this extension promoted to core. The extension loading code sets this extension supported
781      * due to that, so this code works on fglrx as well. */
782     if(gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO])
783     {
784         TRACE("GL_ARB_texture_non_power_of_two advertised on R500 or earlier card, removing.\n");
785         gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] = FALSE;
786         gl_info->supported[WINE_NORMALIZED_TEXRECT] = TRUE;
787     }
788
789     /* fglrx has the same structural issues as the one described in quirk_apple_glsl_constants, although
790      * it is generally more efficient. Reserve just 8 constants. */
791     TRACE_(d3d_caps)("Reserving 8 GLSL constants for compiler private use.\n");
792     gl_info->reserved_glsl_constants = max(gl_info->reserved_glsl_constants, 8);
793 }
794
795 static void quirk_no_np2(struct wined3d_gl_info *gl_info)
796 {
797     /*  The nVidia GeForceFX series reports OpenGL 2.0 capabilities with the latest drivers versions, but
798      *  doesn't explicitly advertise the ARB_tex_npot extension in the GL extension string.
799      *  This usually means that ARB_tex_npot is supported in hardware as long as the application is staying
800      *  within the limits enforced by the ARB_texture_rectangle extension. This however is not true for the
801      *  FX series, which instantly falls back to a slower software path as soon as ARB_tex_npot is used.
802      *  We therefore completely remove ARB_tex_npot from the list of supported extensions.
803      *
804      *  Note that wine_normalized_texrect can't be used in this case because internally it uses ARB_tex_npot,
805      *  triggering the software fallback. There is not much we can do here apart from disabling the
806      *  software-emulated extension and reenable ARB_tex_rect (which was previously disabled
807      *  in IWineD3DImpl_FillGLCaps).
808      *  This fixup removes performance problems on both the FX 5900 and FX 5700 (e.g. for framebuffer
809      *  post-processing effects in the game "Max Payne 2").
810      *  The behaviour can be verified through a simple test app attached in bugreport #14724. */
811     TRACE("GL_ARB_texture_non_power_of_two advertised through OpenGL 2.0 on NV FX card, removing.\n");
812     gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] = FALSE;
813     gl_info->supported[ARB_TEXTURE_RECTANGLE] = TRUE;
814 }
815
816 static void quirk_texcoord_w(struct wined3d_gl_info *gl_info)
817 {
818     /* The Intel GPUs on MacOS set the .w register of texcoords to 0.0 by default, which causes problems
819      * with fixed function fragment processing. Ideally this flag should be detected with a test shader
820      * and OpenGL feedback mode, but some GL implementations (MacOS ATI at least, probably all MacOS ones)
821      * do not like vertex shaders in feedback mode and return an error, even though it should be valid
822      * according to the spec.
823      *
824      * We don't want to enable this on all cards, as it adds an extra instruction per texcoord used. This
825      * makes the shader slower and eats instruction slots which should be available to the d3d app.
826      *
827      * ATI Radeon HD 2xxx cards on MacOS have the issue. Instead of checking for the buggy cards, blacklist
828      * all radeon cards on Macs and whitelist the good ones. That way we're prepared for the future. If
829      * this workaround is activated on cards that do not need it, it won't break things, just affect
830      * performance negatively. */
831     TRACE("Enabling vertex texture coord fixes in vertex shaders.\n");
832     gl_info->quirks |= WINED3D_QUIRK_SET_TEXCOORD_W;
833 }
834
835 static void quirk_clip_varying(struct wined3d_gl_info *gl_info)
836 {
837     gl_info->quirks |= WINED3D_QUIRK_GLSL_CLIP_VARYING;
838 }
839
840 static void quirk_allows_specular_alpha(struct wined3d_gl_info *gl_info)
841 {
842     gl_info->quirks |= WINED3D_QUIRK_ALLOWS_SPECULAR_ALPHA;
843 }
844
845 static void quirk_apple_nvts(struct wined3d_gl_info *gl_info)
846 {
847     gl_info->supported[NV_TEXTURE_SHADER] = FALSE;
848     gl_info->supported[NV_TEXTURE_SHADER2] = FALSE;
849 }
850
851 static void quirk_disable_nvvp_clip(struct wined3d_gl_info *gl_info)
852 {
853     gl_info->quirks |= WINED3D_QUIRK_NV_CLIP_BROKEN;
854 }
855
856 static void quirk_fbo_tex_update(struct wined3d_gl_info *gl_info)
857 {
858     gl_info->quirks |= WINED3D_QUIRK_FBO_TEX_UPDATE;
859 }
860
861 struct driver_quirk
862 {
863     BOOL (*match)(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
864             enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device);
865     void (*apply)(struct wined3d_gl_info *gl_info);
866     const char *description;
867 };
868
869 static const struct driver_quirk quirk_table[] =
870 {
871     {
872         match_ati_r300_to_500,
873         quirk_ati_dx9,
874         "ATI GLSL constant and normalized texrect quirk"
875     },
876     /* MacOS advertises more GLSL vertex shader uniforms than supported by the hardware, and if more are
877      * used it falls back to software. While the compiler can detect if the shader uses all declared
878      * uniforms, the optimization fails if the shader uses relative addressing. So any GLSL shader
879      * using relative addressing falls back to software.
880      *
881      * ARB vp gives the correct amount of uniforms, so use it instead of GLSL. */
882     {
883         match_apple,
884         quirk_apple_glsl_constants,
885         "Apple GLSL uniform override"
886     },
887     {
888         match_geforce5,
889         quirk_no_np2,
890         "Geforce 5 NP2 disable"
891     },
892     {
893         match_apple_intel,
894         quirk_texcoord_w,
895         "Init texcoord .w for Apple Intel GPU driver"
896     },
897     {
898         match_apple_nonr500ati,
899         quirk_texcoord_w,
900         "Init texcoord .w for Apple ATI >= r600 GPU driver"
901     },
902     {
903         match_fglrx,
904         quirk_one_point_sprite,
905         "Fglrx point sprite crash workaround"
906     },
907     {
908         match_dx10_capable,
909         quirk_clip_varying,
910         "Reserved varying for gl_ClipPos"
911     },
912     {
913         /* GL_EXT_secondary_color does not allow 4 component secondary colors, but most
914          * GL implementations accept it. The Mac GL is the only implementation known to
915          * reject it.
916          *
917          * If we can pass 4 component specular colors, do it, because (a) we don't have
918          * to screw around with the data, and (b) the D3D fixed function vertex pipeline
919          * passes specular alpha to the pixel shader if any is used. Otherwise the
920          * specular alpha is used to pass the fog coordinate, which we pass to opengl
921          * via GL_EXT_fog_coord.
922          */
923         match_allows_spec_alpha,
924         quirk_allows_specular_alpha,
925         "Allow specular alpha quirk"
926     },
927     {
928         /* The pixel formats provided by GL_NV_texture_shader are broken on OSX
929          * (rdar://5682521).
930          */
931         match_apple_nvts,
932         quirk_apple_nvts,
933         "Apple NV_texture_shader disable"
934     },
935     {
936         match_broken_nv_clip,
937         quirk_disable_nvvp_clip,
938         "Apple NV_vertex_program clip bug quirk"
939     },
940     {
941         match_fbo_tex_update,
942         quirk_fbo_tex_update,
943         "FBO rebind for attachment updates"
944     },
945 };
946
947 /* Certain applications (Steam) complain if we report an outdated driver version. In general,
948  * reporting a driver version is moot because we are not the Windows driver, and we have different
949  * bugs, features, etc.
950  *
951  * The driver version has the form "x.y.z.w".
952  *
953  * "x" is the Windows version the driver is meant for:
954  * 4 -> 95/98/NT4
955  * 5 -> 2000
956  * 6 -> 2000/XP
957  * 7 -> Vista
958  * 8 -> Win 7
959  *
960  * "y" is the Direct3D level the driver supports:
961  * 11 -> d3d6
962  * 12 -> d3d7
963  * 13 -> d3d8
964  * 14 -> d3d9
965  * 15 -> d3d10
966  *
967  * "z" is unknown, possibly vendor specific.
968  *
969  * "w" is the vendor specific driver version.
970  */
971 struct driver_version_information
972 {
973     WORD vendor;                    /* reported PCI card vendor ID  */
974     WORD card;                      /* reported PCI card device ID  */
975     const char *description;        /* Description of the card e.g. NVIDIA RIVA TNT */
976     WORD d3d_level;                 /* driver hiword to report      */
977     WORD lopart_hi, lopart_lo;      /* driver loword to report      */
978 };
979
980 static const struct driver_version_information driver_version_table[] =
981 {
982     /* Nvidia drivers. Geforce6 and newer cards are supported by the current driver (180.x)
983      * 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
984      * Geforce2MX/3/4 up to 96.x - driver uses numbering 9.6.8.9 for 96.89
985      * TNT/Geforce1/2 up to 71.x - driver uses numbering 7.1.8.6 for 71.86
986      *
987      * All version numbers used below are from the Linux nvidia drivers. */
988     {HW_VENDOR_NVIDIA,     CARD_NVIDIA_RIVA_TNT,           "NVIDIA RIVA TNT",                  1,  8,  6      },
989     {HW_VENDOR_NVIDIA,     CARD_NVIDIA_RIVA_TNT2,          "NVIDIA RIVA TNT2/TNT2 Pro",        1,  8,  6      },
990     {HW_VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE,            "NVIDIA GeForce 256",               1,  8,  6      },
991     {HW_VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE2_MX,        "NVIDIA GeForce2 MX/MX 400",        6,  4,  3      },
992     {HW_VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE2,           "NVIDIA GeForce2 GTS/GeForce2 Pro", 1,  8,  6      },
993     {HW_VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE3,           "NVIDIA GeForce3",                  6,  10, 9371   },
994     {HW_VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE4_MX,        "NVIDIA GeForce4 MX 460",           6,  10, 9371   },
995     {HW_VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE4_TI4200,    "NVIDIA GeForce4 Ti 4200",          6,  10, 9371   },
996     {HW_VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCEFX_5200,     "NVIDIA GeForce FX 5200",           15, 11, 7516   },
997     {HW_VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCEFX_5600,     "NVIDIA GeForce FX 5600",           15, 11, 7516   },
998     {HW_VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCEFX_5800,     "NVIDIA GeForce FX 5800",           15, 11, 7516   },
999     {HW_VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_6200,       "NVIDIA GeForce 6200",              15, 11, 8618   },
1000     {HW_VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_6600GT,     "NVIDIA GeForce 6600 GT",           15, 11, 8618   },
1001     {HW_VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_6800,       "NVIDIA GeForce 6800",              15, 11, 8618   },
1002     {HW_VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_7300,       "NVIDIA GeForce Go 7300",           15, 11, 8585   },
1003     {HW_VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_7400,       "NVIDIA GeForce Go 7400",           15, 11, 8585   },
1004     {HW_VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_7600,       "NVIDIA GeForce 7600 GT",           15, 11, 8618   },
1005     {HW_VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_7800GT,     "NVIDIA GeForce 7800 GT",           15, 11, 8618   },
1006     {HW_VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_8300GS,     "NVIDIA GeForce 8300 GS",           15, 11, 8618   },
1007     {HW_VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_8600GT,     "NVIDIA GeForce 8600 GT",           15, 11, 8618   },
1008     {HW_VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_8600MGT,    "NVIDIA GeForce 8600M GT",          15, 11, 8585   },
1009     {HW_VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_8800GTS,    "NVIDIA GeForce 8800 GTS",          15, 11, 8618   },
1010     {HW_VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_9200,       "NVIDIA GeForce 9200",              15, 11, 8618   },
1011     {HW_VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_9400GT,     "NVIDIA GeForce 9400 GT",           15, 11, 8618   },
1012     {HW_VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_9500GT,     "NVIDIA GeForce 9500 GT",           15, 11, 8618   },
1013     {HW_VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_9600GT,     "NVIDIA GeForce 9600 GT",           15, 11, 8618   },
1014     {HW_VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_9800GT,     "NVIDIA GeForce 9800 GT",           15, 11, 8618   },
1015     {HW_VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_GTX260,     "NVIDIA GeForce GTX 260",           15, 11, 8618   },
1016     {HW_VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_GTX275,     "NVIDIA GeForce GTX 275",           15, 11, 8618   },
1017     {HW_VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_GTX280,     "NVIDIA GeForce GTX 280",           15, 11, 8618   },
1018     {HW_VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_GT240,      "NVIDIA GeForce GT 240",            15, 11, 8618   },
1019
1020     /* ATI cards. The driver versions are somewhat similar, but not quite the same. Let's hardcode. */
1021     {HW_VENDOR_ATI,        CARD_ATI_RADEON_9500,           "ATI Radeon 9500",                  14, 10, 6764    },
1022     {HW_VENDOR_ATI,        CARD_ATI_RADEON_X700,           "ATI Radeon X700 SE",               14, 10, 6764    },
1023     {HW_VENDOR_ATI,        CARD_ATI_RADEON_X1600,          "ATI Radeon X1600 Series",          14, 10, 6764    },
1024     {HW_VENDOR_ATI,        CARD_ATI_RADEON_HD2300,         "ATI Mobility Radeon HD 2300",      14, 10, 6764    },
1025     {HW_VENDOR_ATI,        CARD_ATI_RADEON_HD2600,         "ATI Mobility Radeon HD 2600",      14, 10, 6764    },
1026     {HW_VENDOR_ATI,        CARD_ATI_RADEON_HD2900,         "ATI Radeon HD 2900 XT",            14, 10, 6764    },
1027     {HW_VENDOR_ATI,        CARD_ATI_RADEON_HD4350,         "ATI Radeon HD 4350",               14, 10, 6764    },
1028     {HW_VENDOR_ATI,        CARD_ATI_RADEON_HD4600,         "ATI Radeon HD 4600 Series",        14, 10, 6764    },
1029     {HW_VENDOR_ATI,        CARD_ATI_RADEON_HD4700,         "ATI Radeon HD 4700 Series",        14, 10, 6764    },
1030     {HW_VENDOR_ATI,        CARD_ATI_RADEON_HD4800,         "ATI Radeon HD 4800 Series",        14, 10, 6764    },
1031     {HW_VENDOR_ATI,        CARD_ATI_RADEON_HD5700,         "ATI Radeon HD 5700 Series",        14, 10, 8681    },
1032     {HW_VENDOR_ATI,        CARD_ATI_RADEON_HD5800,         "ATI Radeon HD 5800 Series",        14, 10, 8681    },
1033
1034     /* TODO: Add information about legacy ATI hardware, Intel and other cards. */
1035 };
1036
1037 static void init_driver_info(struct wined3d_driver_info *driver_info,
1038         enum wined3d_pci_vendor vendor, enum wined3d_pci_device device)
1039 {
1040     OSVERSIONINFOW os_version;
1041     WORD driver_os_version;
1042     unsigned int i;
1043
1044     if (wined3d_settings.pci_vendor_id != PCI_VENDOR_NONE)
1045     {
1046         TRACE_(d3d_caps)("Overriding PCI vendor ID with: %04x\n", wined3d_settings.pci_vendor_id);
1047         vendor = wined3d_settings.pci_vendor_id;
1048     }
1049     driver_info->vendor = vendor;
1050
1051     if (wined3d_settings.pci_device_id != PCI_DEVICE_NONE)
1052     {
1053         TRACE_(d3d_caps)("Overriding PCI device ID with: %04x\n", wined3d_settings.pci_device_id);
1054         device = wined3d_settings.pci_device_id;
1055     }
1056     driver_info->device = device;
1057
1058     switch (vendor)
1059     {
1060         case HW_VENDOR_ATI:
1061             driver_info->name = "ati2dvag.dll";
1062             break;
1063
1064         case HW_VENDOR_NVIDIA:
1065             driver_info->name = "nv4_disp.dll";
1066             break;
1067
1068         case HW_VENDOR_INTEL:
1069         default:
1070             FIXME_(d3d_caps)("Unhandled vendor %04x.\n", vendor);
1071             driver_info->name = "Display";
1072             break;
1073     }
1074
1075     memset(&os_version, 0, sizeof(os_version));
1076     os_version.dwOSVersionInfoSize = sizeof(os_version);
1077     if (!GetVersionExW(&os_version))
1078     {
1079         ERR("Failed to get OS version, reporting 2000/XP.\n");
1080         driver_os_version = 6;
1081     }
1082     else
1083     {
1084         TRACE("OS version %u.%u.\n", os_version.dwMajorVersion, os_version.dwMinorVersion);
1085         switch (os_version.dwMajorVersion)
1086         {
1087             case 4:
1088                 driver_os_version = 4;
1089                 break;
1090
1091             case 5:
1092                 driver_os_version = 6;
1093                 break;
1094
1095             case 6:
1096                 if (os_version.dwMinorVersion == 0)
1097                 {
1098                     driver_os_version = 7;
1099                 }
1100                 else
1101                 {
1102                     if (os_version.dwMinorVersion > 1)
1103                     {
1104                         FIXME("Unhandled OS version %u.%u, reporting Win 7.\n",
1105                                 os_version.dwMajorVersion, os_version.dwMinorVersion);
1106                     }
1107                     driver_os_version = 8;
1108                 }
1109                 break;
1110
1111             default:
1112                 FIXME("Unhandled OS version %u.%u, reporting 2000/XP.\n",
1113                         os_version.dwMajorVersion, os_version.dwMinorVersion);
1114                 driver_os_version = 6;
1115                 break;
1116         }
1117     }
1118
1119     driver_info->description = "Direct3D HAL";
1120     driver_info->version_high = MAKEDWORD_VERSION(driver_os_version, 15);
1121     driver_info->version_low = MAKEDWORD_VERSION(8, 6); /* Nvidia RIVA TNT, arbitrary */
1122
1123     for (i = 0; i < (sizeof(driver_version_table) / sizeof(driver_version_table[0])); ++i)
1124     {
1125         if (vendor == driver_version_table[i].vendor && device == driver_version_table[i].card)
1126         {
1127             TRACE_(d3d_caps)("Found card %04x:%04x in driver DB.\n", vendor, device);
1128
1129             driver_info->description = driver_version_table[i].description;
1130             driver_info->version_high = MAKEDWORD_VERSION(driver_os_version, driver_version_table[i].d3d_level);
1131             driver_info->version_low = MAKEDWORD_VERSION(driver_version_table[i].lopart_hi,
1132                     driver_version_table[i].lopart_lo);
1133             break;
1134         }
1135     }
1136
1137     TRACE_(d3d_caps)("Reporting (fake) driver version 0x%08x-0x%08x.\n",
1138             driver_info->version_high, driver_info->version_low);
1139 }
1140
1141 /* Context activation is done by the caller. */
1142 static void fixup_extensions(struct wined3d_gl_info *gl_info, const char *gl_renderer,
1143         enum wined3d_gl_vendor gl_vendor, enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
1144 {
1145     unsigned int i;
1146
1147     for (i = 0; i < (sizeof(quirk_table) / sizeof(*quirk_table)); ++i)
1148     {
1149         if (!quirk_table[i].match(gl_info, gl_renderer, gl_vendor, card_vendor, device)) continue;
1150         TRACE_(d3d_caps)("Applying driver quirk \"%s\".\n", quirk_table[i].description);
1151         quirk_table[i].apply(gl_info);
1152     }
1153
1154     /* Find out if PBOs work as they are supposed to. */
1155     test_pbo_functionality(gl_info);
1156 }
1157
1158 static DWORD wined3d_parse_gl_version(const char *gl_version)
1159 {
1160     const char *ptr = gl_version;
1161     int major, minor;
1162
1163     major = atoi(ptr);
1164     if (major <= 0) ERR_(d3d_caps)("Invalid opengl major version: %d.\n", major);
1165
1166     while (isdigit(*ptr)) ++ptr;
1167     if (*ptr++ != '.') ERR_(d3d_caps)("Invalid opengl version string: %s.\n", debugstr_a(gl_version));
1168
1169     minor = atoi(ptr);
1170
1171     TRACE_(d3d_caps)("Found OpenGL version: %d.%d.\n", major, minor);
1172
1173     return MAKEDWORD_VERSION(major, minor);
1174 }
1175
1176 static enum wined3d_gl_vendor wined3d_guess_gl_vendor(struct wined3d_gl_info *gl_info, const char *gl_vendor_string, const char *gl_renderer)
1177 {
1178
1179     /* MacOS has various specialities in the extensions it advertises. Some have to be loaded from
1180      * the opengl 1.2+ core, while other extensions are advertised, but software emulated. So try to
1181      * detect the Apple OpenGL implementation to apply some extension fixups afterwards.
1182      *
1183      * Detecting this isn't really easy. The vendor string doesn't mention Apple. Compile-time checks
1184      * aren't sufficient either because a Linux binary may display on a macos X server via remote X11.
1185      * So try to detect the GL implementation by looking at certain Apple extensions. Some extensions
1186      * like client storage might be supported on other implementations too, but GL_APPLE_flush_render
1187      * is specific to the Mac OS X window management, and GL_APPLE_ycbcr_422 is QuickTime specific. So
1188      * the chance that other implementations support them is rather small since Win32 QuickTime uses
1189      * DirectDraw, not OpenGL. */
1190     if (gl_info->supported[APPLE_FENCE]
1191             && gl_info->supported[APPLE_CLIENT_STORAGE]
1192             && gl_info->supported[APPLE_FLUSH_RENDER]
1193             && gl_info->supported[APPLE_YCBCR_422])
1194         return GL_VENDOR_APPLE;
1195
1196     if (strstr(gl_vendor_string, "NVIDIA"))
1197         return GL_VENDOR_NVIDIA;
1198
1199     if (strstr(gl_vendor_string, "ATI"))
1200         return GL_VENDOR_ATI;
1201
1202     if (strstr(gl_vendor_string, "Intel(R)")
1203             || strstr(gl_renderer, "Intel(R)")
1204             || strstr(gl_vendor_string, "Intel Inc."))
1205         return GL_VENDOR_INTEL;
1206
1207     if (strstr(gl_vendor_string, "Mesa")
1208             || strstr(gl_vendor_string, "Advanced Micro Devices, Inc.")
1209             || strstr(gl_vendor_string, "DRI R300 Project")
1210             || strstr(gl_vendor_string, "X.Org R300 Project")
1211             || strstr(gl_vendor_string, "Tungsten Graphics, Inc")
1212             || strstr(gl_vendor_string, "VMware, Inc.")
1213             || strstr(gl_renderer, "Mesa")
1214             || strstr(gl_renderer, "Gallium"))
1215         return GL_VENDOR_MESA;
1216
1217     FIXME_(d3d_caps)("Received unrecognized GL_VENDOR %s. Returning GL_VENDOR_WINE.\n", debugstr_a(gl_vendor_string));
1218
1219     return GL_VENDOR_WINE;
1220 }
1221
1222 static enum wined3d_pci_vendor wined3d_guess_card_vendor(const char *gl_vendor_string, const char *gl_renderer)
1223 {
1224     if (strstr(gl_vendor_string, "NVIDIA"))
1225         return HW_VENDOR_NVIDIA;
1226
1227     if (strstr(gl_vendor_string, "ATI")
1228             || strstr(gl_vendor_string, "Advanced Micro Devices, Inc.")
1229             || strstr(gl_vendor_string, "X.Org R300 Project")
1230             || strstr(gl_vendor_string, "DRI R300 Project"))
1231         return HW_VENDOR_ATI;
1232
1233     if (strstr(gl_vendor_string, "Intel(R)")
1234             || strstr(gl_renderer, "Intel(R)")
1235             || strstr(gl_vendor_string, "Intel Inc."))
1236         return HW_VENDOR_INTEL;
1237
1238     if (strstr(gl_vendor_string, "Mesa")
1239             || strstr(gl_vendor_string, "Tungsten Graphics, Inc")
1240             || strstr(gl_vendor_string, "VMware, Inc."))
1241         return HW_VENDOR_WINE;
1242
1243     FIXME_(d3d_caps)("Received unrecognized GL_VENDOR %s. Returning HW_VENDOR_NVIDIA.\n", debugstr_a(gl_vendor_string));
1244
1245     return HW_VENDOR_NVIDIA;
1246 }
1247
1248
1249
1250 enum wined3d_pci_device select_card_nvidia_binary(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
1251             unsigned int *vidmem )
1252 {
1253     /* Both the GeforceFX, 6xxx and 7xxx series support D3D9. The last two types have more
1254      * shader capabilities, so we use the shader capabilities to distinguish between FX and 6xxx/7xxx.
1255      */
1256     if (WINE_D3D9_CAPABLE(gl_info) && gl_info->supported[NV_VERTEX_PROGRAM3])
1257     {
1258         /* Geforce 200 - highend */
1259         if (strstr(gl_renderer, "GTX 280")
1260                 || strstr(gl_renderer, "GTX 285")
1261                 || strstr(gl_renderer, "GTX 295"))
1262         {
1263             *vidmem = 1024;
1264             return CARD_NVIDIA_GEFORCE_GTX280;
1265         }
1266
1267         /* Geforce 200 - midend high */
1268         if (strstr(gl_renderer, "GTX 275"))
1269         {
1270             *vidmem = 896;
1271             return CARD_NVIDIA_GEFORCE_GTX275;
1272         }
1273
1274         /* Geforce 200 - midend */
1275         if (strstr(gl_renderer, "GTX 260"))
1276         {
1277             *vidmem = 1024;
1278             return CARD_NVIDIA_GEFORCE_GTX260;
1279         }
1280         /* Geforce 200 - midend */
1281         if (strstr(gl_renderer, "GT 240"))
1282         {
1283            *vidmem = 512;
1284            return CARD_NVIDIA_GEFORCE_GT240;
1285         }
1286
1287         /* Geforce9 - highend / Geforce 200 - midend (GTS 150/250 are based on the same core) */
1288         if (strstr(gl_renderer, "9800")
1289                 || strstr(gl_renderer, "GTS 150")
1290                 || strstr(gl_renderer, "GTS 250"))
1291         {
1292             *vidmem = 512;
1293             return CARD_NVIDIA_GEFORCE_9800GT;
1294         }
1295
1296         /* Geforce9 - midend */
1297         if (strstr(gl_renderer, "9600"))
1298         {
1299             *vidmem = 384; /* The 9600GSO has 384MB, the 9600GT has 512-1024MB */
1300             return CARD_NVIDIA_GEFORCE_9600GT;
1301         }
1302
1303         /* Geforce9 - midend low / Geforce 200 - low */
1304         if (strstr(gl_renderer, "9500")
1305                 || strstr(gl_renderer, "GT 120")
1306                 || strstr(gl_renderer, "GT 130"))
1307         {
1308             *vidmem = 256; /* The 9500GT has 256-1024MB */
1309             return CARD_NVIDIA_GEFORCE_9500GT;
1310         }
1311
1312         /* Geforce9 - lowend */
1313         if (strstr(gl_renderer, "9400"))
1314         {
1315             *vidmem = 256; /* The 9400GT has 256-1024MB */
1316             return CARD_NVIDIA_GEFORCE_9400GT;
1317         }
1318
1319         /* Geforce9 - lowend low */
1320         if (strstr(gl_renderer, "9100")
1321                 || strstr(gl_renderer, "9200")
1322                 || strstr(gl_renderer, "9300")
1323                 || strstr(gl_renderer, "G 100"))
1324         {
1325             *vidmem = 256; /* The 9100-9300 cards have 256MB */
1326             return CARD_NVIDIA_GEFORCE_9200;
1327         }
1328
1329         /* Geforce8 - highend */
1330         if (strstr(gl_renderer, "8800"))
1331         {
1332             *vidmem = 320; /* The 8800GTS uses 320MB, a 8800GTX can have 768MB */
1333             return CARD_NVIDIA_GEFORCE_8800GTS;
1334         }
1335
1336         /* Geforce8 - midend mobile */
1337         if (strstr(gl_renderer, "8600 M"))
1338         {
1339             *vidmem = 512;
1340             return CARD_NVIDIA_GEFORCE_8600MGT;
1341         }
1342
1343         /* Geforce8 - midend */
1344         if (strstr(gl_renderer, "8600")
1345                 || strstr(gl_renderer, "8700"))
1346         {
1347             *vidmem = 256;
1348             return CARD_NVIDIA_GEFORCE_8600GT;
1349         }
1350
1351         /* Geforce8 - lowend */
1352         if (strstr(gl_renderer, "8100")
1353                 || strstr(gl_renderer, "8200")
1354                 || strstr(gl_renderer, "8300")
1355                 || strstr(gl_renderer, "8400")
1356                 || strstr(gl_renderer, "8500"))
1357         {
1358             *vidmem = 128; /* 128-256MB for a 8300, 256-512MB for a 8400 */
1359             return CARD_NVIDIA_GEFORCE_8300GS;
1360         }
1361
1362         /* Geforce7 - highend */
1363         if (strstr(gl_renderer, "7800")
1364                 || strstr(gl_renderer, "7900")
1365                 || strstr(gl_renderer, "7950")
1366                 || strstr(gl_renderer, "Quadro FX 4")
1367                 || strstr(gl_renderer, "Quadro FX 5"))
1368         {
1369             *vidmem = 256; /* A 7800GT uses 256MB while highend 7900 cards can use 512MB */
1370             return CARD_NVIDIA_GEFORCE_7800GT;
1371         }
1372
1373         /* Geforce7 midend */
1374         if (strstr(gl_renderer, "7600")
1375                 || strstr(gl_renderer, "7700"))
1376         {
1377             *vidmem = 256; /* The 7600 uses 256-512MB */
1378             return CARD_NVIDIA_GEFORCE_7600;
1379         }
1380
1381         /* Geforce7 lower medium */
1382         if (strstr(gl_renderer, "7400"))
1383         {
1384             *vidmem = 256; /* The 7400 uses 256-512MB */
1385             return CARD_NVIDIA_GEFORCE_7400;
1386         }
1387
1388         /* Geforce7 lowend */
1389         if (strstr(gl_renderer, "7300"))
1390         {
1391             *vidmem = 256; /* Mac Pros with this card have 256 MB */
1392             return CARD_NVIDIA_GEFORCE_7300;
1393         }
1394
1395         /* Geforce6 highend */
1396         if (strstr(gl_renderer, "6800"))
1397         {
1398             *vidmem = 128; /* The 6800 uses 128-256MB, the 7600 uses 256-512MB */
1399             return CARD_NVIDIA_GEFORCE_6800;
1400         }
1401
1402         /* Geforce6 - midend */
1403         if (strstr(gl_renderer, "6600")
1404                 || strstr(gl_renderer, "6610")
1405                 || strstr(gl_renderer, "6700"))
1406         {
1407             *vidmem = 128; /* A 6600GT has 128-256MB */
1408             return CARD_NVIDIA_GEFORCE_6600GT;
1409         }
1410
1411         /* Geforce6/7 lowend */
1412         *vidmem = 64; /* */
1413         return CARD_NVIDIA_GEFORCE_6200; /* Geforce 6100/6150/6200/7300/7400/7500 */
1414     }
1415
1416     if (WINE_D3D9_CAPABLE(gl_info))
1417     {
1418         /* GeforceFX - highend */
1419         if (strstr(gl_renderer, "5800")
1420                 || strstr(gl_renderer, "5900")
1421                 || strstr(gl_renderer, "5950")
1422                 || strstr(gl_renderer, "Quadro FX"))
1423         {
1424             *vidmem = 256; /* 5800-5900 cards use 256MB */
1425             return CARD_NVIDIA_GEFORCEFX_5800;
1426         }
1427
1428         /* GeforceFX - midend */
1429         if (strstr(gl_renderer, "5600")
1430                 || strstr(gl_renderer, "5650")
1431                 || strstr(gl_renderer, "5700")
1432                 || strstr(gl_renderer, "5750"))
1433         {
1434             *vidmem = 128; /* A 5600 uses 128-256MB */
1435             return CARD_NVIDIA_GEFORCEFX_5600;
1436         }
1437
1438         /* GeforceFX - lowend */
1439         *vidmem = 64; /* Normal FX5200 cards use 64-256MB; laptop (non-standard) can have less */
1440         return CARD_NVIDIA_GEFORCEFX_5200; /* GeforceFX 5100/5200/5250/5300/5500 */
1441     }
1442
1443     if (WINE_D3D8_CAPABLE(gl_info))
1444     {
1445         if (strstr(gl_renderer, "GeForce4 Ti") || strstr(gl_renderer, "Quadro4"))
1446         {
1447             *vidmem = 64; /* Geforce4 Ti cards have 64-128MB */
1448             return CARD_NVIDIA_GEFORCE4_TI4200; /* Geforce4 Ti4200/Ti4400/Ti4600/Ti4800, Quadro4 */
1449         }
1450
1451         *vidmem = 64; /* Geforce3 cards have 64-128MB */
1452         return CARD_NVIDIA_GEFORCE3; /* Geforce3 standard/Ti200/Ti500, Quadro DCC */
1453     }
1454
1455     if (WINE_D3D7_CAPABLE(gl_info))
1456     {
1457         if (strstr(gl_renderer, "GeForce4 MX"))
1458         {
1459             /* Most Geforce4MX GPUs have at least 64MB of memory, some
1460              * early models had 32MB but most have 64MB or even 128MB. */
1461             *vidmem = 64;
1462             return CARD_NVIDIA_GEFORCE4_MX; /* MX420/MX440/MX460/MX4000 */
1463         }
1464
1465         if (strstr(gl_renderer, "GeForce2 MX") || strstr(gl_renderer, "Quadro2 MXR"))
1466         {
1467             *vidmem = 32; /* Geforce2MX GPUs have 32-64MB of video memory */
1468             return CARD_NVIDIA_GEFORCE2_MX; /* Geforce2 standard/MX100/MX200/MX400, Quadro2 MXR */
1469         }
1470
1471         if (strstr(gl_renderer, "GeForce2") || strstr(gl_renderer, "Quadro2"))
1472         {
1473             *vidmem = 32; /* Geforce2 GPUs have 32-64MB of video memory */
1474             return CARD_NVIDIA_GEFORCE2; /* Geforce2 GTS/Pro/Ti/Ultra, Quadro2 */
1475         }
1476
1477         /* Most Geforce1 cards have 32MB, there are also some rare 16
1478          * and 64MB (Dell) models. */
1479         *vidmem = 32;
1480         return CARD_NVIDIA_GEFORCE; /* Geforce 256/DDR, Quadro */
1481     }
1482
1483     if (strstr(gl_renderer, "TNT2"))
1484     {
1485         *vidmem = 32; /* Most TNT2 boards have 32MB, though there are 16MB boards too */
1486         return CARD_NVIDIA_RIVA_TNT2; /* Riva TNT2 standard/M64/Pro/Ultra */
1487     }
1488
1489     *vidmem = 16; /* Most TNT boards have 16MB, some rare models have 8MB */
1490     return CARD_NVIDIA_RIVA_TNT; /* Riva TNT, Vanta */
1491
1492 }
1493
1494 enum wined3d_pci_device select_card_ati_binary(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
1495     unsigned int *vidmem )
1496 {
1497     /* See http://developer.amd.com/drivers/pc_vendor_id/Pages/default.aspx
1498      *
1499      * Beware: renderer string do not match exact card model,
1500      * eg HD 4800 is returned for multiple cards, even for RV790 based ones. */
1501     if (WINE_D3D9_CAPABLE(gl_info))
1502     {
1503         /* Radeon EG CYPRESS XT / PRO HD5800 - highend */
1504         if (strstr(gl_renderer, "HD 5800")          /* Radeon EG CYPRESS HD58xx generic renderer string */
1505                 || strstr(gl_renderer, "HD 5850")   /* Radeon EG CYPRESS XT */
1506                 || strstr(gl_renderer, "HD 5870"))  /* Radeon EG CYPRESS PRO */
1507         {
1508             *vidmem = 1024; /* note: HD58xx cards use 1024MB  */
1509             return CARD_ATI_RADEON_HD5800;
1510         }
1511
1512         /* Radeon EG JUNIPER XT / LE HD5700 - midend */
1513         if (strstr(gl_renderer, "HD 5700")          /* Radeon EG JUNIPER HD57xx generic renderer string */
1514                 || strstr(gl_renderer, "HD 5750")   /* Radeon EG JUNIPER LE */
1515                 || strstr(gl_renderer, "HD 5770"))  /* Radeon EG JUNIPER XT */
1516         {
1517             *vidmem = 512; /* note: HD5770 cards use 1024MB and HD5750 cards use 512MB or 1024MB  */
1518             return CARD_ATI_RADEON_HD5700;
1519         }
1520
1521         /* Radeon R7xx HD4800 - highend */
1522         if (strstr(gl_renderer, "HD 4800")          /* Radeon RV7xx HD48xx generic renderer string */
1523                 || strstr(gl_renderer, "HD 4830")   /* Radeon RV770 */
1524                 || strstr(gl_renderer, "HD 4850")   /* Radeon RV770 */
1525                 || strstr(gl_renderer, "HD 4870")   /* Radeon RV770 */
1526                 || strstr(gl_renderer, "HD 4890"))  /* Radeon RV790 */
1527         {
1528             *vidmem = 512; /* note: HD4890 cards use 1024MB */
1529             return CARD_ATI_RADEON_HD4800;
1530         }
1531
1532         /* Radeon R740 HD4700 - midend */
1533         if (strstr(gl_renderer, "HD 4700")          /* Radeon RV770 */
1534                 || strstr(gl_renderer, "HD 4770"))  /* Radeon RV740 */
1535         {
1536             *vidmem = 512;
1537             return CARD_ATI_RADEON_HD4700;
1538         }
1539
1540         /* Radeon R730 HD4600 - midend */
1541         if (strstr(gl_renderer, "HD 4600")          /* Radeon RV730 */
1542                 || strstr(gl_renderer, "HD 4650")   /* Radeon RV730 */
1543                 || strstr(gl_renderer, "HD 4670"))  /* Radeon RV730 */
1544         {
1545             *vidmem = 512;
1546             return CARD_ATI_RADEON_HD4600;
1547         }
1548
1549         /* Radeon R710 HD4500/HD4350 - lowend */
1550         if (strstr(gl_renderer, "HD 4350")          /* Radeon RV710 */
1551                 || strstr(gl_renderer, "HD 4550"))  /* Radeon RV710 */
1552         {
1553             *vidmem = 256;
1554             return CARD_ATI_RADEON_HD4350;
1555         }
1556
1557         /* Radeon R6xx HD2900/HD3800 - highend */
1558         if (strstr(gl_renderer, "HD 2900")
1559                 || strstr(gl_renderer, "HD 3870")
1560                 || strstr(gl_renderer, "HD 3850"))
1561         {
1562             *vidmem = 512; /* HD2900/HD3800 uses 256-1024MB */
1563             return CARD_ATI_RADEON_HD2900;
1564         }
1565
1566         /* Radeon R6xx HD2600/HD3600 - midend; HD3830 is China-only midend */
1567         if (strstr(gl_renderer, "HD 2600")
1568                 || strstr(gl_renderer, "HD 3830")
1569                 || strstr(gl_renderer, "HD 3690")
1570                 || strstr(gl_renderer, "HD 3650"))
1571         {
1572             *vidmem = 256; /* HD2600/HD3600 uses 256-512MB */
1573             return CARD_ATI_RADEON_HD2600;
1574         }
1575
1576         /* Radeon R6xx HD2300/HD2400/HD3400 - lowend */
1577         if (strstr(gl_renderer, "HD 2300")
1578                 || strstr(gl_renderer, "HD 2400")
1579                 || strstr(gl_renderer, "HD 3470")
1580                 || strstr(gl_renderer, "HD 3450")
1581                 || strstr(gl_renderer, "HD 3430")
1582                 || strstr(gl_renderer, "HD 3400"))
1583         {
1584             *vidmem = 128; /* HD2300 uses at least 128MB, HD2400 uses 256MB */
1585             return CARD_ATI_RADEON_HD2300;
1586         }
1587
1588         /* Radeon R6xx/R7xx integrated */
1589         if (strstr(gl_renderer, "HD 3100")
1590                 || strstr(gl_renderer, "HD 3200")
1591                 || strstr(gl_renderer, "HD 3300"))
1592         {
1593             *vidmem = 128; /* 128MB */
1594             return CARD_ATI_RADEON_HD3200;
1595         }
1596
1597         /* Radeon R5xx */
1598         if (strstr(gl_renderer, "X1600")
1599                 || strstr(gl_renderer, "X1650")
1600                 || strstr(gl_renderer, "X1800")
1601                 || strstr(gl_renderer, "X1900")
1602                 || strstr(gl_renderer, "X1950"))
1603         {
1604             *vidmem = 128; /* X1600 uses 128-256MB, >=X1800 uses 256MB */
1605             return CARD_ATI_RADEON_X1600;
1606         }
1607
1608         /* Radeon R4xx + X1300/X1400/X1450/X1550/X2300 (lowend R5xx) */
1609         if (strstr(gl_renderer, "X700")
1610                 || strstr(gl_renderer, "X800")
1611                 || strstr(gl_renderer, "X850")
1612                 || strstr(gl_renderer, "X1300")
1613                 || strstr(gl_renderer, "X1400")
1614                 || strstr(gl_renderer, "X1450")
1615                 || strstr(gl_renderer, "X1550"))
1616         {
1617             *vidmem = 128; /* x700/x8*0 use 128-256MB, >=x1300 128-512MB */
1618             return CARD_ATI_RADEON_X700;
1619         }
1620
1621         /* Radeon Xpress Series - onboard, DX9b, Shader 2.0, 300-400MHz */
1622         if (strstr(gl_renderer, "Radeon Xpress"))
1623         {
1624             *vidmem = 64; /* Shared RAM, BIOS configurable, 64-256M */
1625             return CARD_ATI_RADEON_XPRESS_200M;
1626         }
1627
1628         /* Radeon R3xx */
1629         *vidmem = 64; /* Radeon 9500 uses 64MB, higher models use up to 256MB */
1630         return CARD_ATI_RADEON_9500; /* Radeon 9500/9550/9600/9700/9800/X300/X550/X600 */
1631     }
1632
1633     if (WINE_D3D8_CAPABLE(gl_info))
1634     {
1635         *vidmem = 64; /* 8500/9000 cards use mostly 64MB, though there are 32MB and 128MB models */
1636         return CARD_ATI_RADEON_8500; /* Radeon 8500/9000/9100/9200/9300 */
1637     }
1638
1639     if (WINE_D3D7_CAPABLE(gl_info))
1640     {
1641         *vidmem = 32; /* There are models with up to 64MB */
1642         return CARD_ATI_RADEON_7200; /* Radeon 7000/7100/7200/7500 */
1643     }
1644
1645     *vidmem = 16; /* There are 16-32MB models */
1646     return CARD_ATI_RAGE_128PRO;
1647
1648 }
1649
1650 enum wined3d_pci_device select_card_intel_binary(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
1651     unsigned int *vidmem )
1652 {
1653     if (strstr(gl_renderer, "X3100"))
1654     {
1655         /* MacOS calls the card GMA X3100, Google findings also suggest the name GM965 */
1656         *vidmem = 128;
1657         return CARD_INTEL_X3100;
1658     }
1659
1660     if (strstr(gl_renderer, "GMA 950") || strstr(gl_renderer, "945GM"))
1661     {
1662         /* MacOS calls the card GMA 950, but everywhere else the PCI ID is named 945GM */
1663         *vidmem = 64;
1664         return CARD_INTEL_I945GM;
1665     }
1666
1667     if (strstr(gl_renderer, "915GM")) return CARD_INTEL_I915GM;
1668     if (strstr(gl_renderer, "915G")) return CARD_INTEL_I915G;
1669     if (strstr(gl_renderer, "865G")) return CARD_INTEL_I865G;
1670     if (strstr(gl_renderer, "855G")) return CARD_INTEL_I855G;
1671     if (strstr(gl_renderer, "830G")) return CARD_INTEL_I830G;
1672     return CARD_INTEL_I915G;
1673
1674 }
1675
1676 enum wined3d_pci_device (select_card_ati_mesa)(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
1677             unsigned int *vidmem )
1678 {
1679     /* See http://developer.amd.com/drivers/pc_vendor_id/Pages/default.aspx
1680      *
1681      * Beware: renderer string do not match exact card model,
1682      * eg HD 4800 is returned for multiple cards, even for RV790 based ones. */
1683     if (strstr(gl_renderer, "Gallium"))
1684     {
1685         /* Radeon R7xx HD4800 - highend */
1686         if (strstr(gl_renderer, "R700")          /* Radeon R7xx HD48xx generic renderer string */
1687                 || strstr(gl_renderer, "RV770")  /* Radeon RV770 */
1688                 || strstr(gl_renderer, "RV790"))  /* Radeon RV790 */
1689         {
1690             *vidmem = 512; /* note: HD4890 cards use 1024MB */
1691             return CARD_ATI_RADEON_HD4800;
1692         }
1693
1694         /* Radeon R740 HD4700 - midend */
1695         if (strstr(gl_renderer, "RV740"))          /* Radeon RV740 */
1696         {
1697             *vidmem = 512;
1698             return CARD_ATI_RADEON_HD4700;
1699         }
1700
1701         /* Radeon R730 HD4600 - midend */
1702         if (strstr(gl_renderer, "RV730"))        /* Radeon RV730 */
1703         {
1704             *vidmem = 512;
1705             return CARD_ATI_RADEON_HD4600;
1706         }
1707
1708         /* Radeon R710 HD4500/HD4350 - lowend */
1709         if (strstr(gl_renderer, "RV710"))          /* Radeon RV710 */
1710         {
1711             *vidmem = 256;
1712             return CARD_ATI_RADEON_HD4350;
1713         }
1714
1715         /* Radeon R6xx HD2900/HD3800 - highend */
1716         if (strstr(gl_renderer, "R600")
1717                 || strstr(gl_renderer, "RV670")
1718                 || strstr(gl_renderer, "R680"))
1719         {
1720             *vidmem = 512; /* HD2900/HD3800 uses 256-1024MB */
1721             return CARD_ATI_RADEON_HD2900;
1722         }
1723
1724         /* Radeon R6xx HD2600/HD3600 - midend; HD3830 is China-only midend */
1725         if (strstr(gl_renderer, "RV630")
1726                 || strstr(gl_renderer, "RV635"))
1727         {
1728             *vidmem = 256; /* HD2600/HD3600 uses 256-512MB */
1729             return CARD_ATI_RADEON_HD2600;
1730         }
1731
1732         /* Radeon R6xx HD2300/HD2400/HD3400 - lowend */
1733         if (strstr(gl_renderer, "RV610")
1734                 || strstr(gl_renderer, "RV620"))
1735         {
1736             *vidmem = 128; /* HD2300 uses at least 128MB, HD2400 uses 256MB */
1737             return CARD_ATI_RADEON_HD2300;
1738         }
1739
1740         /* Radeon R6xx/R7xx integrated */
1741         if (strstr(gl_renderer, "RS780")
1742                 || strstr(gl_renderer, "RS880"))
1743         {
1744             *vidmem = 128; /* 128MB */
1745             return CARD_ATI_RADEON_HD3200;
1746         }
1747
1748         /* Radeon R5xx */
1749         if (strstr(gl_renderer, "RV530")
1750                 || strstr(gl_renderer, "RV535")
1751                 || strstr(gl_renderer, "RV560")
1752                 || strstr(gl_renderer, "R520")
1753                 || strstr(gl_renderer, "RV570")
1754                 || strstr(gl_renderer, "R580"))
1755         {
1756             *vidmem = 128; /* X1600 uses 128-256MB, >=X1800 uses 256MB */
1757             return CARD_ATI_RADEON_X1600;
1758         }
1759
1760         /* Radeon R4xx + X1300/X1400/X1450/X1550/X2300 (lowend R5xx) */
1761         if (strstr(gl_renderer, "R410")
1762                 || strstr(gl_renderer, "R420")
1763                 || strstr(gl_renderer, "R423")
1764                 || strstr(gl_renderer, "R430")
1765                 || strstr(gl_renderer, "R480")
1766                 || strstr(gl_renderer, "R481")
1767                 || strstr(gl_renderer, "RV410")
1768                 || strstr(gl_renderer, "RV515")
1769                 || strstr(gl_renderer, "RV516"))
1770         {
1771             *vidmem = 128; /* x700/x8*0 use 128-256MB, >=x1300 128-512MB */
1772             return CARD_ATI_RADEON_X700;
1773         }
1774
1775         /* Radeon Xpress Series - onboard, DX9b, Shader 2.0, 300-400MHz */
1776         if (strstr(gl_renderer, "RS400")
1777                 || strstr(gl_renderer, "RS480")
1778                 || strstr(gl_renderer, "RS482")
1779                 || strstr(gl_renderer, "RS485")
1780                 || strstr(gl_renderer, "RS600")
1781                 || strstr(gl_renderer, "RS690")
1782                 || strstr(gl_renderer, "RS740"))
1783         {
1784             *vidmem = 64; /* Shared RAM, BIOS configurable, 64-256M */
1785             return CARD_ATI_RADEON_XPRESS_200M;
1786         }
1787
1788         /* Radeon R3xx */
1789         if (strstr(gl_renderer, "R300")
1790                 || strstr(gl_renderer, "RV350")
1791                 || strstr(gl_renderer, "RV351")
1792                 || strstr(gl_renderer, "RV360")
1793                 || strstr(gl_renderer, "RV370")
1794                 || strstr(gl_renderer, "R350")
1795                 || strstr(gl_renderer, "R360"))
1796         {
1797             *vidmem = 64; /* Radeon 9500 uses 64MB, higher models use up to 256MB */
1798             return CARD_ATI_RADEON_9500; /* Radeon 9500/9550/9600/9700/9800/X300/X550/X600 */
1799         }
1800     }
1801
1802     if (WINE_D3D9_CAPABLE(gl_info))
1803     {
1804         /* Radeon R7xx HD4800 - highend */
1805         if (strstr(gl_renderer, "(R700")          /* Radeon R7xx HD48xx generic renderer string */
1806                 || strstr(gl_renderer, "(RV770")  /* Radeon RV770 */
1807                 || strstr(gl_renderer, "(RV790"))  /* Radeon RV790 */
1808         {
1809             *vidmem = 512; /* note: HD4890 cards use 1024MB */
1810             return CARD_ATI_RADEON_HD4800;
1811         }
1812
1813         /* Radeon R740 HD4700 - midend */
1814         if (strstr(gl_renderer, "(RV740"))          /* Radeon RV740 */
1815         {
1816             *vidmem = 512;
1817             return CARD_ATI_RADEON_HD4700;
1818         }
1819
1820         /* Radeon R730 HD4600 - midend */
1821         if (strstr(gl_renderer, "(RV730"))        /* Radeon RV730 */
1822         {
1823             *vidmem = 512;
1824             return CARD_ATI_RADEON_HD4600;
1825         }
1826
1827         /* Radeon R710 HD4500/HD4350 - lowend */
1828         if (strstr(gl_renderer, "(RV710"))          /* Radeon RV710 */
1829         {
1830             *vidmem = 256;
1831             return CARD_ATI_RADEON_HD4350;
1832         }
1833
1834         /* Radeon R6xx HD2900/HD3800 - highend */
1835         if (strstr(gl_renderer, "(R600")
1836                 || strstr(gl_renderer, "(RV670")
1837                 || strstr(gl_renderer, "(R680"))
1838         {
1839             *vidmem = 512; /* HD2900/HD3800 uses 256-1024MB */
1840             return CARD_ATI_RADEON_HD2900;
1841         }
1842
1843         /* Radeon R6xx HD2600/HD3600 - midend; HD3830 is China-only midend */
1844         if (strstr(gl_renderer, "(RV630")
1845                 || strstr(gl_renderer, "(RV635"))
1846         {
1847             *vidmem = 256; /* HD2600/HD3600 uses 256-512MB */
1848             return CARD_ATI_RADEON_HD2600;
1849         }
1850
1851         /* Radeon R6xx HD2300/HD2400/HD3400 - lowend */
1852         if (strstr(gl_renderer, "(RV610")
1853                 || strstr(gl_renderer, "(RV620"))
1854         {
1855             *vidmem = 128; /* HD2300 uses at least 128MB, HD2400 uses 256MB */
1856             return CARD_ATI_RADEON_HD2300;
1857         }
1858
1859         /* Radeon R6xx/R7xx integrated */
1860         if (strstr(gl_renderer, "(RS780")
1861                 || strstr(gl_renderer, "(RS880"))
1862         {
1863             *vidmem = 128; /* 128MB */
1864             return CARD_ATI_RADEON_HD3200;
1865         }
1866     }
1867
1868     if (WINE_D3D8_CAPABLE(gl_info))
1869     {
1870         *vidmem = 64; /* 8500/9000 cards use mostly 64MB, though there are 32MB and 128MB models */
1871         return CARD_ATI_RADEON_8500; /* Radeon 8500/9000/9100/9200/9300 */
1872     }
1873
1874     if (WINE_D3D7_CAPABLE(gl_info))
1875     {
1876         *vidmem = 32; /* There are models with up to 64MB */
1877         return CARD_ATI_RADEON_7200; /* Radeon 7000/7100/7200/7500 */
1878     }
1879
1880     *vidmem = 16; /* There are 16-32MB models */
1881     return CARD_ATI_RAGE_128PRO;
1882
1883 }
1884
1885 enum wined3d_pci_device (select_card_nvidia_mesa)(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
1886     unsigned int *vidmem )
1887 {
1888     FIXME_(d3d_caps)("Card selection not handled for Mesa Nouveau driver\n");
1889     if (WINE_D3D9_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCEFX_5600;
1890     if (WINE_D3D8_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCE3;
1891     if (WINE_D3D7_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCE;
1892     if (WINE_D3D6_CAPABLE(gl_info)) return CARD_NVIDIA_RIVA_TNT;
1893     return CARD_NVIDIA_RIVA_128;
1894 }
1895
1896 enum wined3d_pci_device (select_card_intel_mesa)(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
1897     unsigned int *vidmem )
1898 {
1899     FIXME_(d3d_caps)("Card selection not handled for Mesa Intel driver\n");
1900     return CARD_INTEL_I915G;
1901 }
1902
1903
1904 struct vendor_card_selection
1905 {
1906     enum wined3d_gl_vendor gl_vendor;
1907     enum wined3d_pci_vendor card_vendor;
1908     const char *description;        /* Description of the card selector i.e. Apple OS/X Intel */
1909     enum wined3d_pci_device (*select_card)(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
1910             unsigned int *vidmem );
1911 };
1912
1913 static const struct vendor_card_selection vendor_card_select_table[] =
1914 {
1915     {GL_VENDOR_NVIDIA, HW_VENDOR_NVIDIA,  "Nvidia binary driver",     select_card_nvidia_binary},
1916     {GL_VENDOR_APPLE,  HW_VENDOR_NVIDIA,  "Apple OSX NVidia binary driver",   select_card_nvidia_binary},
1917     {GL_VENDOR_APPLE,  HW_VENDOR_ATI,     "Apple OSX AMD/ATI binary driver",  select_card_ati_binary},
1918     {GL_VENDOR_APPLE,  HW_VENDOR_INTEL,   "Apple OSX Intel binary driver",    select_card_intel_binary},
1919     {GL_VENDOR_ATI,    HW_VENDOR_ATI,     "AMD/ATI binary driver",    select_card_ati_binary},
1920     {GL_VENDOR_MESA,   HW_VENDOR_ATI,     "Mesa AMD/ATI driver",      select_card_ati_mesa},
1921     {GL_VENDOR_MESA,   HW_VENDOR_NVIDIA,  "Mesa Nouveau driver",      select_card_nvidia_mesa},
1922     {GL_VENDOR_MESA,   HW_VENDOR_INTEL,   "Mesa Intel driver",        select_card_intel_mesa}
1923 };
1924
1925
1926 static enum wined3d_pci_device wined3d_guess_card(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
1927         enum wined3d_gl_vendor *gl_vendor, enum wined3d_pci_vendor *card_vendor, unsigned int *vidmem)
1928 {
1929     /* Above is a list of Nvidia and ATI GPUs. Both vendors have dozens of
1930      * different GPUs with roughly the same features. In most cases GPUs from a
1931      * certain family differ in clockspeeds, the amount of video memory and the
1932      * number of shader pipelines.
1933      *
1934      * A Direct3D device object contains the PCI id (vendor + device) of the
1935      * videocard which is used for rendering. Various applications use this
1936      * information to get a rough estimation of the features of the card and
1937      * some might use it for enabling 3d effects only on certain types of
1938      * videocards. In some cases games might even use it to work around bugs
1939      * which happen on certain videocards/driver combinations. The problem is
1940      * that OpenGL only exposes a rendering string containing the name of the
1941      * videocard and not the PCI id.
1942      *
1943      * Various games depend on the PCI id, so somehow we need to provide one.
1944      * A simple option is to parse the renderer string and translate this to
1945      * the right PCI id. This is a lot of work because there are more than 200
1946      * GPUs just for Nvidia. Various cards share the same renderer string, so
1947      * the amount of code might be 'small' but there are quite a number of
1948      * exceptions which would make this a pain to maintain. Another way would
1949      * be to query the PCI id from the operating system (assuming this is the
1950      * videocard which is used for rendering which is not always the case).
1951      * This would work but it is not very portable. Second it would not work
1952      * well in, let's say, a remote X situation in which the amount of 3d
1953      * features which can be used is limited.
1954      *
1955      * As said most games only use the PCI id to get an indication of the
1956      * capabilities of the card. It doesn't really matter if the given id is
1957      * the correct one if we return the id of a card with similar 3d features.
1958      *
1959      * The code below checks the OpenGL capabilities of a videocard and matches
1960      * that to a certain level of Direct3D functionality. Once a card passes
1961      * the Direct3D9 check, we know that the card (in case of Nvidia) is at
1962      * least a GeforceFX. To give a better estimate we do a basic check on the
1963      * renderer string but if that won't pass we return a default card. This
1964      * way is better than maintaining a full card database as even without a
1965      * full database we can return a card with similar features. Second the
1966      * size of the database can be made quite small because when you know what
1967      * type of 3d functionality a card has, you know to which GPU family the
1968      * GPU must belong. Because of this you only have to check a small part of
1969      * the renderer string to distinguishes between different models from that
1970      * family.
1971      *
1972      * The code also selects a default amount of video memory which we will
1973      * use for an estimation of the amount of free texture memory. In case of
1974      * real D3D the amount of texture memory includes video memory and system
1975      * memory (to be specific AGP memory or in case of PCIE TurboCache /
1976      * HyperMemory). We don't know how much system memory can be addressed by
1977      * the system but we can make a reasonable estimation about the amount of
1978      * video memory. If the value is slightly wrong it doesn't matter as we
1979      * didn't include AGP-like memory which makes the amount of addressable
1980      * memory higher and second OpenGL isn't that critical it moves to system
1981      * memory behind our backs if really needed. Note that the amount of video
1982      * memory can be overruled using a registry setting. */
1983
1984     int i;
1985
1986     for (i = 0; i < (sizeof(vendor_card_select_table) / sizeof(*vendor_card_select_table)); ++i)
1987     {
1988         if ((vendor_card_select_table[i].gl_vendor != *gl_vendor)
1989             || (vendor_card_select_table[i].card_vendor != *card_vendor))
1990                 continue;
1991         TRACE_(d3d_caps)("Applying card_selector \"%s\".\n", vendor_card_select_table[i].description);
1992         return vendor_card_select_table[i].select_card(gl_info, gl_renderer, vidmem);
1993     }
1994
1995     FIXME_(d3d_caps)("No card selector available for GL vendor %d and card vendor %04x.\n",
1996                      *gl_vendor, *card_vendor);
1997
1998     /* Default to generic Nvidia hardware based on the supported OpenGL extensions. The choice
1999      * for Nvidia was because the hardware and drivers they make are of good quality. This makes
2000      * them a good generic choice. */
2001     *card_vendor = HW_VENDOR_NVIDIA;
2002     if (WINE_D3D9_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCEFX_5600;
2003     if (WINE_D3D8_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCE3;
2004     if (WINE_D3D7_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCE;
2005     if (WINE_D3D6_CAPABLE(gl_info)) return CARD_NVIDIA_RIVA_TNT;
2006     return CARD_NVIDIA_RIVA_128;
2007 }
2008
2009 static const struct fragment_pipeline *select_fragment_implementation(struct wined3d_adapter *adapter)
2010 {
2011     const struct wined3d_gl_info *gl_info = &adapter->gl_info;
2012     int vs_selected_mode, ps_selected_mode;
2013
2014     select_shader_mode(gl_info, &ps_selected_mode, &vs_selected_mode);
2015     if ((ps_selected_mode == SHADER_ARB || ps_selected_mode == SHADER_GLSL)
2016             && gl_info->supported[ARB_FRAGMENT_PROGRAM]) return &arbfp_fragment_pipeline;
2017     else if (ps_selected_mode == SHADER_ATI) return &atifs_fragment_pipeline;
2018     else if (gl_info->supported[NV_REGISTER_COMBINERS]
2019             && gl_info->supported[NV_TEXTURE_SHADER2]) return &nvts_fragment_pipeline;
2020     else if (gl_info->supported[NV_REGISTER_COMBINERS]) return &nvrc_fragment_pipeline;
2021     else return &ffp_fragment_pipeline;
2022 }
2023
2024 static const shader_backend_t *select_shader_backend(struct wined3d_adapter *adapter)
2025 {
2026     int vs_selected_mode, ps_selected_mode;
2027
2028     select_shader_mode(&adapter->gl_info, &ps_selected_mode, &vs_selected_mode);
2029     if (vs_selected_mode == SHADER_GLSL || ps_selected_mode == SHADER_GLSL) return &glsl_shader_backend;
2030     if (vs_selected_mode == SHADER_ARB || ps_selected_mode == SHADER_ARB) return &arb_program_shader_backend;
2031     return &none_shader_backend;
2032 }
2033
2034 static const struct blit_shader *select_blit_implementation(struct wined3d_adapter *adapter)
2035 {
2036     const struct wined3d_gl_info *gl_info = &adapter->gl_info;
2037     int vs_selected_mode, ps_selected_mode;
2038
2039     select_shader_mode(gl_info, &ps_selected_mode, &vs_selected_mode);
2040     if ((ps_selected_mode == SHADER_ARB || ps_selected_mode == SHADER_GLSL)
2041             && gl_info->supported[ARB_FRAGMENT_PROGRAM]) return &arbfp_blit;
2042     else return &ffp_blit;
2043 }
2044
2045 /* Context activation is done by the caller. */
2046 static BOOL IWineD3DImpl_FillGLCaps(struct wined3d_adapter *adapter)
2047 {
2048     struct wined3d_driver_info *driver_info = &adapter->driver_info;
2049     struct wined3d_gl_info *gl_info = &adapter->gl_info;
2050     const char *GL_Extensions    = NULL;
2051     const char *WGL_Extensions   = NULL;
2052     const char *gl_vendor_str, *gl_renderer_str, *gl_version_str;
2053     struct fragment_caps fragment_caps;
2054     enum wined3d_gl_vendor gl_vendor;
2055     enum wined3d_pci_vendor card_vendor;
2056     enum wined3d_pci_device device;
2057     GLint       gl_max;
2058     GLfloat     gl_floatv[2];
2059     unsigned    i;
2060     HDC         hdc;
2061     unsigned int vidmem=0;
2062     DWORD gl_version;
2063     size_t len;
2064
2065     TRACE_(d3d_caps)("(%p)\n", gl_info);
2066
2067     ENTER_GL();
2068
2069     gl_renderer_str = (const char *)glGetString(GL_RENDERER);
2070     TRACE_(d3d_caps)("GL_RENDERER: %s.\n", debugstr_a(gl_renderer_str));
2071     if (!gl_renderer_str)
2072     {
2073         LEAVE_GL();
2074         ERR_(d3d_caps)("Received a NULL GL_RENDERER.\n");
2075         return FALSE;
2076     }
2077
2078     gl_vendor_str = (const char *)glGetString(GL_VENDOR);
2079     TRACE_(d3d_caps)("GL_VENDOR: %s.\n", debugstr_a(gl_vendor_str));
2080     if (!gl_vendor_str)
2081     {
2082         LEAVE_GL();
2083         ERR_(d3d_caps)("Received a NULL GL_VENDOR.\n");
2084         return FALSE;
2085     }
2086
2087     /* Parse the GL_VERSION field into major and minor information */
2088     gl_version_str = (const char *)glGetString(GL_VERSION);
2089     TRACE_(d3d_caps)("GL_VERSION: %s.\n", debugstr_a(gl_version_str));
2090     if (!gl_version_str)
2091     {
2092         LEAVE_GL();
2093         ERR_(d3d_caps)("Received a NULL GL_VERSION.\n");
2094         return FALSE;
2095     }
2096     gl_version = wined3d_parse_gl_version(gl_version_str);
2097
2098     /*
2099      * Initialize openGL extension related variables
2100      *  with Default values
2101      */
2102     memset(gl_info->supported, 0, sizeof(gl_info->supported));
2103     gl_info->limits.buffers = 1;
2104     gl_info->limits.textures = 1;
2105     gl_info->limits.fragment_samplers = 1;
2106     gl_info->limits.vertex_samplers = 0;
2107     gl_info->limits.combined_samplers = gl_info->limits.fragment_samplers + gl_info->limits.vertex_samplers;
2108     gl_info->limits.sampler_stages = 1;
2109     gl_info->limits.glsl_vs_float_constants = 0;
2110     gl_info->limits.glsl_ps_float_constants = 0;
2111     gl_info->limits.arb_vs_float_constants = 0;
2112     gl_info->limits.arb_vs_native_constants = 0;
2113     gl_info->limits.arb_vs_instructions = 0;
2114     gl_info->limits.arb_vs_temps = 0;
2115     gl_info->limits.arb_ps_float_constants = 0;
2116     gl_info->limits.arb_ps_local_constants = 0;
2117     gl_info->limits.arb_ps_instructions = 0;
2118     gl_info->limits.arb_ps_temps = 0;
2119
2120     /* Retrieve opengl defaults */
2121     glGetIntegerv(GL_MAX_CLIP_PLANES, &gl_max);
2122     gl_info->limits.clipplanes = min(WINED3DMAXUSERCLIPPLANES, gl_max);
2123     TRACE_(d3d_caps)("ClipPlanes support - num Planes=%d\n", gl_max);
2124
2125     glGetIntegerv(GL_MAX_LIGHTS, &gl_max);
2126     gl_info->limits.lights = gl_max;
2127     TRACE_(d3d_caps)("Lights support - max lights=%d\n", gl_max);
2128
2129     glGetIntegerv(GL_MAX_TEXTURE_SIZE, &gl_max);
2130     gl_info->limits.texture_size = gl_max;
2131     TRACE_(d3d_caps)("Maximum texture size support - max texture size=%d\n", gl_max);
2132
2133     glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, gl_floatv);
2134     gl_info->limits.pointsize_min = gl_floatv[0];
2135     gl_info->limits.pointsize_max = gl_floatv[1];
2136     TRACE_(d3d_caps)("Maximum point size support - max point size=%f\n", gl_floatv[1]);
2137
2138     /* Parse the gl supported features, in theory enabling parts of our code appropriately. */
2139     GL_Extensions = (const char *)glGetString(GL_EXTENSIONS);
2140     if (!GL_Extensions)
2141     {
2142         LEAVE_GL();
2143         ERR_(d3d_caps)("Received a NULL GL_EXTENSIONS.\n");
2144         return FALSE;
2145     }
2146
2147     LEAVE_GL();
2148
2149     TRACE_(d3d_caps)("GL_Extensions reported:\n");
2150
2151     gl_info->supported[WINED3D_GL_EXT_NONE] = TRUE;
2152
2153     while (*GL_Extensions)
2154     {
2155         const char *start;
2156         char current_ext[256];
2157
2158         while (isspace(*GL_Extensions)) ++GL_Extensions;
2159         start = GL_Extensions;
2160         while (!isspace(*GL_Extensions) && *GL_Extensions) ++GL_Extensions;
2161
2162         len = GL_Extensions - start;
2163         if (!len || len >= sizeof(current_ext)) continue;
2164
2165         memcpy(current_ext, start, len);
2166         current_ext[len] = '\0';
2167         TRACE_(d3d_caps)("- %s\n", debugstr_a(current_ext));
2168
2169         for (i = 0; i < (sizeof(EXTENSION_MAP) / sizeof(*EXTENSION_MAP)); ++i)
2170         {
2171             if (!strcmp(current_ext, EXTENSION_MAP[i].extension_string))
2172             {
2173                 TRACE_(d3d_caps)(" FOUND: %s support.\n", EXTENSION_MAP[i].extension_string);
2174                 gl_info->supported[EXTENSION_MAP[i].extension] = TRUE;
2175                 break;
2176             }
2177         }
2178     }
2179
2180     /* Now work out what GL support this card really has */
2181 #define USE_GL_FUNC(type, pfn, ext, replace) \
2182 { \
2183     DWORD ver = ver_for_ext(ext); \
2184     if (gl_info->supported[ext]) gl_info->pfn = (type)pwglGetProcAddress(#pfn); \
2185     else if (ver && ver <= gl_version) gl_info->pfn = (type)pwglGetProcAddress(#replace); \
2186     else gl_info->pfn = NULL; \
2187 }
2188     GL_EXT_FUNCS_GEN;
2189 #undef USE_GL_FUNC
2190
2191 #define USE_GL_FUNC(type, pfn, ext, replace) gl_info->pfn = (type)pwglGetProcAddress(#pfn);
2192     WGL_EXT_FUNCS_GEN;
2193 #undef USE_GL_FUNC
2194
2195     ENTER_GL();
2196
2197     /* Now mark all the extensions supported which are included in the opengl core version. Do this *after*
2198      * loading the functions, otherwise the code above will load the extension entry points instead of the
2199      * core functions, which may not work. */
2200     for (i = 0; i < (sizeof(EXTENSION_MAP) / sizeof(*EXTENSION_MAP)); ++i)
2201     {
2202         if (!gl_info->supported[EXTENSION_MAP[i].extension]
2203                 && EXTENSION_MAP[i].version <= gl_version && EXTENSION_MAP[i].version)
2204         {
2205             TRACE_(d3d_caps)(" GL CORE: %s support.\n", EXTENSION_MAP[i].extension_string);
2206             gl_info->supported[EXTENSION_MAP[i].extension] = TRUE;
2207         }
2208     }
2209
2210     if (gl_info->supported[APPLE_FENCE])
2211     {
2212         /* GL_NV_fence and GL_APPLE_fence provide the same functionality basically.
2213          * The apple extension interacts with some other apple exts. Disable the NV
2214          * extension if the apple one is support to prevent confusion in other parts
2215          * of the code. */
2216         gl_info->supported[NV_FENCE] = FALSE;
2217     }
2218     if (gl_info->supported[APPLE_FLOAT_PIXELS])
2219     {
2220         /* GL_APPLE_float_pixels == GL_ARB_texture_float + GL_ARB_half_float_pixel
2221          *
2222          * The enums are the same:
2223          * GL_RGBA16F_ARB     = GL_RGBA_FLOAT16_APPLE = 0x881A
2224          * GL_RGB16F_ARB      = GL_RGB_FLOAT16_APPLE  = 0x881B
2225          * GL_RGBA32F_ARB     = GL_RGBA_FLOAT32_APPLE = 0x8814
2226          * GL_RGB32F_ARB      = GL_RGB_FLOAT32_APPLE  = 0x8815
2227          * GL_HALF_FLOAT_ARB  = GL_HALF_APPLE         = 0x140B
2228          */
2229         if (!gl_info->supported[ARB_TEXTURE_FLOAT])
2230         {
2231             TRACE_(d3d_caps)(" IMPLIED: GL_ARB_texture_float support(from GL_APPLE_float_pixels.\n");
2232             gl_info->supported[ARB_TEXTURE_FLOAT] = TRUE;
2233         }
2234         if (!gl_info->supported[ARB_HALF_FLOAT_PIXEL])
2235         {
2236             TRACE_(d3d_caps)(" IMPLIED: GL_ARB_half_float_pixel support(from GL_APPLE_float_pixels.\n");
2237             gl_info->supported[ARB_HALF_FLOAT_PIXEL] = TRUE;
2238         }
2239     }
2240     if (gl_info->supported[ARB_MAP_BUFFER_RANGE])
2241     {
2242         /* GL_ARB_map_buffer_range and GL_APPLE_flush_buffer_range provide the same
2243          * functionality. Prefer the ARB extension */
2244         gl_info->supported[APPLE_FLUSH_BUFFER_RANGE] = FALSE;
2245     }
2246     if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
2247     {
2248         TRACE_(d3d_caps)(" IMPLIED: NVIDIA (NV) Texture Gen Reflection support.\n");
2249         gl_info->supported[NV_TEXGEN_REFLECTION] = TRUE;
2250     }
2251     if (!gl_info->supported[ARB_DEPTH_CLAMP] && gl_info->supported[NV_DEPTH_CLAMP])
2252     {
2253         TRACE_(d3d_caps)(" IMPLIED: ARB_depth_clamp support (by NV_depth_clamp).\n");
2254         gl_info->supported[ARB_DEPTH_CLAMP] = TRUE;
2255     }
2256     if (!gl_info->supported[ARB_VERTEX_ARRAY_BGRA] && gl_info->supported[EXT_VERTEX_ARRAY_BGRA])
2257     {
2258         TRACE_(d3d_caps)(" IMPLIED: ARB_vertex_array_bgra support (by EXT_vertex_array_bgra).\n");
2259         gl_info->supported[ARB_VERTEX_ARRAY_BGRA] = TRUE;
2260     }
2261     if (gl_info->supported[NV_TEXTURE_SHADER2])
2262     {
2263         if (gl_info->supported[NV_REGISTER_COMBINERS])
2264         {
2265             /* Also disable ATI_FRAGMENT_SHADER if register combiners and texture_shader2
2266              * are supported. The nv extensions provide the same functionality as the
2267              * ATI one, and a bit more(signed pixelformats). */
2268             gl_info->supported[ATI_FRAGMENT_SHADER] = FALSE;
2269         }
2270     }
2271
2272     if (gl_info->supported[NV_REGISTER_COMBINERS])
2273     {
2274         glGetIntegerv(GL_MAX_GENERAL_COMBINERS_NV, &gl_max);
2275         gl_info->limits.general_combiners = gl_max;
2276         TRACE_(d3d_caps)("Max general combiners: %d.\n", gl_max);
2277     }
2278     if (gl_info->supported[ARB_DRAW_BUFFERS])
2279     {
2280         glGetIntegerv(GL_MAX_DRAW_BUFFERS_ARB, &gl_max);
2281         gl_info->limits.buffers = gl_max;
2282         TRACE_(d3d_caps)("Max draw buffers: %u.\n", gl_max);
2283     }
2284     if (gl_info->supported[ARB_MULTITEXTURE])
2285     {
2286         glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &gl_max);
2287         gl_info->limits.textures = min(MAX_TEXTURES, gl_max);
2288         TRACE_(d3d_caps)("Max textures: %d.\n", gl_info->limits.textures);
2289
2290         if (gl_info->supported[ARB_FRAGMENT_PROGRAM])
2291         {
2292             GLint tmp;
2293             glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS_ARB, &tmp);
2294             gl_info->limits.fragment_samplers = min(MAX_FRAGMENT_SAMPLERS, tmp);
2295         }
2296         else
2297         {
2298             gl_info->limits.fragment_samplers = max(gl_info->limits.fragment_samplers, gl_max);
2299         }
2300         TRACE_(d3d_caps)("Max fragment samplers: %d.\n", gl_info->limits.fragment_samplers);
2301
2302         if (gl_info->supported[ARB_VERTEX_SHADER])
2303         {
2304             GLint tmp;
2305             glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB, &tmp);
2306             gl_info->limits.vertex_samplers = tmp;
2307             glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB, &tmp);
2308             gl_info->limits.combined_samplers = tmp;
2309
2310             /* Loading GLSL sampler uniforms is much simpler if we can assume that the sampler setup
2311              * is known at shader link time. In a vertex shader + pixel shader combination this isn't
2312              * an issue because then the sampler setup only depends on the two shaders. If a pixel
2313              * shader is used with fixed function vertex processing we're fine too because fixed function
2314              * vertex processing doesn't use any samplers. If fixed function fragment processing is
2315              * used we have to make sure that all vertex sampler setups are valid together with all
2316              * possible fixed function fragment processing setups. This is true if vsamplers + MAX_TEXTURES
2317              * <= max_samplers. This is true on all d3d9 cards that support vtf(gf 6 and gf7 cards).
2318              * dx9 radeon cards do not support vertex texture fetch. DX10 cards have 128 samplers, and
2319              * dx9 is limited to 8 fixed function texture stages and 4 vertex samplers. DX10 does not have
2320              * a fixed function pipeline anymore.
2321              *
2322              * So this is just a check to check that our assumption holds true. If not, write a warning
2323              * and reduce the number of vertex samplers or probably disable vertex texture fetch. */
2324             if (gl_info->limits.vertex_samplers && gl_info->limits.combined_samplers < 12
2325                     && MAX_TEXTURES + gl_info->limits.vertex_samplers > gl_info->limits.combined_samplers)
2326             {
2327                 FIXME("OpenGL implementation supports %u vertex samplers and %u total samplers.\n",
2328                         gl_info->limits.vertex_samplers, gl_info->limits.combined_samplers);
2329                 FIXME("Expected vertex samplers + MAX_TEXTURES(=8) > combined_samplers.\n");
2330                 if (gl_info->limits.combined_samplers > MAX_TEXTURES)
2331                     gl_info->limits.vertex_samplers = gl_info->limits.combined_samplers - MAX_TEXTURES;
2332                 else
2333                     gl_info->limits.vertex_samplers = 0;
2334             }
2335         }
2336         else
2337         {
2338             gl_info->limits.combined_samplers = gl_info->limits.fragment_samplers;
2339         }
2340         TRACE_(d3d_caps)("Max vertex samplers: %u.\n", gl_info->limits.vertex_samplers);
2341         TRACE_(d3d_caps)("Max combined samplers: %u.\n", gl_info->limits.combined_samplers);
2342     }
2343     if (gl_info->supported[ARB_VERTEX_BLEND])
2344     {
2345         glGetIntegerv(GL_MAX_VERTEX_UNITS_ARB, &gl_max);
2346         gl_info->limits.blends = gl_max;
2347         TRACE_(d3d_caps)("Max blends: %u.\n", gl_info->limits.blends);
2348     }
2349     if (gl_info->supported[EXT_TEXTURE3D])
2350     {
2351         glGetIntegerv(GL_MAX_3D_TEXTURE_SIZE_EXT, &gl_max);
2352         gl_info->limits.texture3d_size = gl_max;
2353         TRACE_(d3d_caps)("Max texture3D size: %d.\n", gl_info->limits.texture3d_size);
2354     }
2355     if (gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC])
2356     {
2357         glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &gl_max);
2358         gl_info->limits.anisotropy = gl_max;
2359         TRACE_(d3d_caps)("Max anisotropy: %d.\n", gl_info->limits.anisotropy);
2360     }
2361     if (gl_info->supported[ARB_FRAGMENT_PROGRAM])
2362     {
2363         GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max));
2364         gl_info->limits.arb_ps_float_constants = gl_max;
2365         TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM float constants: %d.\n", gl_info->limits.arb_ps_float_constants);
2366         GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB, &gl_max));
2367         gl_info->limits.arb_ps_native_constants = gl_max;
2368         TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM native float constants: %d.\n",
2369                 gl_info->limits.arb_ps_native_constants);
2370         GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, &gl_max));
2371         gl_info->limits.arb_ps_temps = gl_max;
2372         TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM native temporaries: %d.\n", gl_info->limits.arb_ps_temps);
2373         GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, &gl_max));
2374         gl_info->limits.arb_ps_instructions = gl_max;
2375         TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM native instructions: %d.\n", gl_info->limits.arb_ps_instructions);
2376         GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB, &gl_max));
2377         gl_info->limits.arb_ps_local_constants = gl_max;
2378         TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM local parameters: %d.\n", gl_info->limits.arb_ps_instructions);
2379     }
2380     if (gl_info->supported[ARB_VERTEX_PROGRAM])
2381     {
2382         GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max));
2383         gl_info->limits.arb_vs_float_constants = gl_max;
2384         TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM float constants: %d.\n", gl_info->limits.arb_vs_float_constants);
2385         GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB, &gl_max));
2386         gl_info->limits.arb_vs_native_constants = gl_max;
2387         TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM native float constants: %d.\n",
2388                 gl_info->limits.arb_vs_native_constants);
2389         GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, &gl_max));
2390         gl_info->limits.arb_vs_temps = gl_max;
2391         TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM native temporaries: %d.\n", gl_info->limits.arb_vs_temps);
2392         GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, &gl_max));
2393         gl_info->limits.arb_vs_instructions = gl_max;
2394         TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM native instructions: %d.\n", gl_info->limits.arb_vs_instructions);
2395
2396         if (test_arb_vs_offset_limit(gl_info)) gl_info->quirks |= WINED3D_QUIRK_ARB_VS_OFFSET_LIMIT;
2397     }
2398     if (gl_info->supported[ARB_VERTEX_SHADER])
2399     {
2400         glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB, &gl_max);
2401         gl_info->limits.glsl_vs_float_constants = gl_max / 4;
2402         TRACE_(d3d_caps)("Max ARB_VERTEX_SHADER float constants: %u.\n", gl_info->limits.glsl_vs_float_constants);
2403     }
2404     if (gl_info->supported[ARB_FRAGMENT_SHADER])
2405     {
2406         glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB, &gl_max);
2407         gl_info->limits.glsl_ps_float_constants = gl_max / 4;
2408         TRACE_(d3d_caps)("Max ARB_FRAGMENT_SHADER float constants: %u.\n", gl_info->limits.glsl_ps_float_constants);
2409         glGetIntegerv(GL_MAX_VARYING_FLOATS_ARB, &gl_max);
2410         gl_info->limits.glsl_varyings = gl_max;
2411         TRACE_(d3d_caps)("Max GLSL varyings: %u (%u 4 component varyings).\n", gl_max, gl_max / 4);
2412     }
2413     if (gl_info->supported[ARB_SHADING_LANGUAGE_100])
2414     {
2415         const char *str = (const char *)glGetString(GL_SHADING_LANGUAGE_VERSION_ARB);
2416         TRACE_(d3d_caps)("GLSL version string: %s.\n", debugstr_a(str));
2417     }
2418     if (gl_info->supported[NV_LIGHT_MAX_EXPONENT])
2419     {
2420         glGetFloatv(GL_MAX_SHININESS_NV, &gl_info->limits.shininess);
2421     }
2422     else
2423     {
2424         gl_info->limits.shininess = 128.0f;
2425     }
2426     if (gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO])
2427     {
2428         /* If we have full NP2 texture support, disable
2429          * GL_ARB_texture_rectangle because we will never use it.
2430          * This saves a few redundant glDisable calls. */
2431         gl_info->supported[ARB_TEXTURE_RECTANGLE] = FALSE;
2432     }
2433     if (gl_info->supported[ATI_FRAGMENT_SHADER])
2434     {
2435         /* Disable NV_register_combiners and fragment shader if this is supported.
2436          * generally the NV extensions are preferred over the ATI ones, and this
2437          * extension is disabled if register_combiners and texture_shader2 are both
2438          * supported. So we reach this place only if we have incomplete NV dxlevel 8
2439          * fragment processing support. */
2440         gl_info->supported[NV_REGISTER_COMBINERS] = FALSE;
2441         gl_info->supported[NV_REGISTER_COMBINERS2] = FALSE;
2442         gl_info->supported[NV_TEXTURE_SHADER] = FALSE;
2443         gl_info->supported[NV_TEXTURE_SHADER2] = FALSE;
2444     }
2445     if (gl_info->supported[NV_HALF_FLOAT])
2446     {
2447         /* GL_ARB_half_float_vertex is a subset of GL_NV_half_float. */
2448         gl_info->supported[ARB_HALF_FLOAT_VERTEX] = TRUE;
2449     }
2450     if (gl_info->supported[ARB_POINT_SPRITE])
2451     {
2452         gl_info->limits.point_sprite_units = gl_info->limits.textures;
2453     }
2454     else
2455     {
2456         gl_info->limits.point_sprite_units = 0;
2457     }
2458     checkGLcall("extension detection");
2459
2460     LEAVE_GL();
2461
2462     adapter->fragment_pipe = select_fragment_implementation(adapter);
2463     adapter->shader_backend = select_shader_backend(adapter);
2464     adapter->blitter = select_blit_implementation(adapter);
2465
2466     adapter->fragment_pipe->get_caps(gl_info, &fragment_caps);
2467     gl_info->limits.texture_stages = fragment_caps.MaxTextureBlendStages;
2468     TRACE_(d3d_caps)("Max texture stages: %u.\n", gl_info->limits.texture_stages);
2469
2470     /* In some cases the number of texture stages can be larger than the number
2471      * of samplers. The GF4 for example can use only 2 samplers (no fragment
2472      * shaders), but 8 texture stages (register combiners). */
2473     gl_info->limits.sampler_stages = max(gl_info->limits.fragment_samplers, gl_info->limits.texture_stages);
2474
2475     if (gl_info->supported[ARB_FRAMEBUFFER_OBJECT])
2476     {
2477         gl_info->fbo_ops.glIsRenderbuffer = gl_info->glIsRenderbuffer;
2478         gl_info->fbo_ops.glBindRenderbuffer = gl_info->glBindRenderbuffer;
2479         gl_info->fbo_ops.glDeleteRenderbuffers = gl_info->glDeleteRenderbuffers;
2480         gl_info->fbo_ops.glGenRenderbuffers = gl_info->glGenRenderbuffers;
2481         gl_info->fbo_ops.glRenderbufferStorage = gl_info->glRenderbufferStorage;
2482         gl_info->fbo_ops.glRenderbufferStorageMultisample = gl_info->glRenderbufferStorageMultisample;
2483         gl_info->fbo_ops.glGetRenderbufferParameteriv = gl_info->glGetRenderbufferParameteriv;
2484         gl_info->fbo_ops.glIsFramebuffer = gl_info->glIsFramebuffer;
2485         gl_info->fbo_ops.glBindFramebuffer = gl_info->glBindFramebuffer;
2486         gl_info->fbo_ops.glDeleteFramebuffers = gl_info->glDeleteFramebuffers;
2487         gl_info->fbo_ops.glGenFramebuffers = gl_info->glGenFramebuffers;
2488         gl_info->fbo_ops.glCheckFramebufferStatus = gl_info->glCheckFramebufferStatus;
2489         gl_info->fbo_ops.glFramebufferTexture1D = gl_info->glFramebufferTexture1D;
2490         gl_info->fbo_ops.glFramebufferTexture2D = gl_info->glFramebufferTexture2D;
2491         gl_info->fbo_ops.glFramebufferTexture3D = gl_info->glFramebufferTexture3D;
2492         gl_info->fbo_ops.glFramebufferRenderbuffer = gl_info->glFramebufferRenderbuffer;
2493         gl_info->fbo_ops.glGetFramebufferAttachmentParameteriv = gl_info->glGetFramebufferAttachmentParameteriv;
2494         gl_info->fbo_ops.glBlitFramebuffer = gl_info->glBlitFramebuffer;
2495         gl_info->fbo_ops.glGenerateMipmap = gl_info->glGenerateMipmap;
2496     }
2497     else
2498     {
2499         if (gl_info->supported[EXT_FRAMEBUFFER_OBJECT])
2500         {
2501             gl_info->fbo_ops.glIsRenderbuffer = gl_info->glIsRenderbufferEXT;
2502             gl_info->fbo_ops.glBindRenderbuffer = gl_info->glBindRenderbufferEXT;
2503             gl_info->fbo_ops.glDeleteRenderbuffers = gl_info->glDeleteRenderbuffersEXT;
2504             gl_info->fbo_ops.glGenRenderbuffers = gl_info->glGenRenderbuffersEXT;
2505             gl_info->fbo_ops.glRenderbufferStorage = gl_info->glRenderbufferStorageEXT;
2506             gl_info->fbo_ops.glGetRenderbufferParameteriv = gl_info->glGetRenderbufferParameterivEXT;
2507             gl_info->fbo_ops.glIsFramebuffer = gl_info->glIsFramebufferEXT;
2508             gl_info->fbo_ops.glBindFramebuffer = gl_info->glBindFramebufferEXT;
2509             gl_info->fbo_ops.glDeleteFramebuffers = gl_info->glDeleteFramebuffersEXT;
2510             gl_info->fbo_ops.glGenFramebuffers = gl_info->glGenFramebuffersEXT;
2511             gl_info->fbo_ops.glCheckFramebufferStatus = gl_info->glCheckFramebufferStatusEXT;
2512             gl_info->fbo_ops.glFramebufferTexture1D = gl_info->glFramebufferTexture1DEXT;
2513             gl_info->fbo_ops.glFramebufferTexture2D = gl_info->glFramebufferTexture2DEXT;
2514             gl_info->fbo_ops.glFramebufferTexture3D = gl_info->glFramebufferTexture3DEXT;
2515             gl_info->fbo_ops.glFramebufferRenderbuffer = gl_info->glFramebufferRenderbufferEXT;
2516             gl_info->fbo_ops.glGetFramebufferAttachmentParameteriv = gl_info->glGetFramebufferAttachmentParameterivEXT;
2517             gl_info->fbo_ops.glGenerateMipmap = gl_info->glGenerateMipmapEXT;
2518         }
2519         else if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
2520         {
2521             WARN_(d3d_caps)("Framebuffer objects not supported, falling back to backbuffer offscreen rendering mode.\n");
2522             wined3d_settings.offscreen_rendering_mode = ORM_BACKBUFFER;
2523         }
2524         if (gl_info->supported[EXT_FRAMEBUFFER_BLIT])
2525         {
2526             gl_info->fbo_ops.glBlitFramebuffer = gl_info->glBlitFramebufferEXT;
2527         }
2528         if (gl_info->supported[EXT_FRAMEBUFFER_MULTISAMPLE])
2529         {
2530             gl_info->fbo_ops.glRenderbufferStorageMultisample = gl_info->glRenderbufferStorageMultisampleEXT;
2531         }
2532     }
2533
2534     /* MRTs are currently only supported when FBOs are used. */
2535     if (wined3d_settings.offscreen_rendering_mode != ORM_FBO)
2536     {
2537         gl_info->limits.buffers = 1;
2538     }
2539
2540     gl_vendor = wined3d_guess_gl_vendor(gl_info, gl_vendor_str, gl_renderer_str);
2541     card_vendor = wined3d_guess_card_vendor(gl_vendor_str, gl_renderer_str);
2542     TRACE_(d3d_caps)("found GL_VENDOR (%s)->(0x%04x/0x%04x)\n", debugstr_a(gl_vendor_str), gl_vendor, card_vendor);
2543
2544     device = wined3d_guess_card(gl_info, gl_renderer_str, &gl_vendor, &card_vendor, &vidmem);
2545     TRACE_(d3d_caps)("FOUND (fake) card: 0x%x (vendor id), 0x%x (device id)\n", card_vendor, device);
2546
2547     /* If we have an estimate use it, else default to 64MB;  */
2548     if(vidmem)
2549         gl_info->vidmem = vidmem*1024*1024; /* convert from MBs to bytes */
2550     else
2551         gl_info->vidmem = WINE_DEFAULT_VIDMEM;
2552
2553     gl_info->wrap_lookup[WINED3DTADDRESS_WRAP - WINED3DTADDRESS_WRAP] = GL_REPEAT;
2554     gl_info->wrap_lookup[WINED3DTADDRESS_MIRROR - WINED3DTADDRESS_WRAP] =
2555             gl_info->supported[ARB_TEXTURE_MIRRORED_REPEAT] ? GL_MIRRORED_REPEAT_ARB : GL_REPEAT;
2556     gl_info->wrap_lookup[WINED3DTADDRESS_CLAMP - WINED3DTADDRESS_WRAP] = GL_CLAMP_TO_EDGE;
2557     gl_info->wrap_lookup[WINED3DTADDRESS_BORDER - WINED3DTADDRESS_WRAP] =
2558             gl_info->supported[ARB_TEXTURE_BORDER_CLAMP] ? GL_CLAMP_TO_BORDER_ARB : GL_REPEAT;
2559     gl_info->wrap_lookup[WINED3DTADDRESS_MIRRORONCE - WINED3DTADDRESS_WRAP] =
2560             gl_info->supported[ATI_TEXTURE_MIRROR_ONCE] ? GL_MIRROR_CLAMP_TO_EDGE_ATI : GL_REPEAT;
2561
2562     /* Make sure there's an active HDC else the WGL extensions will fail */
2563     hdc = pwglGetCurrentDC();
2564     if (hdc) {
2565         /* Not all GL drivers might offer WGL extensions e.g. VirtualBox */
2566         if(GL_EXTCALL(wglGetExtensionsStringARB))
2567             WGL_Extensions = GL_EXTCALL(wglGetExtensionsStringARB(hdc));
2568
2569         if (NULL == WGL_Extensions) {
2570             ERR("   WGL_Extensions returns NULL\n");
2571         } else {
2572             TRACE_(d3d_caps)("WGL_Extensions reported:\n");
2573             while (*WGL_Extensions != 0x00) {
2574                 const char *Start;
2575                 char ThisExtn[256];
2576
2577                 while (isspace(*WGL_Extensions)) WGL_Extensions++;
2578                 Start = WGL_Extensions;
2579                 while (!isspace(*WGL_Extensions) && *WGL_Extensions != 0x00) {
2580                     WGL_Extensions++;
2581                 }
2582
2583                 len = WGL_Extensions - Start;
2584                 if (len == 0 || len >= sizeof(ThisExtn))
2585                     continue;
2586
2587                 memcpy(ThisExtn, Start, len);
2588                 ThisExtn[len] = '\0';
2589                 TRACE_(d3d_caps)("- %s\n", debugstr_a(ThisExtn));
2590
2591                 if (!strcmp(ThisExtn, "WGL_ARB_pixel_format")) {
2592                     gl_info->supported[WGL_ARB_PIXEL_FORMAT] = TRUE;
2593                     TRACE_(d3d_caps)("FOUND: WGL_ARB_pixel_format support\n");
2594                 }
2595                 if (!strcmp(ThisExtn, "WGL_WINE_pixel_format_passthrough")) {
2596                     gl_info->supported[WGL_WINE_PIXEL_FORMAT_PASSTHROUGH] = TRUE;
2597                     TRACE_(d3d_caps)("FOUND: WGL_WINE_pixel_format_passthrough support\n");
2598                 }
2599             }
2600         }
2601     }
2602
2603     fixup_extensions(gl_info, gl_renderer_str, gl_vendor, card_vendor, device);
2604     init_driver_info(driver_info, card_vendor, device);
2605     add_gl_compat_wrappers(gl_info);
2606
2607     return TRUE;
2608 }
2609
2610 /**********************************************************
2611  * IWineD3D implementation follows
2612  **********************************************************/
2613
2614 static UINT     WINAPI IWineD3DImpl_GetAdapterCount (IWineD3D *iface) {
2615     IWineD3DImpl *This = (IWineD3DImpl *)iface;
2616
2617     TRACE_(d3d_caps)("(%p): Reporting %u adapters\n", This, This->adapter_count);
2618
2619     return This->adapter_count;
2620 }
2621
2622 static HRESULT WINAPI IWineD3DImpl_RegisterSoftwareDevice(IWineD3D *iface, void *init_function)
2623 {
2624     FIXME("iface %p, init_function %p stub!\n", iface, init_function);
2625
2626     return WINED3D_OK;
2627 }
2628
2629 static HMONITOR WINAPI IWineD3DImpl_GetAdapterMonitor(IWineD3D *iface, UINT Adapter) {
2630     IWineD3DImpl *This = (IWineD3DImpl *)iface;
2631
2632     TRACE_(d3d_caps)("(%p)->(%d)\n", This, Adapter);
2633
2634     if (Adapter >= IWineD3DImpl_GetAdapterCount(iface)) {
2635         return NULL;
2636     }
2637
2638     return MonitorFromPoint(This->adapters[Adapter].monitorPoint, MONITOR_DEFAULTTOPRIMARY);
2639 }
2640
2641 /* FIXME: GetAdapterModeCount and EnumAdapterModes currently only returns modes
2642      of the same bpp but different resolutions                                  */
2643
2644 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */
2645 static UINT     WINAPI IWineD3DImpl_GetAdapterModeCount(IWineD3D *iface, UINT Adapter, WINED3DFORMAT Format) {
2646     IWineD3DImpl *This = (IWineD3DImpl *)iface;
2647     TRACE_(d3d_caps)("(%p}->(Adapter: %d, Format: %s)\n", This, Adapter, debug_d3dformat(Format));
2648
2649     if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
2650         return 0;
2651     }
2652
2653     /* TODO: Store modes per adapter and read it from the adapter structure */
2654     if (Adapter == 0) { /* Display */
2655         const struct wined3d_format_desc *format_desc = getFormatDescEntry(Format, &This->adapters[Adapter].gl_info);
2656         UINT format_bits = format_desc->byte_count * CHAR_BIT;
2657         unsigned int i = 0;
2658         unsigned int j = 0;
2659         DEVMODEW mode;
2660
2661         memset(&mode, 0, sizeof(mode));
2662         mode.dmSize = sizeof(mode);
2663
2664         while (EnumDisplaySettingsExW(NULL, j, &mode, 0))
2665         {
2666             ++j;
2667
2668             if (Format == WINED3DFMT_UNKNOWN)
2669             {
2670                 /* This is for D3D8, do not enumerate P8 here */
2671                 if (mode.dmBitsPerPel == 32 || mode.dmBitsPerPel == 16) ++i;
2672             }
2673             else if (mode.dmBitsPerPel == format_bits)
2674             {
2675                 ++i;
2676             }
2677         }
2678
2679         TRACE_(d3d_caps)("(%p}->(Adapter: %d) => %d (out of %d)\n", This, Adapter, i, j);
2680         return i;
2681     } else {
2682         FIXME_(d3d_caps)("Adapter not primary display\n");
2683     }
2684     return 0;
2685 }
2686
2687 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */
2688 static HRESULT WINAPI IWineD3DImpl_EnumAdapterModes(IWineD3D *iface, UINT Adapter, WINED3DFORMAT Format, UINT Mode, WINED3DDISPLAYMODE* pMode) {
2689     IWineD3DImpl *This = (IWineD3DImpl *)iface;
2690     TRACE_(d3d_caps)("(%p}->(Adapter:%d, mode:%d, pMode:%p, format:%s)\n", This, Adapter, Mode, pMode, debug_d3dformat(Format));
2691
2692     /* Validate the parameters as much as possible */
2693     if (NULL == pMode ||
2694         Adapter >= IWineD3DImpl_GetAdapterCount(iface) ||
2695         Mode    >= IWineD3DImpl_GetAdapterModeCount(iface, Adapter, Format)) {
2696         return WINED3DERR_INVALIDCALL;
2697     }
2698
2699     /* TODO: Store modes per adapter and read it from the adapter structure */
2700     if (Adapter == 0)
2701     {
2702         const struct wined3d_format_desc *format_desc = getFormatDescEntry(Format, &This->adapters[Adapter].gl_info);
2703         UINT format_bits = format_desc->byte_count * CHAR_BIT;
2704         DEVMODEW DevModeW;
2705         int ModeIdx = 0;
2706         UINT i = 0;
2707         int j = 0;
2708
2709         ZeroMemory(&DevModeW, sizeof(DevModeW));
2710         DevModeW.dmSize = sizeof(DevModeW);
2711
2712         /* If we are filtering to a specific format (D3D9), then need to skip
2713            all unrelated modes, but if mode is irrelevant (D3D8), then we can
2714            just count through the ones with valid bit depths */
2715         while ((i<=Mode) && EnumDisplaySettingsExW(NULL, j++, &DevModeW, 0))
2716         {
2717             if (Format == WINED3DFMT_UNKNOWN)
2718             {
2719                 /* This is for D3D8, do not enumerate P8 here */
2720                 if (DevModeW.dmBitsPerPel == 32 || DevModeW.dmBitsPerPel == 16) ++i;
2721             }
2722             else if (DevModeW.dmBitsPerPel == format_bits)
2723             {
2724                 ++i;
2725             }
2726         }
2727
2728         if (i == 0) {
2729             TRACE_(d3d_caps)("No modes found for format (%x - %s)\n", Format, debug_d3dformat(Format));
2730             return WINED3DERR_INVALIDCALL;
2731         }
2732         ModeIdx = j - 1;
2733
2734         /* Now get the display mode via the calculated index */
2735         if (EnumDisplaySettingsExW(NULL, ModeIdx, &DevModeW, 0)) {
2736             pMode->Width        = DevModeW.dmPelsWidth;
2737             pMode->Height       = DevModeW.dmPelsHeight;
2738             pMode->RefreshRate  = DEFAULT_REFRESH_RATE;
2739             if (DevModeW.dmFields & DM_DISPLAYFREQUENCY)
2740                 pMode->RefreshRate = DevModeW.dmDisplayFrequency;
2741
2742             if (Format == WINED3DFMT_UNKNOWN) {
2743                 pMode->Format = pixelformat_for_depth(DevModeW.dmBitsPerPel);
2744             } else {
2745                 pMode->Format = Format;
2746             }
2747         } else {
2748             TRACE_(d3d_caps)("Requested mode out of range %d\n", Mode);
2749             return WINED3DERR_INVALIDCALL;
2750         }
2751
2752         TRACE_(d3d_caps)("W %d H %d rr %d fmt (%x - %s) bpp %u\n", pMode->Width, pMode->Height,
2753                 pMode->RefreshRate, pMode->Format, debug_d3dformat(pMode->Format),
2754                 DevModeW.dmBitsPerPel);
2755
2756     }
2757     else
2758     {
2759         FIXME_(d3d_caps)("Adapter not primary display\n");
2760     }
2761
2762     return WINED3D_OK;
2763 }
2764
2765 static HRESULT WINAPI IWineD3DImpl_GetAdapterDisplayMode(IWineD3D *iface, UINT Adapter, WINED3DDISPLAYMODE *pMode)
2766 {
2767     TRACE("iface %p, adapter_idx %u, display_mode %p.\n", iface, Adapter, pMode);
2768
2769     if (NULL == pMode ||
2770         Adapter >= IWineD3D_GetAdapterCount(iface)) {
2771         return WINED3DERR_INVALIDCALL;
2772     }
2773
2774     if (Adapter == 0) { /* Display */
2775         int bpp = 0;
2776         DEVMODEW DevModeW;
2777
2778         ZeroMemory(&DevModeW, sizeof(DevModeW));
2779         DevModeW.dmSize = sizeof(DevModeW);
2780
2781         EnumDisplaySettingsExW(NULL, ENUM_CURRENT_SETTINGS, &DevModeW, 0);
2782         pMode->Width        = DevModeW.dmPelsWidth;
2783         pMode->Height       = DevModeW.dmPelsHeight;
2784         bpp                 = DevModeW.dmBitsPerPel;
2785         pMode->RefreshRate  = DEFAULT_REFRESH_RATE;
2786         if (DevModeW.dmFields&DM_DISPLAYFREQUENCY)
2787         {
2788             pMode->RefreshRate = DevModeW.dmDisplayFrequency;
2789         }
2790
2791         pMode->Format = pixelformat_for_depth(bpp);
2792     } else {
2793         FIXME_(d3d_caps)("Adapter not primary display\n");
2794     }
2795
2796     TRACE_(d3d_caps)("returning w:%d, h:%d, ref:%d, fmt:%s\n", pMode->Width,
2797           pMode->Height, pMode->RefreshRate, debug_d3dformat(pMode->Format));
2798     return WINED3D_OK;
2799 }
2800
2801 /* NOTE: due to structure differences between dx8 and dx9 D3DADAPTER_IDENTIFIER,
2802    and fields being inserted in the middle, a new structure is used in place    */
2803 static HRESULT WINAPI IWineD3DImpl_GetAdapterIdentifier(IWineD3D *iface, UINT Adapter, DWORD Flags,
2804                                                    WINED3DADAPTER_IDENTIFIER* pIdentifier) {
2805     IWineD3DImpl *This = (IWineD3DImpl *)iface;
2806     struct wined3d_adapter *adapter;
2807     size_t len;
2808
2809     TRACE_(d3d_caps)("(%p}->(Adapter: %d, Flags: %x, pId=%p)\n", This, Adapter, Flags, pIdentifier);
2810
2811     if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
2812         return WINED3DERR_INVALIDCALL;
2813     }
2814
2815     adapter = &This->adapters[Adapter];
2816
2817     /* Return the information requested */
2818     TRACE_(d3d_caps)("device/Vendor Name and Version detection using FillGLCaps\n");
2819
2820     if (pIdentifier->driver_size)
2821     {
2822         const char *name = adapter->driver_info.name;
2823         len = min(strlen(name), pIdentifier->driver_size - 1);
2824         memcpy(pIdentifier->driver, name, len);
2825         pIdentifier->driver[len] = '\0';
2826     }
2827
2828     if (pIdentifier->description_size)
2829     {
2830         const char *description = adapter->driver_info.description;
2831         len = min(strlen(description), pIdentifier->description_size - 1);
2832         memcpy(pIdentifier->description, description, len);
2833         pIdentifier->description[len] = '\0';
2834     }
2835
2836     /* Note that d3d8 doesn't supply a device name. */
2837     if (pIdentifier->device_name_size)
2838     {
2839         static const char *device_name = "\\\\.\\DISPLAY1"; /* FIXME: May depend on desktop? */
2840
2841         len = strlen(device_name);
2842         if (len >= pIdentifier->device_name_size)
2843         {
2844             ERR("Device name size too small.\n");
2845             return WINED3DERR_INVALIDCALL;
2846         }
2847
2848         memcpy(pIdentifier->device_name, device_name, len);
2849         pIdentifier->device_name[len] = '\0';
2850     }
2851
2852     pIdentifier->driver_version.u.HighPart = adapter->driver_info.version_high;
2853     pIdentifier->driver_version.u.LowPart = adapter->driver_info.version_low;
2854     pIdentifier->vendor_id = adapter->driver_info.vendor;
2855     pIdentifier->device_id = adapter->driver_info.device;
2856     pIdentifier->subsystem_id = 0;
2857     pIdentifier->revision = 0;
2858     memcpy(&pIdentifier->device_identifier, &IID_D3DDEVICE_D3DUID, sizeof(pIdentifier->device_identifier));
2859     pIdentifier->whql_level = (Flags & WINED3DENUM_NO_WHQL_LEVEL) ? 0 : 1;
2860     memcpy(&pIdentifier->adapter_luid, &adapter->luid, sizeof(pIdentifier->adapter_luid));
2861     pIdentifier->video_memory = adapter->TextureRam;
2862
2863     return WINED3D_OK;
2864 }
2865
2866 static BOOL IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(const struct wined3d_gl_info *gl_info,
2867         const WineD3D_PixelFormat *cfg, const struct wined3d_format_desc *format_desc)
2868 {
2869     short redSize, greenSize, blueSize, alphaSize, colorBits;
2870
2871     if(!cfg)
2872         return FALSE;
2873
2874     /* Float formats need FBOs. If FBOs are used this function isn't called */
2875     if (format_desc->Flags & WINED3DFMT_FLAG_FLOAT) return FALSE;
2876
2877     if(cfg->iPixelType == WGL_TYPE_RGBA_ARB) { /* Integer RGBA formats */
2878         if (!getColorBits(format_desc, &redSize, &greenSize, &blueSize, &alphaSize, &colorBits))
2879         {
2880             ERR("Unable to check compatibility for Format=%s\n", debug_d3dformat(format_desc->format));
2881             return FALSE;
2882         }
2883
2884         if(cfg->redSize < redSize)
2885             return FALSE;
2886
2887         if(cfg->greenSize < greenSize)
2888             return FALSE;
2889
2890         if(cfg->blueSize < blueSize)
2891             return FALSE;
2892
2893         if(cfg->alphaSize < alphaSize)
2894             return FALSE;
2895
2896         return TRUE;
2897     }
2898
2899     /* Probably a RGBA_float or color index mode */
2900     return FALSE;
2901 }
2902
2903 static BOOL IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(const struct wined3d_gl_info *gl_info,
2904         const WineD3D_PixelFormat *cfg, const struct wined3d_format_desc *format_desc)
2905 {
2906     short depthSize, stencilSize;
2907     BOOL lockable = FALSE;
2908
2909     if(!cfg)
2910         return FALSE;
2911
2912     if (!getDepthStencilBits(format_desc, &depthSize, &stencilSize))
2913     {
2914         ERR("Unable to check compatibility for Format=%s\n", debug_d3dformat(format_desc->format));
2915         return FALSE;
2916     }
2917
2918     /* Float formats need FBOs. If FBOs are used this function isn't called */
2919     if (format_desc->Flags & WINED3DFMT_FLAG_FLOAT) return FALSE;
2920
2921     if ((format_desc->format == WINED3DFMT_D16_LOCKABLE) || (format_desc->format == WINED3DFMT_D32_FLOAT))
2922         lockable = TRUE;
2923
2924     /* On some modern cards like the Geforce8/9 GLX doesn't offer some dephthstencil formats which D3D9 reports.
2925      * We can safely report 'compatible' formats (e.g. D24 can be used for D16) as long as we aren't dealing with
2926      * a lockable format. This also helps D3D <= 7 as they expect D16 which isn't offered without this on Geforce8 cards. */
2927     if(!(cfg->depthSize == depthSize || (!lockable && cfg->depthSize > depthSize)))
2928         return FALSE;
2929
2930     /* Some cards like Intel i915 ones only offer D24S8 but lots of games also need a format without stencil, so
2931      * allow more stencil bits than requested. */
2932     if(cfg->stencilSize < stencilSize)
2933         return FALSE;
2934
2935     return TRUE;
2936 }
2937
2938 static HRESULT WINAPI IWineD3DImpl_CheckDepthStencilMatch(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
2939                                                    WINED3DFORMAT AdapterFormat,
2940                                                    WINED3DFORMAT RenderTargetFormat,
2941                                                    WINED3DFORMAT DepthStencilFormat) {
2942     IWineD3DImpl *This = (IWineD3DImpl *)iface;
2943     int nCfgs;
2944     const WineD3D_PixelFormat *cfgs;
2945     const struct wined3d_adapter *adapter;
2946     const struct wined3d_format_desc *rt_format_desc;
2947     const struct wined3d_format_desc *ds_format_desc;
2948     int it;
2949
2950     WARN_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, DevType:(%x,%s), AdptFmt:(%x,%s), RendrTgtFmt:(%x,%s), DepthStencilFmt:(%x,%s))\n",
2951            This, Adapter,
2952            DeviceType, debug_d3ddevicetype(DeviceType),
2953            AdapterFormat, debug_d3dformat(AdapterFormat),
2954            RenderTargetFormat, debug_d3dformat(RenderTargetFormat),
2955            DepthStencilFormat, debug_d3dformat(DepthStencilFormat));
2956
2957     if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
2958         TRACE("(%p) Failed: Atapter (%u) higher than supported adapters (%u) returning WINED3DERR_INVALIDCALL\n", This, Adapter, IWineD3D_GetAdapterCount(iface));
2959         return WINED3DERR_INVALIDCALL;
2960     }
2961
2962     adapter = &This->adapters[Adapter];
2963     rt_format_desc = getFormatDescEntry(RenderTargetFormat, &adapter->gl_info);
2964     ds_format_desc = getFormatDescEntry(DepthStencilFormat, &adapter->gl_info);
2965     if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
2966     {
2967         if ((rt_format_desc->Flags & WINED3DFMT_FLAG_RENDERTARGET) &&
2968             (ds_format_desc->Flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL))) {
2969             TRACE_(d3d_caps)("(%p) : Formats matched\n", This);
2970             return WINED3D_OK;
2971         }
2972     }
2973     else
2974     {
2975         cfgs = adapter->cfgs;
2976         nCfgs = adapter->nCfgs;
2977         for (it = 0; it < nCfgs; ++it) {
2978             if (IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&adapter->gl_info, &cfgs[it], rt_format_desc))
2979             {
2980                 if (IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&adapter->gl_info, &cfgs[it], ds_format_desc))
2981                 {
2982                     TRACE_(d3d_caps)("(%p) : Formats matched\n", This);
2983                     return WINED3D_OK;
2984                 }
2985             }
2986         }
2987     }
2988     WARN_(d3d_caps)("unsupported format pair: %s and %s\n", debug_d3dformat(RenderTargetFormat), debug_d3dformat(DepthStencilFormat));
2989
2990     return WINED3DERR_NOTAVAILABLE;
2991 }
2992
2993 static HRESULT WINAPI IWineD3DImpl_CheckDeviceMultiSampleType(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
2994         WINED3DFORMAT SurfaceFormat, BOOL Windowed, WINED3DMULTISAMPLE_TYPE MultiSampleType, DWORD *pQualityLevels)
2995 {
2996     IWineD3DImpl *This = (IWineD3DImpl *)iface;
2997     const struct wined3d_format_desc *glDesc;
2998     const struct wined3d_adapter *adapter;
2999
3000     TRACE_(d3d_caps)("(%p)-> (Adptr:%d, DevType:(%x,%s), SurfFmt:(%x,%s), Win?%d, MultiSamp:%x, pQual:%p)\n",
3001           This,
3002           Adapter,
3003           DeviceType, debug_d3ddevicetype(DeviceType),
3004           SurfaceFormat, debug_d3dformat(SurfaceFormat),
3005           Windowed,
3006           MultiSampleType,
3007           pQualityLevels);
3008
3009     if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
3010         return WINED3DERR_INVALIDCALL;
3011     }
3012
3013     /* TODO: handle Windowed, add more quality levels */
3014
3015     if (WINED3DMULTISAMPLE_NONE == MultiSampleType) {
3016         if(pQualityLevels) *pQualityLevels = 1;
3017         return WINED3D_OK;
3018     }
3019
3020     /* By default multisampling is disabled right now as it causes issues
3021      * on some Nvidia driver versions and it doesn't work well in combination
3022      * with FBOs yet. */
3023     if(!wined3d_settings.allow_multisampling)
3024         return WINED3DERR_NOTAVAILABLE;
3025
3026     adapter = &This->adapters[Adapter];
3027     glDesc = getFormatDescEntry(SurfaceFormat, &adapter->gl_info);
3028     if (!glDesc) return WINED3DERR_INVALIDCALL;
3029
3030     if(glDesc->Flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL)) {
3031         int i, nCfgs;
3032         const WineD3D_PixelFormat *cfgs;
3033
3034         cfgs = adapter->cfgs;
3035         nCfgs = adapter->nCfgs;
3036         for(i=0; i<nCfgs; i++) {
3037             if(cfgs[i].numSamples != MultiSampleType)
3038                 continue;
3039
3040             if (!IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&adapter->gl_info, &cfgs[i], glDesc))
3041                 continue;
3042
3043             TRACE("Found iPixelFormat=%d to support MultiSampleType=%d for format %s\n", cfgs[i].iPixelFormat, MultiSampleType, debug_d3dformat(SurfaceFormat));
3044
3045             if(pQualityLevels)
3046                 *pQualityLevels = 1; /* Guess at a value! */
3047             return WINED3D_OK;
3048         }
3049     }
3050     else if(glDesc->Flags & WINED3DFMT_FLAG_RENDERTARGET) {
3051         short redSize, greenSize, blueSize, alphaSize, colorBits;
3052         int i, nCfgs;
3053         const WineD3D_PixelFormat *cfgs;
3054
3055         if (!getColorBits(glDesc, &redSize, &greenSize, &blueSize, &alphaSize, &colorBits))
3056         {
3057             ERR("Unable to color bits for format %#x, can't check multisampling capability!\n", SurfaceFormat);
3058             return WINED3DERR_NOTAVAILABLE;
3059         }
3060
3061         cfgs = adapter->cfgs;
3062         nCfgs = adapter->nCfgs;
3063         for(i=0; i<nCfgs; i++) {
3064             if(cfgs[i].numSamples != MultiSampleType)
3065                 continue;
3066             if(cfgs[i].redSize != redSize)
3067                 continue;
3068             if(cfgs[i].greenSize != greenSize)
3069                 continue;
3070             if(cfgs[i].blueSize != blueSize)
3071                 continue;
3072             /* Not all drivers report alpha-less formats since they use 32-bit anyway, so accept alpha even if we didn't ask for it. */
3073             if(alphaSize && cfgs[i].alphaSize != alphaSize)
3074                 continue;
3075             if(cfgs[i].colorSize != (glDesc->byte_count << 3))
3076                 continue;
3077
3078             TRACE("Found iPixelFormat=%d to support MultiSampleType=%d for format %s\n", cfgs[i].iPixelFormat, MultiSampleType, debug_d3dformat(SurfaceFormat));
3079
3080             if(pQualityLevels)
3081                 *pQualityLevels = 1; /* Guess at a value! */
3082             return WINED3D_OK;
3083         }
3084     }
3085     return WINED3DERR_NOTAVAILABLE;
3086 }
3087
3088 static HRESULT WINAPI IWineD3DImpl_CheckDeviceType(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
3089         WINED3DFORMAT DisplayFormat, WINED3DFORMAT BackBufferFormat, BOOL Windowed)
3090 {
3091     HRESULT hr = WINED3DERR_NOTAVAILABLE;
3092     UINT nmodes;
3093
3094     TRACE("iface %p, adapter_idx %u, device_type %s, display_format %s, backbuffer_format %s, windowed %#x.\n",
3095             iface, Adapter, debug_d3ddevicetype(DeviceType), debug_d3dformat(DisplayFormat),
3096             debug_d3dformat(BackBufferFormat), Windowed);
3097
3098     if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
3099         WARN_(d3d_caps)("Adapter >= IWineD3D_GetAdapterCount(iface), returning WINED3DERR_INVALIDCALL\n");
3100         return WINED3DERR_INVALIDCALL;
3101     }
3102
3103     /* The task of this function is to check whether a certain display / backbuffer format
3104      * combination is available on the given adapter. In fullscreen mode microsoft specified
3105      * that the display format shouldn't provide alpha and that ignoring alpha the backbuffer
3106      * and display format should match exactly.
3107      * In windowed mode format conversion can occur and this depends on the driver. When format
3108      * conversion is done, this function should nevertheless fail and applications need to use
3109      * CheckDeviceFormatConversion.
3110      * At the moment we assume that fullscreen and windowed have the same capabilities */
3111
3112     /* There are only 4 display formats */
3113     if (!(DisplayFormat == WINED3DFMT_B5G6R5_UNORM
3114             || DisplayFormat == WINED3DFMT_B5G5R5X1_UNORM
3115             || DisplayFormat == WINED3DFMT_B8G8R8X8_UNORM
3116             || DisplayFormat == WINED3DFMT_B10G10R10A2_UNORM))
3117     {
3118         TRACE_(d3d_caps)("Format %s unsupported as display format\n", debug_d3dformat(DisplayFormat));
3119         return WINED3DERR_NOTAVAILABLE;
3120     }
3121
3122     /* If the requested DisplayFormat is not available, don't continue */
3123     nmodes = IWineD3DImpl_GetAdapterModeCount(iface, Adapter, DisplayFormat);
3124     if(!nmodes) {
3125         TRACE_(d3d_caps)("No available modes for display format %s\n", debug_d3dformat(DisplayFormat));
3126         return WINED3DERR_NOTAVAILABLE;
3127     }
3128
3129     /* Windowed mode allows you to specify WINED3DFMT_UNKNOWN for the backbufferformat, it means 'reuse' the display format for the backbuffer */
3130     if(!Windowed && BackBufferFormat == WINED3DFMT_UNKNOWN) {
3131         TRACE_(d3d_caps)("BackBufferFormat WINED3FMT_UNKNOWN not available in Windowed mode\n");
3132         return WINED3DERR_NOTAVAILABLE;
3133     }
3134
3135     /* In FULLSCREEN mode R5G6B5 can only be mixed with backbuffer format R5G6B5 */
3136     if (DisplayFormat == WINED3DFMT_B5G6R5_UNORM && BackBufferFormat != WINED3DFMT_B5G6R5_UNORM)
3137     {
3138         TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat), debug_d3dformat(BackBufferFormat));
3139         return WINED3DERR_NOTAVAILABLE;
3140     }
3141
3142     /* In FULLSCREEN mode X1R5G5B5 can only be mixed with backbuffer format *1R5G5B5 */
3143     if (DisplayFormat == WINED3DFMT_B5G5R5X1_UNORM
3144             && !(BackBufferFormat == WINED3DFMT_B5G5R5X1_UNORM || BackBufferFormat == WINED3DFMT_B5G5R5A1_UNORM))
3145     {
3146         TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat), debug_d3dformat(BackBufferFormat));
3147         return WINED3DERR_NOTAVAILABLE;
3148     }
3149
3150     /* In FULLSCREEN mode X8R8G8B8 can only be mixed with backbuffer format *8R8G8B8 */
3151     if (DisplayFormat == WINED3DFMT_B8G8R8X8_UNORM
3152             && !(BackBufferFormat == WINED3DFMT_B8G8R8X8_UNORM || BackBufferFormat == WINED3DFMT_B8G8R8A8_UNORM))
3153     {
3154         TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat), debug_d3dformat(BackBufferFormat));
3155         return WINED3DERR_NOTAVAILABLE;
3156     }
3157
3158     /* A2R10G10B10 is only allowed in fullscreen mode and it can only be mixed with backbuffer format A2R10G10B10 */
3159     if (DisplayFormat == WINED3DFMT_B10G10R10A2_UNORM
3160             && (BackBufferFormat != WINED3DFMT_B10G10R10A2_UNORM || Windowed))
3161     {
3162         TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat), debug_d3dformat(BackBufferFormat));
3163         return WINED3DERR_NOTAVAILABLE;
3164     }
3165
3166     /* Use CheckDeviceFormat to see if the BackBufferFormat is usable with the given DisplayFormat */
3167     hr = IWineD3DImpl_CheckDeviceFormat(iface, Adapter, DeviceType, DisplayFormat, WINED3DUSAGE_RENDERTARGET, WINED3DRTYPE_SURFACE, BackBufferFormat, SURFACE_OPENGL);
3168     if(FAILED(hr))
3169         TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat), debug_d3dformat(BackBufferFormat));
3170
3171     return hr;
3172 }
3173
3174
3175 /* Check if we support bumpmapping for a format */
3176 static BOOL CheckBumpMapCapability(struct wined3d_adapter *adapter,
3177         WINED3DDEVTYPE DeviceType, const struct wined3d_format_desc *format_desc)
3178 {
3179     switch(format_desc->format)
3180     {
3181         case WINED3DFMT_R8G8_SNORM:
3182         case WINED3DFMT_R16G16_SNORM:
3183         case WINED3DFMT_R5G5_SNORM_L6_UNORM:
3184         case WINED3DFMT_R8G8_SNORM_L8X8_UNORM:
3185         case WINED3DFMT_R8G8B8A8_SNORM:
3186             /* Ask the fixed function pipeline implementation if it can deal
3187              * with the conversion. If we've got a GL extension giving native
3188              * support this will be an identity conversion. */
3189             if (adapter->fragment_pipe->color_fixup_supported(format_desc->color_fixup))
3190             {
3191                 TRACE_(d3d_caps)("[OK]\n");
3192                 return TRUE;
3193             }
3194             TRACE_(d3d_caps)("[FAILED]\n");
3195             return FALSE;
3196
3197         default:
3198             TRACE_(d3d_caps)("[FAILED]\n");
3199             return FALSE;
3200     }
3201 }
3202
3203 /* Check if the given DisplayFormat + DepthStencilFormat combination is valid for the Adapter */
3204 static BOOL CheckDepthStencilCapability(struct wined3d_adapter *adapter,
3205         const struct wined3d_format_desc *display_format_desc, const struct wined3d_format_desc *ds_format_desc)
3206 {
3207     int it=0;
3208
3209     /* Only allow depth/stencil formats */
3210     if (!(ds_format_desc->depth_size || ds_format_desc->stencil_size)) return FALSE;
3211
3212     if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
3213     {
3214         /* With FBOs WGL limitations do not apply, but the format needs to be FBO attachable */
3215         if (ds_format_desc->Flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL)) return TRUE;
3216     }
3217     else
3218     {
3219         /* Walk through all WGL pixel formats to find a match */
3220         for (it = 0; it < adapter->nCfgs; ++it)
3221         {
3222             WineD3D_PixelFormat *cfg = &adapter->cfgs[it];
3223             if (IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&adapter->gl_info, cfg, display_format_desc))
3224             {
3225                 if (IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&adapter->gl_info, cfg, ds_format_desc))
3226                 {
3227                     return TRUE;
3228                 }
3229             }
3230         }
3231     }
3232
3233     return FALSE;
3234 }
3235
3236 static BOOL CheckFilterCapability(struct wined3d_adapter *adapter, const struct wined3d_format_desc *format_desc)
3237 {
3238     /* The flags entry of a format contains the filtering capability */
3239     if (format_desc->Flags & WINED3DFMT_FLAG_FILTERING) return TRUE;
3240
3241     return FALSE;
3242 }
3243
3244 /* Check the render target capabilities of a format */
3245 static BOOL CheckRenderTargetCapability(struct wined3d_adapter *adapter,
3246         const struct wined3d_format_desc *adapter_format_desc, const struct wined3d_format_desc *check_format_desc)
3247 {
3248     /* Filter out non-RT formats */
3249     if (!(check_format_desc->Flags & WINED3DFMT_FLAG_RENDERTARGET)) return FALSE;
3250     if(wined3d_settings.offscreen_rendering_mode == ORM_BACKBUFFER) {
3251         WineD3D_PixelFormat *cfgs = adapter->cfgs;
3252         int it;
3253         short AdapterRed, AdapterGreen, AdapterBlue, AdapterAlpha, AdapterTotalSize;
3254         short CheckRed, CheckGreen, CheckBlue, CheckAlpha, CheckTotalSize;
3255
3256         getColorBits(adapter_format_desc, &AdapterRed, &AdapterGreen, &AdapterBlue, &AdapterAlpha, &AdapterTotalSize);
3257         getColorBits(check_format_desc, &CheckRed, &CheckGreen, &CheckBlue, &CheckAlpha, &CheckTotalSize);
3258
3259         /* In backbuffer mode the front and backbuffer share the same WGL pixelformat.
3260          * The format must match in RGB, alpha is allowed to be different. (Only the backbuffer can have alpha) */
3261         if(!((AdapterRed == CheckRed) && (AdapterGreen == CheckGreen) && (AdapterBlue == CheckBlue))) {
3262             TRACE_(d3d_caps)("[FAILED]\n");
3263             return FALSE;
3264         }
3265
3266         /* Check if there is a WGL pixel format matching the requirements, the format should also be window
3267          * drawable (not offscreen; e.g. Nvidia offers R5G6B5 for pbuffers even when X is running at 24bit) */
3268         for (it = 0; it < adapter->nCfgs; ++it)
3269         {
3270             if (cfgs[it].windowDrawable && IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&adapter->gl_info,
3271                     &cfgs[it], check_format_desc))
3272             {
3273                 TRACE_(d3d_caps)("iPixelFormat=%d is compatible with CheckFormat=%s\n",
3274                         cfgs[it].iPixelFormat, debug_d3dformat(check_format_desc->format));
3275                 return TRUE;
3276             }
3277         }
3278     }
3279     else if(wined3d_settings.offscreen_rendering_mode == ORM_FBO)
3280     {
3281         /* For now return TRUE for FBOs until we have some proper checks.
3282          * Note that this function will only be called when the format is around for texturing. */
3283         return TRUE;
3284     }
3285     return FALSE;
3286 }
3287
3288 static BOOL CheckSrgbReadCapability(struct wined3d_adapter *adapter, const struct wined3d_format_desc *format_desc)
3289 {
3290     const struct wined3d_gl_info *gl_info = &adapter->gl_info;
3291
3292     /* Check for supported sRGB formats (Texture loading and framebuffer) */
3293     if (!gl_info->supported[EXT_TEXTURE_SRGB])
3294     {
3295         TRACE_(d3d_caps)("[FAILED] GL_EXT_texture_sRGB not supported\n");
3296         return FALSE;
3297     }
3298
3299     switch (format_desc->format)
3300     {
3301         case WINED3DFMT_B8G8R8A8_UNORM:
3302         case WINED3DFMT_B8G8R8X8_UNORM:
3303         case WINED3DFMT_B4G4R4A4_UNORM:
3304         case WINED3DFMT_L8_UNORM:
3305         case WINED3DFMT_L8A8_UNORM:
3306         case WINED3DFMT_DXT1:
3307         case WINED3DFMT_DXT2:
3308         case WINED3DFMT_DXT3:
3309         case WINED3DFMT_DXT4:
3310         case WINED3DFMT_DXT5:
3311             TRACE_(d3d_caps)("[OK]\n");
3312             return TRUE;
3313
3314         default:
3315             TRACE_(d3d_caps)("[FAILED] Gamma texture format %s not supported.\n", debug_d3dformat(format_desc->format));
3316             return FALSE;
3317     }
3318     return FALSE;
3319 }
3320
3321 static BOOL CheckSrgbWriteCapability(struct wined3d_adapter *adapter,
3322         WINED3DDEVTYPE DeviceType, const struct wined3d_format_desc *format_desc)
3323 {
3324     /* Only offer SRGB writing on X8R8G8B8/A8R8G8B8 when we use ARB or GLSL shaders as we are
3325      * doing the color fixup in shaders.
3326      * Note Windows drivers (at least on the Geforce 8800) also offer this on R5G6B5. */
3327     if ((format_desc->format == WINED3DFMT_B8G8R8X8_UNORM) || (format_desc->format == WINED3DFMT_B8G8R8A8_UNORM))
3328     {
3329         int vs_selected_mode;
3330         int ps_selected_mode;
3331         select_shader_mode(&adapter->gl_info, &ps_selected_mode, &vs_selected_mode);
3332
3333         if((ps_selected_mode == SHADER_ARB) || (ps_selected_mode == SHADER_GLSL)) {
3334             TRACE_(d3d_caps)("[OK]\n");
3335             return TRUE;
3336         }
3337     }
3338
3339     TRACE_(d3d_caps)("[FAILED] - no SRGB writing support on format=%s\n", debug_d3dformat(format_desc->format));
3340     return FALSE;
3341 }
3342
3343 /* Check if a format support blending in combination with pixel shaders */
3344 static BOOL CheckPostPixelShaderBlendingCapability(struct wined3d_adapter *adapter,
3345         const struct wined3d_format_desc *format_desc)
3346 {
3347     /* The flags entry of a format contains the post pixel shader blending capability */
3348     if (format_desc->Flags & WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING) return TRUE;
3349
3350     return FALSE;
3351 }
3352
3353 static BOOL CheckWrapAndMipCapability(struct wined3d_adapter *adapter, const struct wined3d_format_desc *format_desc)
3354 {
3355     /* OpenGL supports mipmapping on all formats basically. Wrapping is unsupported,
3356      * but we have to report mipmapping so we cannot reject this flag. Tests show that
3357      * windows reports WRAPANDMIP on unfilterable surfaces as well, apparently to show
3358      * that wrapping is supported. The lack of filtering will sort out the mipmapping
3359      * capability anyway.
3360      *
3361      * For now lets report this on all formats, but in the future we may want to
3362      * restrict it to some should games need that
3363      */
3364     return TRUE;
3365 }
3366
3367 /* Check if a texture format is supported on the given adapter */
3368 static BOOL CheckTextureCapability(struct wined3d_adapter *adapter,
3369         WINED3DDEVTYPE DeviceType, const struct wined3d_format_desc *format_desc)
3370 {
3371     const struct wined3d_gl_info *gl_info = &adapter->gl_info;
3372
3373     switch (format_desc->format)
3374     {
3375         /*****
3376          *  supported: RGB(A) formats
3377          */
3378         case WINED3DFMT_B8G8R8_UNORM: /* Enable for dx7, blacklisted for 8 and 9 above */
3379         case WINED3DFMT_B8G8R8A8_UNORM:
3380         case WINED3DFMT_B8G8R8X8_UNORM:
3381         case WINED3DFMT_B5G6R5_UNORM:
3382         case WINED3DFMT_B5G5R5X1_UNORM:
3383         case WINED3DFMT_B5G5R5A1_UNORM:
3384         case WINED3DFMT_B4G4R4A4_UNORM:
3385         case WINED3DFMT_A8_UNORM:
3386         case WINED3DFMT_B4G4R4X4_UNORM:
3387         case WINED3DFMT_R8G8B8A8_UNORM:
3388         case WINED3DFMT_R8G8B8X8_UNORM:
3389         case WINED3DFMT_B10G10R10A2_UNORM:
3390         case WINED3DFMT_R10G10B10A2_UNORM:
3391         case WINED3DFMT_R16G16_UNORM:
3392             TRACE_(d3d_caps)("[OK]\n");
3393             return TRUE;
3394
3395         case WINED3DFMT_B2G3R3_UNORM:
3396             TRACE_(d3d_caps)("[FAILED] - Not supported on Windows\n");
3397             return FALSE;
3398
3399         /*****
3400          *  supported: Palettized
3401          */
3402         case WINED3DFMT_P8_UINT:
3403             TRACE_(d3d_caps)("[OK]\n");
3404             return TRUE;
3405         /* No Windows driver offers WINED3DFMT_P8_UINT_A8_UNORM, so don't offer it either */
3406         case WINED3DFMT_P8_UINT_A8_UNORM:
3407             return FALSE;
3408
3409         /*****
3410          *  Supported: (Alpha)-Luminance
3411          */
3412         case WINED3DFMT_L8_UNORM:
3413         case WINED3DFMT_L8A8_UNORM:
3414         case WINED3DFMT_L16_UNORM:
3415             TRACE_(d3d_caps)("[OK]\n");
3416             return TRUE;
3417
3418         /* Not supported on Windows, thus disabled */
3419         case WINED3DFMT_L4A4_UNORM:
3420             TRACE_(d3d_caps)("[FAILED] - not supported on windows\n");
3421             return FALSE;
3422
3423         /*****
3424          *  Supported: Depth/Stencil formats
3425          */
3426         case WINED3DFMT_D16_LOCKABLE:
3427         case WINED3DFMT_D16_UNORM:
3428         case WINED3DFMT_S1_UINT_D15_UNORM:
3429         case WINED3DFMT_X8D24_UNORM:
3430         case WINED3DFMT_S4X4_UINT_D24_UNORM:
3431         case WINED3DFMT_D24_UNORM_S8_UINT:
3432         case WINED3DFMT_S8_UINT_D24_FLOAT:
3433         case WINED3DFMT_D32_UNORM:
3434         case WINED3DFMT_D32_FLOAT:
3435             return TRUE;
3436
3437         /*****
3438          *  Not supported everywhere(depends on GL_ATI_envmap_bumpmap or
3439          *  GL_NV_texture_shader). Emulated by shaders
3440          */
3441         case WINED3DFMT_R8G8_SNORM:
3442         case WINED3DFMT_R8G8_SNORM_L8X8_UNORM:
3443         case WINED3DFMT_R5G5_SNORM_L6_UNORM:
3444         case WINED3DFMT_R8G8B8A8_SNORM:
3445         case WINED3DFMT_R16G16_SNORM:
3446             /* Ask the shader backend if it can deal with the conversion. If
3447              * we've got a GL extension giving native support this will be an
3448              * identity conversion. */
3449             if (adapter->shader_backend->shader_color_fixup_supported(format_desc->color_fixup))
3450             {
3451                 TRACE_(d3d_caps)("[OK]\n");
3452                 return TRUE;
3453             }
3454             TRACE_(d3d_caps)("[FAILED]\n");
3455             return FALSE;
3456
3457         case WINED3DFMT_DXT1:
3458         case WINED3DFMT_DXT2:
3459         case WINED3DFMT_DXT3:
3460         case WINED3DFMT_DXT4:
3461         case WINED3DFMT_DXT5:
3462             if (gl_info->supported[EXT_TEXTURE_COMPRESSION_S3TC])
3463             {
3464                 TRACE_(d3d_caps)("[OK]\n");
3465                 return TRUE;
3466             }
3467             TRACE_(d3d_caps)("[FAILED]\n");
3468             return FALSE;
3469
3470
3471         /*****
3472          *  Odd formats - not supported
3473          */
3474         case WINED3DFMT_VERTEXDATA:
3475         case WINED3DFMT_R16_UINT:
3476         case WINED3DFMT_R32_UINT:
3477         case WINED3DFMT_R16G16B16A16_SNORM:
3478         case WINED3DFMT_R10G10B10_SNORM_A2_UNORM:
3479         case WINED3DFMT_R10G11B11_SNORM:
3480             TRACE_(d3d_caps)("[FAILED]\n"); /* Enable when implemented */
3481             return FALSE;
3482
3483         /*****
3484          *  WINED3DFMT_R8G8_SNORM_Cx: Not supported right now
3485          */
3486         case WINED3DFMT_R8G8_SNORM_Cx:
3487             TRACE_(d3d_caps)("[FAILED]\n"); /* Enable when implemented */
3488             return FALSE;
3489
3490         /* YUV formats */
3491         case WINED3DFMT_UYVY:
3492         case WINED3DFMT_YUY2:
3493             if (gl_info->supported[APPLE_YCBCR_422])
3494             {
3495                 TRACE_(d3d_caps)("[OK]\n");
3496                 return TRUE;
3497             }
3498             TRACE_(d3d_caps)("[FAILED]\n");
3499             return FALSE;
3500         case WINED3DFMT_YV12:
3501             TRACE_(d3d_caps)("[FAILED]\n");
3502             return FALSE;
3503
3504             /* Not supported */
3505         case WINED3DFMT_R16G16B16A16_UNORM:
3506         case WINED3DFMT_B2G3R3A8_UNORM:
3507             TRACE_(d3d_caps)("[FAILED]\n"); /* Enable when implemented */
3508             return FALSE;
3509
3510             /* Floating point formats */
3511         case WINED3DFMT_R16_FLOAT:
3512         case WINED3DFMT_R16G16_FLOAT:
3513         case WINED3DFMT_R16G16B16A16_FLOAT:
3514             if (gl_info->supported[ARB_TEXTURE_FLOAT] && gl_info->supported[ARB_HALF_FLOAT_PIXEL])
3515             {
3516                 TRACE_(d3d_caps)("[OK]\n");
3517                 return TRUE;
3518             }
3519             TRACE_(d3d_caps)("[FAILED]\n");
3520             return FALSE;
3521
3522         case WINED3DFMT_R32_FLOAT:
3523         case WINED3DFMT_R32G32_FLOAT:
3524         case WINED3DFMT_R32G32B32A32_FLOAT:
3525             if (gl_info->supported[ARB_TEXTURE_FLOAT])
3526             {
3527                 TRACE_(d3d_caps)("[OK]\n");
3528                 return TRUE;
3529             }
3530             TRACE_(d3d_caps)("[FAILED]\n");
3531             return FALSE;
3532
3533         /* ATI instancing hack: Although ATI cards do not support Shader Model 3.0, they support
3534          * instancing. To query if the card supports instancing CheckDeviceFormat with the special format
3535          * MAKEFOURCC('I','N','S','T') is used. Should a (broken) app check for this provide a proper return value.
3536          * We can do instancing with all shader versions, but we need vertex shaders.
3537          *
3538          * Additionally applications have to set the D3DRS_POINTSIZE render state to MAKEFOURCC('I','N','S','T') once
3539          * to enable instancing. WineD3D doesn't need that and just ignores it.
3540          *
3541          * With Shader Model 3.0 capable cards Instancing 'just works' in Windows.
3542          */
3543         case WINED3DFMT_INST:
3544             TRACE("ATI Instancing check hack\n");
3545             if (gl_info->supported[ARB_VERTEX_PROGRAM] || gl_info->supported[ARB_VERTEX_SHADER])
3546             {
3547                 TRACE_(d3d_caps)("[OK]\n");
3548                 return TRUE;
3549             }
3550             TRACE_(d3d_caps)("[FAILED]\n");
3551             return FALSE;
3552
3553         /* Some weird FOURCC formats */
3554         case WINED3DFMT_R8G8_B8G8:
3555         case WINED3DFMT_G8R8_G8B8:
3556         case WINED3DFMT_MULTI2_ARGB8:
3557             TRACE_(d3d_caps)("[FAILED]\n");
3558             return FALSE;
3559
3560         /* Vendor specific formats */
3561         case WINED3DFMT_ATI2N:
3562             if (gl_info->supported[ATI_TEXTURE_COMPRESSION_3DC]
3563                     || gl_info->supported[EXT_TEXTURE_COMPRESSION_RGTC])
3564             {
3565                 if (adapter->shader_backend->shader_color_fixup_supported(format_desc->color_fixup)
3566                         && adapter->fragment_pipe->color_fixup_supported(format_desc->color_fixup))
3567                 {
3568                     TRACE_(d3d_caps)("[OK]\n");
3569                     return TRUE;
3570                 }
3571
3572                 TRACE_(d3d_caps)("[OK]\n");
3573                 return TRUE;
3574             }
3575             TRACE_(d3d_caps)("[FAILED]\n");
3576             return FALSE;
3577
3578         case WINED3DFMT_NVHU:
3579         case WINED3DFMT_NVHS:
3580             /* These formats seem to be similar to the HILO formats in GL_NV_texture_shader. NVHU
3581              * is said to be GL_UNSIGNED_HILO16, NVHS GL_SIGNED_HILO16. Rumours say that d3d computes
3582              * a 3rd channel similarly to D3DFMT_CxV8U8(So NVHS could be called D3DFMT_CxV16U16).
3583              * ATI refused to support formats which can easilly be emulated with pixel shaders, so
3584              * Applications have to deal with not having NVHS and NVHU.
3585              */
3586             TRACE_(d3d_caps)("[FAILED]\n");
3587             return FALSE;
3588
3589         case WINED3DFMT_UNKNOWN:
3590             return FALSE;
3591
3592         default:
3593             ERR("Unhandled format=%s\n", debug_d3dformat(format_desc->format));
3594             break;
3595     }
3596     return FALSE;
3597 }
3598
3599 static BOOL CheckSurfaceCapability(struct wined3d_adapter *adapter,
3600         const struct wined3d_format_desc *adapter_format_desc,
3601         WINED3DDEVTYPE DeviceType, const struct wined3d_format_desc *check_format_desc,
3602         WINED3DSURFTYPE SurfaceType)
3603 {
3604     if(SurfaceType == SURFACE_GDI) {
3605         switch(check_format_desc->format)
3606         {
3607             case WINED3DFMT_B8G8R8_UNORM:
3608             case WINED3DFMT_B8G8R8A8_UNORM:
3609             case WINED3DFMT_B8G8R8X8_UNORM:
3610             case WINED3DFMT_B5G6R5_UNORM:
3611             case WINED3DFMT_B5G5R5X1_UNORM:
3612             case WINED3DFMT_B5G5R5A1_UNORM:
3613             case WINED3DFMT_B4G4R4A4_UNORM:
3614             case WINED3DFMT_B2G3R3_UNORM:
3615             case WINED3DFMT_A8_UNORM:
3616             case WINED3DFMT_B2G3R3A8_UNORM:
3617             case WINED3DFMT_B4G4R4X4_UNORM:
3618             case WINED3DFMT_R10G10B10A2_UNORM:
3619             case WINED3DFMT_R8G8B8A8_UNORM:
3620             case WINED3DFMT_R8G8B8X8_UNORM:
3621             case WINED3DFMT_R16G16_UNORM:
3622             case WINED3DFMT_B10G10R10A2_UNORM:
3623             case WINED3DFMT_R16G16B16A16_UNORM:
3624             case WINED3DFMT_P8_UINT:
3625                 TRACE_(d3d_caps)("[OK]\n");
3626                 return TRUE;
3627             default:
3628                 TRACE_(d3d_caps)("[FAILED] - not available on GDI surfaces\n");
3629                 return FALSE;
3630         }
3631     }
3632
3633     /* All format that are supported for textures are supported for surfaces as well */
3634     if (CheckTextureCapability(adapter, DeviceType, check_format_desc)) return TRUE;
3635     /* All depth stencil formats are supported on surfaces */
3636     if (CheckDepthStencilCapability(adapter, adapter_format_desc, check_format_desc)) return TRUE;
3637
3638     /* If opengl can't process the format natively, the blitter may be able to convert it */
3639     if (adapter->blitter->color_fixup_supported(&adapter->gl_info, check_format_desc->color_fixup))
3640     {
3641         TRACE_(d3d_caps)("[OK]\n");
3642         return TRUE;
3643     }
3644
3645     /* Reject other formats */
3646     TRACE_(d3d_caps)("[FAILED]\n");
3647     return FALSE;
3648 }
3649
3650 static BOOL CheckVertexTextureCapability(struct wined3d_adapter *adapter,
3651         const struct wined3d_format_desc *format_desc)
3652 {
3653     const struct wined3d_gl_info *gl_info = &adapter->gl_info;
3654
3655     if (!gl_info->limits.vertex_samplers)
3656     {
3657         TRACE_(d3d_caps)("[FAILED]\n");
3658         return FALSE;
3659     }
3660
3661     switch (format_desc->format)
3662     {
3663         case WINED3DFMT_R32G32B32A32_FLOAT:
3664             if (!gl_info->supported[ARB_TEXTURE_FLOAT])
3665             {
3666                 TRACE_(d3d_caps)("[FAILED]\n");
3667                 return FALSE;
3668             }
3669             TRACE_(d3d_caps)("[OK]\n");
3670             return TRUE;
3671
3672         default:
3673             TRACE_(d3d_caps)("[FAILED]\n");
3674             return FALSE;
3675     }
3676     return FALSE;
3677 }
3678
3679 static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
3680         WINED3DFORMAT AdapterFormat, DWORD Usage, WINED3DRESOURCETYPE RType, WINED3DFORMAT CheckFormat,
3681         WINED3DSURFTYPE SurfaceType)
3682 {
3683     IWineD3DImpl *This = (IWineD3DImpl *)iface;
3684     struct wined3d_adapter *adapter = &This->adapters[Adapter];
3685     const struct wined3d_gl_info *gl_info = &adapter->gl_info;
3686     const struct wined3d_format_desc *format_desc = getFormatDescEntry(CheckFormat, gl_info);
3687     const struct wined3d_format_desc *adapter_format_desc = getFormatDescEntry(AdapterFormat, gl_info);
3688     DWORD UsageCaps = 0;
3689
3690     TRACE_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, DevType:(%u,%s), AdptFmt:(%u,%s), Use:(%u,%s,%s), ResTyp:(%x,%s), CheckFmt:(%u,%s))\n",
3691           This,
3692           Adapter,
3693           DeviceType, debug_d3ddevicetype(DeviceType),
3694           AdapterFormat, debug_d3dformat(AdapterFormat),
3695           Usage, debug_d3dusage(Usage), debug_d3dusagequery(Usage),
3696           RType, debug_d3dresourcetype(RType),
3697           CheckFormat, debug_d3dformat(CheckFormat));
3698
3699     if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
3700         return WINED3DERR_INVALIDCALL;
3701     }
3702
3703     if(RType == WINED3DRTYPE_CUBETEXTURE) {
3704
3705         if(SurfaceType != SURFACE_OPENGL) {
3706             TRACE("[FAILED]\n");
3707             return WINED3DERR_NOTAVAILABLE;
3708         }
3709
3710         /* Cubetexture allows:
3711          *                    - D3DUSAGE_AUTOGENMIPMAP
3712          *                    - D3DUSAGE_DEPTHSTENCIL
3713          *                    - D3DUSAGE_DYNAMIC
3714          *                    - D3DUSAGE_NONSECURE (d3d9ex)
3715          *                    - D3DUSAGE_RENDERTARGET
3716          *                    - D3DUSAGE_SOFTWAREPROCESSING
3717          *                    - D3DUSAGE_QUERY_WRAPANDMIP
3718          */
3719         if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
3720         {
3721             /* Check if the texture format is around */
3722             if (CheckTextureCapability(adapter, DeviceType, format_desc))
3723             {
3724                 if(Usage & WINED3DUSAGE_AUTOGENMIPMAP) {
3725                     /* Check for automatic mipmap generation support */
3726                     if (gl_info->supported[SGIS_GENERATE_MIPMAP])
3727                     {
3728                         UsageCaps |= WINED3DUSAGE_AUTOGENMIPMAP;
3729                     } else {
3730                         /* When autogenmipmap isn't around continue and return WINED3DOK_NOAUTOGEN instead of D3D_OK */
3731                         TRACE_(d3d_caps)("[FAILED] - No autogenmipmap support, but continuing\n");
3732                     }
3733                 }
3734
3735                 /* Always report dynamic locking */
3736                 if(Usage & WINED3DUSAGE_DYNAMIC)
3737                     UsageCaps |= WINED3DUSAGE_DYNAMIC;
3738
3739                 if(Usage & WINED3DUSAGE_RENDERTARGET) {
3740                     if(CheckRenderTargetCapability(adapter, adapter_format_desc, format_desc))
3741                     {
3742                         UsageCaps |= WINED3DUSAGE_RENDERTARGET;
3743                     } else {
3744                         TRACE_(d3d_caps)("[FAILED] - No rendertarget support\n");
3745                         return WINED3DERR_NOTAVAILABLE;
3746                     }
3747                 }
3748
3749                 /* Always report software processing */
3750                 if(Usage & WINED3DUSAGE_SOFTWAREPROCESSING)
3751                     UsageCaps |= WINED3DUSAGE_SOFTWAREPROCESSING;
3752
3753                 /* Check QUERY_FILTER support */
3754                 if(Usage & WINED3DUSAGE_QUERY_FILTER) {
3755                     if (CheckFilterCapability(adapter, format_desc))
3756                     {
3757                         UsageCaps |= WINED3DUSAGE_QUERY_FILTER;
3758                     } else {
3759                         TRACE_(d3d_caps)("[FAILED] - No query filter support\n");
3760                         return WINED3DERR_NOTAVAILABLE;
3761                     }
3762                 }
3763
3764                 /* Check QUERY_POSTPIXELSHADER_BLENDING support */
3765                 if(Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING) {
3766                     if (CheckPostPixelShaderBlendingCapability(adapter, format_desc))
3767                     {
3768                         UsageCaps |= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
3769                     } else {
3770                         TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
3771                         return WINED3DERR_NOTAVAILABLE;
3772                     }
3773                 }
3774
3775                 /* Check QUERY_SRGBREAD support */
3776                 if(Usage & WINED3DUSAGE_QUERY_SRGBREAD) {
3777                     if (CheckSrgbReadCapability(adapter, format_desc))
3778                     {
3779                         UsageCaps |= WINED3DUSAGE_QUERY_SRGBREAD;
3780                     } else {
3781                         TRACE_(d3d_caps)("[FAILED] - No query srgbread support\n");
3782                         return WINED3DERR_NOTAVAILABLE;
3783                     }
3784                 }
3785
3786                 /* Check QUERY_SRGBWRITE support */
3787                 if(Usage & WINED3DUSAGE_QUERY_SRGBWRITE) {
3788                     if (CheckSrgbWriteCapability(adapter, DeviceType, format_desc))
3789                     {
3790                         UsageCaps |= WINED3DUSAGE_QUERY_SRGBWRITE;
3791                     } else {
3792                         TRACE_(d3d_caps)("[FAILED] - No query srgbwrite support\n");
3793                         return WINED3DERR_NOTAVAILABLE;
3794                     }
3795                 }
3796
3797                 /* Check QUERY_VERTEXTEXTURE support */
3798                 if(Usage & WINED3DUSAGE_QUERY_VERTEXTEXTURE) {
3799                     if (CheckVertexTextureCapability(adapter, format_desc))
3800                     {
3801                         UsageCaps |= WINED3DUSAGE_QUERY_VERTEXTEXTURE;
3802                     } else {
3803                         TRACE_(d3d_caps)("[FAILED] - No query vertextexture support\n");
3804                         return WINED3DERR_NOTAVAILABLE;
3805                     }
3806                 }
3807
3808                 /* Check QUERY_WRAPANDMIP support */
3809                 if(Usage & WINED3DUSAGE_QUERY_WRAPANDMIP) {
3810                     if (CheckWrapAndMipCapability(adapter, format_desc))
3811                     {
3812                         UsageCaps |= WINED3DUSAGE_QUERY_WRAPANDMIP;
3813                     } else {
3814                         TRACE_(d3d_caps)("[FAILED] - No wrapping and mipmapping support\n");
3815                         return WINED3DERR_NOTAVAILABLE;
3816                     }
3817                 }
3818             } else {
3819                 TRACE_(d3d_caps)("[FAILED] - Cube texture format not supported\n");
3820                 return WINED3DERR_NOTAVAILABLE;
3821             }
3822         } else {
3823             TRACE_(d3d_caps)("[FAILED] - No cube texture support\n");
3824             return WINED3DERR_NOTAVAILABLE;
3825         }
3826     } else if(RType == WINED3DRTYPE_SURFACE) {
3827         /* Surface allows:
3828          *                - D3DUSAGE_DEPTHSTENCIL
3829          *                - D3DUSAGE_NONSECURE (d3d9ex)
3830          *                - D3DUSAGE_RENDERTARGET
3831          */
3832
3833         if (CheckSurfaceCapability(adapter, adapter_format_desc, DeviceType, format_desc, SurfaceType))
3834         {
3835             if(Usage & WINED3DUSAGE_DEPTHSTENCIL) {
3836                 if (CheckDepthStencilCapability(adapter, adapter_format_desc, format_desc))
3837                 {
3838                     UsageCaps |= WINED3DUSAGE_DEPTHSTENCIL;
3839                 } else {
3840                     TRACE_(d3d_caps)("[FAILED] - No depthstencil support\n");
3841                     return WINED3DERR_NOTAVAILABLE;
3842                 }
3843             }
3844
3845             if(Usage & WINED3DUSAGE_RENDERTARGET) {
3846                 if (CheckRenderTargetCapability(adapter, adapter_format_desc, format_desc))
3847                 {
3848                     UsageCaps |= WINED3DUSAGE_RENDERTARGET;
3849                 } else {
3850                     TRACE_(d3d_caps)("[FAILED] - No rendertarget support\n");
3851                     return WINED3DERR_NOTAVAILABLE;
3852                 }
3853             }
3854
3855             /* Check QUERY_POSTPIXELSHADER_BLENDING support */
3856             if(Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING) {
3857                 if (CheckPostPixelShaderBlendingCapability(adapter, format_desc))
3858                 {
3859                     UsageCaps |= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
3860                 } else {
3861                     TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
3862                     return WINED3DERR_NOTAVAILABLE;
3863                 }
3864             }
3865         } else {
3866             TRACE_(d3d_caps)("[FAILED] - Not supported for plain surfaces\n");
3867             return WINED3DERR_NOTAVAILABLE;
3868         }
3869
3870     } else if(RType == WINED3DRTYPE_TEXTURE) {
3871         /* Texture allows:
3872          *                - D3DUSAGE_AUTOGENMIPMAP
3873          *                - D3DUSAGE_DEPTHSTENCIL
3874          *                - D3DUSAGE_DMAP
3875          *                - D3DUSAGE_DYNAMIC
3876          *                - D3DUSAGE_NONSECURE (d3d9ex)
3877          *                - D3DUSAGE_RENDERTARGET
3878          *                - D3DUSAGE_SOFTWAREPROCESSING
3879          *                - D3DUSAGE_TEXTAPI (d3d9ex)
3880          *                - D3DUSAGE_QUERY_WRAPANDMIP
3881          */
3882
3883         if(SurfaceType != SURFACE_OPENGL) {
3884             TRACE("[FAILED]\n");
3885             return WINED3DERR_NOTAVAILABLE;
3886         }
3887
3888         /* Check if the texture format is around */
3889         if (CheckTextureCapability(adapter, DeviceType, format_desc))
3890         {
3891             if(Usage & WINED3DUSAGE_AUTOGENMIPMAP) {
3892                 /* Check for automatic mipmap generation support */
3893                 if (gl_info->supported[SGIS_GENERATE_MIPMAP])
3894                 {
3895                     UsageCaps |= WINED3DUSAGE_AUTOGENMIPMAP;
3896                 } else {
3897                     /* When autogenmipmap isn't around continue and return WINED3DOK_NOAUTOGEN instead of D3D_OK */
3898                     TRACE_(d3d_caps)("[FAILED] - No autogenmipmap support, but continuing\n");
3899                 }
3900             }
3901
3902             /* Always report dynamic locking */
3903             if(Usage & WINED3DUSAGE_DYNAMIC)
3904                 UsageCaps |= WINED3DUSAGE_DYNAMIC;
3905
3906             if(Usage & WINED3DUSAGE_RENDERTARGET) {
3907                 if (CheckRenderTargetCapability(adapter, adapter_format_desc, format_desc))
3908                 {
3909                     UsageCaps |= WINED3DUSAGE_RENDERTARGET;
3910                 } else {
3911                     TRACE_(d3d_caps)("[FAILED] - No rendertarget support\n");
3912                      return WINED3DERR_NOTAVAILABLE;
3913                  }
3914             }
3915
3916             /* Always report software processing */
3917             if(Usage & WINED3DUSAGE_SOFTWAREPROCESSING)
3918                 UsageCaps |= WINED3DUSAGE_SOFTWAREPROCESSING;
3919
3920             /* Check QUERY_FILTER support */
3921             if(Usage & WINED3DUSAGE_QUERY_FILTER) {
3922                 if (CheckFilterCapability(adapter, format_desc))
3923                 {
3924                     UsageCaps |= WINED3DUSAGE_QUERY_FILTER;
3925                 } else {
3926                     TRACE_(d3d_caps)("[FAILED] - No query filter support\n");
3927                     return WINED3DERR_NOTAVAILABLE;
3928                 }
3929             }
3930
3931             /* Check QUERY_LEGACYBUMPMAP support */
3932             if(Usage & WINED3DUSAGE_QUERY_LEGACYBUMPMAP) {
3933                 if (CheckBumpMapCapability(adapter, DeviceType, format_desc))
3934                 {
3935                     UsageCaps |= WINED3DUSAGE_QUERY_LEGACYBUMPMAP;
3936                 } else {
3937                     TRACE_(d3d_caps)("[FAILED] - No legacy bumpmap support\n");
3938                     return WINED3DERR_NOTAVAILABLE;
3939                 }
3940             }
3941
3942             /* Check QUERY_POSTPIXELSHADER_BLENDING support */
3943             if(Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING) {
3944                 if (CheckPostPixelShaderBlendingCapability(adapter, format_desc))
3945                 {
3946                     UsageCaps |= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
3947                 } else {
3948                     TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
3949                     return WINED3DERR_NOTAVAILABLE;
3950                 }
3951             }
3952
3953             /* Check QUERY_SRGBREAD support */
3954             if(Usage & WINED3DUSAGE_QUERY_SRGBREAD) {
3955                 if (CheckSrgbReadCapability(adapter, format_desc))
3956                 {
3957                     UsageCaps |= WINED3DUSAGE_QUERY_SRGBREAD;
3958                 } else {
3959                     TRACE_(d3d_caps)("[FAILED] - No query srgbread support\n");
3960                     return WINED3DERR_NOTAVAILABLE;
3961                 }
3962             }
3963
3964             /* Check QUERY_SRGBWRITE support */
3965             if(Usage & WINED3DUSAGE_QUERY_SRGBWRITE) {
3966                 if (CheckSrgbWriteCapability(adapter, DeviceType, format_desc))
3967                 {
3968                     UsageCaps |= WINED3DUSAGE_QUERY_SRGBWRITE;
3969                 } else {
3970                     TRACE_(d3d_caps)("[FAILED] - No query srgbwrite support\n");
3971                     return WINED3DERR_NOTAVAILABLE;
3972                 }
3973             }
3974
3975             /* Check QUERY_VERTEXTEXTURE support */
3976             if(Usage & WINED3DUSAGE_QUERY_VERTEXTEXTURE) {
3977                 if (CheckVertexTextureCapability(adapter, format_desc))
3978                 {
3979                     UsageCaps |= WINED3DUSAGE_QUERY_VERTEXTEXTURE;
3980                 } else {
3981                     TRACE_(d3d_caps)("[FAILED] - No query vertextexture support\n");
3982                     return WINED3DERR_NOTAVAILABLE;
3983                 }
3984             }
3985
3986             /* Check QUERY_WRAPANDMIP support */
3987             if(Usage & WINED3DUSAGE_QUERY_WRAPANDMIP) {
3988                 if (CheckWrapAndMipCapability(adapter, format_desc))
3989                 {
3990                     UsageCaps |= WINED3DUSAGE_QUERY_WRAPANDMIP;
3991                 } else {
3992                     TRACE_(d3d_caps)("[FAILED] - No wrapping and mipmapping support\n");
3993                     return WINED3DERR_NOTAVAILABLE;
3994                 }
3995             }
3996
3997             if(Usage & WINED3DUSAGE_DEPTHSTENCIL) {
3998                 if (CheckDepthStencilCapability(adapter, adapter_format_desc, format_desc))
3999                 {
4000                     UsageCaps |= WINED3DUSAGE_DEPTHSTENCIL;
4001                 } else {
4002                     TRACE_(d3d_caps)("[FAILED] - No depth stencil support\n");
4003                     return WINED3DERR_NOTAVAILABLE;
4004                 }
4005             }
4006         } else {
4007             TRACE_(d3d_caps)("[FAILED] - Texture format not supported\n");
4008             return WINED3DERR_NOTAVAILABLE;
4009         }
4010     } else if((RType == WINED3DRTYPE_VOLUME) || (RType == WINED3DRTYPE_VOLUMETEXTURE)) {
4011         /* Volume is to VolumeTexture what Surface is to Texture but its usage caps are not documented.
4012          * Most driver seem to offer (nearly) the same on Volume and VolumeTexture, so do that too.
4013          *
4014          * Volumetexture allows:
4015          *                      - D3DUSAGE_DYNAMIC
4016          *                      - D3DUSAGE_NONSECURE (d3d9ex)
4017          *                      - D3DUSAGE_SOFTWAREPROCESSING
4018          *                      - D3DUSAGE_QUERY_WRAPANDMIP
4019          */
4020
4021         if(SurfaceType != SURFACE_OPENGL) {
4022             TRACE("[FAILED]\n");
4023             return WINED3DERR_NOTAVAILABLE;
4024         }
4025
4026         /* Check volume texture and volume usage caps */
4027         if (gl_info->supported[EXT_TEXTURE3D])
4028         {
4029             if (!CheckTextureCapability(adapter, DeviceType, format_desc))
4030             {
4031                 TRACE_(d3d_caps)("[FAILED] - Format not supported\n");
4032                 return WINED3DERR_NOTAVAILABLE;
4033             }
4034
4035             /* Always report dynamic locking */
4036             if(Usage & WINED3DUSAGE_DYNAMIC)
4037                 UsageCaps |= WINED3DUSAGE_DYNAMIC;
4038
4039             /* Always report software processing */
4040             if(Usage & WINED3DUSAGE_SOFTWAREPROCESSING)
4041                 UsageCaps |= WINED3DUSAGE_SOFTWAREPROCESSING;
4042
4043             /* Check QUERY_FILTER support */
4044             if(Usage & WINED3DUSAGE_QUERY_FILTER) {
4045                 if (CheckFilterCapability(adapter, format_desc))
4046                 {
4047                     UsageCaps |= WINED3DUSAGE_QUERY_FILTER;
4048                 } else {
4049                     TRACE_(d3d_caps)("[FAILED] - No query filter support\n");
4050                     return WINED3DERR_NOTAVAILABLE;
4051                 }
4052             }
4053
4054             /* Check QUERY_POSTPIXELSHADER_BLENDING support */
4055             if(Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING) {
4056                 if (CheckPostPixelShaderBlendingCapability(adapter, format_desc))
4057                 {
4058                     UsageCaps |= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
4059                 } else {
4060                     TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
4061                     return WINED3DERR_NOTAVAILABLE;
4062                 }
4063             }
4064
4065             /* Check QUERY_SRGBREAD support */
4066             if(Usage & WINED3DUSAGE_QUERY_SRGBREAD) {
4067                 if (CheckSrgbReadCapability(adapter, format_desc))
4068                 {
4069                     UsageCaps |= WINED3DUSAGE_QUERY_SRGBREAD;
4070                 } else {
4071                     TRACE_(d3d_caps)("[FAILED] - No query srgbread support\n");
4072                     return WINED3DERR_NOTAVAILABLE;
4073                 }
4074             }
4075
4076             /* Check QUERY_SRGBWRITE support */
4077             if(Usage & WINED3DUSAGE_QUERY_SRGBWRITE) {
4078                 if (CheckSrgbWriteCapability(adapter, DeviceType, format_desc))
4079                 {
4080                     UsageCaps |= WINED3DUSAGE_QUERY_SRGBWRITE;
4081                 } else {
4082                     TRACE_(d3d_caps)("[FAILED] - No query srgbwrite support\n");
4083                     return WINED3DERR_NOTAVAILABLE;
4084                 }
4085             }
4086
4087             /* Check QUERY_VERTEXTEXTURE support */
4088             if(Usage & WINED3DUSAGE_QUERY_VERTEXTEXTURE) {
4089                 if (CheckVertexTextureCapability(adapter, format_desc))
4090                 {
4091                     UsageCaps |= WINED3DUSAGE_QUERY_VERTEXTEXTURE;
4092                 } else {
4093                     TRACE_(d3d_caps)("[FAILED] - No query vertextexture support\n");
4094                     return WINED3DERR_NOTAVAILABLE;
4095                 }
4096             }
4097
4098             /* Check QUERY_WRAPANDMIP support */
4099             if(Usage & WINED3DUSAGE_QUERY_WRAPANDMIP) {
4100                 if (CheckWrapAndMipCapability(adapter, format_desc))
4101                 {
4102                     UsageCaps |= WINED3DUSAGE_QUERY_WRAPANDMIP;
4103                 } else {
4104                     TRACE_(d3d_caps)("[FAILED] - No wrapping and mipmapping support\n");
4105                     return WINED3DERR_NOTAVAILABLE;
4106                 }
4107             }
4108         } else {
4109             TRACE_(d3d_caps)("[FAILED] - No volume texture support\n");
4110             return WINED3DERR_NOTAVAILABLE;
4111         }
4112
4113         /* Filter formats that need conversion; For one part, this conversion is unimplemented,
4114          * and volume textures are huge, so it would be a big performance hit. Unless we hit an
4115          * app needing one of those formats, don't advertize them to avoid leading apps into
4116          * temptation. The windows drivers don't support most of those formats on volumes anyway,
4117          * except of R32F.
4118          */
4119         switch(CheckFormat) {
4120             case WINED3DFMT_P8_UINT:
4121             case WINED3DFMT_L4A4_UNORM:
4122             case WINED3DFMT_R32_FLOAT:
4123             case WINED3DFMT_R16_FLOAT:
4124             case WINED3DFMT_R8G8_SNORM_L8X8_UNORM:
4125             case WINED3DFMT_R5G5_SNORM_L6_UNORM:
4126             case WINED3DFMT_R16G16_UNORM:
4127                 TRACE_(d3d_caps)("[FAILED] - No converted formats on volumes\n");
4128                 return WINED3DERR_NOTAVAILABLE;
4129
4130             case WINED3DFMT_R8G8B8A8_SNORM:
4131             case WINED3DFMT_R16G16_SNORM:
4132             if (!gl_info->supported[NV_TEXTURE_SHADER])
4133             {
4134                 TRACE_(d3d_caps)("[FAILED] - No converted formats on volumes\n");
4135                 return WINED3DERR_NOTAVAILABLE;
4136             }
4137             break;
4138
4139             case WINED3DFMT_R8G8_SNORM:
4140             if (!gl_info->supported[NV_TEXTURE_SHADER])
4141             {
4142                 TRACE_(d3d_caps)("[FAILED] - No converted formats on volumes\n");
4143                 return WINED3DERR_NOTAVAILABLE;
4144             }
4145             break;
4146
4147             case WINED3DFMT_DXT1:
4148             case WINED3DFMT_DXT2:
4149             case WINED3DFMT_DXT3:
4150             case WINED3DFMT_DXT4:
4151             case WINED3DFMT_DXT5:
4152                 /* The GL_EXT_texture_compression_s3tc spec requires that loading an s3tc
4153                  * compressed texture results in an error. While the D3D refrast does
4154                  * support s3tc volumes, at least the nvidia windows driver does not, so
4155                  * we're free not to support this format.
4156                  */
4157                 TRACE_(d3d_caps)("[FAILED] - DXTn does not support 3D textures\n");
4158                 return WINED3DERR_NOTAVAILABLE;
4159
4160             default:
4161                 /* Do nothing, continue with checking the format below */
4162                 break;
4163         }
4164     } else if(RType == WINED3DRTYPE_BUFFER){
4165         /* For instance vertexbuffer/indexbuffer aren't supported yet because no Windows drivers seem to offer it */
4166         TRACE_(d3d_caps)("Unhandled resource type D3DRTYPE_INDEXBUFFER / D3DRTYPE_VERTEXBUFFER\n");
4167         return WINED3DERR_NOTAVAILABLE;
4168     }
4169
4170     /* When the UsageCaps exactly matches Usage return WINED3D_OK except for the situation in which
4171      * WINED3DUSAGE_AUTOGENMIPMAP isn't around, then WINED3DOK_NOAUTOGEN is returned if all the other
4172      * usage flags match. */
4173     if(UsageCaps == Usage) {
4174         return WINED3D_OK;
4175     } else if((UsageCaps == (Usage & ~WINED3DUSAGE_AUTOGENMIPMAP)) && (Usage & WINED3DUSAGE_AUTOGENMIPMAP)){
4176         return WINED3DOK_NOAUTOGEN;
4177     } else {
4178         TRACE_(d3d_caps)("[FAILED] - Usage=%#08x requested for CheckFormat=%s and RType=%d but only %#08x is available\n", Usage, debug_d3dformat(CheckFormat), RType, UsageCaps);
4179         return WINED3DERR_NOTAVAILABLE;
4180     }
4181 }
4182
4183 static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormatConversion(IWineD3D *iface, UINT adapter_idx,
4184         WINED3DDEVTYPE device_type, WINED3DFORMAT src_format, WINED3DFORMAT dst_format)
4185 {
4186     FIXME("iface %p, adapter_idx %u, device_type %s, src_format %s, dst_format %s stub!\n",
4187             iface, adapter_idx, debug_d3ddevicetype(device_type), debug_d3dformat(src_format),
4188             debug_d3dformat(dst_format));
4189
4190     return WINED3D_OK;
4191 }
4192
4193 /* Note: d3d8 passes in a pointer to a D3DCAPS8 structure, which is a true
4194       subset of a D3DCAPS9 structure. However, it has to come via a void *
4195       as the d3d8 interface cannot import the d3d9 header                  */
4196 static HRESULT WINAPI IWineD3DImpl_GetDeviceCaps(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType, WINED3DCAPS* pCaps) {
4197
4198     IWineD3DImpl    *This = (IWineD3DImpl *)iface;
4199     struct wined3d_adapter *adapter = &This->adapters[Adapter];
4200     const struct wined3d_gl_info *gl_info = &adapter->gl_info;
4201     int vs_selected_mode;
4202     int ps_selected_mode;
4203     struct shader_caps shader_caps;
4204     struct fragment_caps fragment_caps;
4205     DWORD ckey_caps, blit_caps, fx_caps;
4206
4207     TRACE_(d3d_caps)("(%p)->(Adptr:%d, DevType: %x, pCaps: %p)\n", This, Adapter, DeviceType, pCaps);
4208
4209     if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
4210         return WINED3DERR_INVALIDCALL;
4211     }
4212
4213     select_shader_mode(&adapter->gl_info, &ps_selected_mode, &vs_selected_mode);
4214
4215     /* ------------------------------------------------
4216        The following fields apply to both d3d8 and d3d9
4217        ------------------------------------------------ */
4218     pCaps->DeviceType              = (DeviceType == WINED3DDEVTYPE_HAL) ? WINED3DDEVTYPE_HAL : WINED3DDEVTYPE_REF;  /* Not quite true, but use h/w supported by opengl I suppose */
4219     pCaps->AdapterOrdinal          = Adapter;
4220
4221     pCaps->Caps                    = 0;
4222     pCaps->Caps2                   = WINED3DCAPS2_CANRENDERWINDOWED |
4223                                      WINED3DCAPS2_FULLSCREENGAMMA |
4224                                      WINED3DCAPS2_DYNAMICTEXTURES;
4225     if (gl_info->supported[SGIS_GENERATE_MIPMAP])
4226     {
4227         pCaps->Caps2 |= WINED3DCAPS2_CANAUTOGENMIPMAP;
4228     }
4229
4230     pCaps->Caps3                   = WINED3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD |
4231                                      WINED3DCAPS3_COPY_TO_VIDMEM                   |
4232                                      WINED3DCAPS3_COPY_TO_SYSTEMMEM;
4233
4234     pCaps->PresentationIntervals   = WINED3DPRESENT_INTERVAL_IMMEDIATE  |
4235                                      WINED3DPRESENT_INTERVAL_ONE;
4236
4237     pCaps->CursorCaps              = WINED3DCURSORCAPS_COLOR            |
4238                                      WINED3DCURSORCAPS_LOWRES;
4239
4240     pCaps->DevCaps                 = WINED3DDEVCAPS_FLOATTLVERTEX       |
4241                                      WINED3DDEVCAPS_EXECUTESYSTEMMEMORY |
4242                                      WINED3DDEVCAPS_TLVERTEXSYSTEMMEMORY|
4243                                      WINED3DDEVCAPS_TLVERTEXVIDEOMEMORY |
4244                                      WINED3DDEVCAPS_DRAWPRIMTLVERTEX    |
4245                                      WINED3DDEVCAPS_HWTRANSFORMANDLIGHT |
4246                                      WINED3DDEVCAPS_EXECUTEVIDEOMEMORY  |
4247                                      WINED3DDEVCAPS_PUREDEVICE          |
4248                                      WINED3DDEVCAPS_HWRASTERIZATION     |
4249                                      WINED3DDEVCAPS_TEXTUREVIDEOMEMORY  |
4250                                      WINED3DDEVCAPS_TEXTURESYSTEMMEMORY |
4251                                      WINED3DDEVCAPS_CANRENDERAFTERFLIP  |
4252                                      WINED3DDEVCAPS_DRAWPRIMITIVES2     |
4253                                      WINED3DDEVCAPS_DRAWPRIMITIVES2EX   |
4254                                      WINED3DDEVCAPS_RTPATCHES;
4255
4256     pCaps->PrimitiveMiscCaps       = WINED3DPMISCCAPS_CULLNONE              |
4257                                      WINED3DPMISCCAPS_CULLCCW               |
4258                                      WINED3DPMISCCAPS_CULLCW                |
4259                                      WINED3DPMISCCAPS_COLORWRITEENABLE      |
4260                                      WINED3DPMISCCAPS_CLIPTLVERTS           |
4261                                      WINED3DPMISCCAPS_CLIPPLANESCALEDPOINTS |
4262                                      WINED3DPMISCCAPS_MASKZ                 |
4263                                      WINED3DPMISCCAPS_BLENDOP               |
4264                                      WINED3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING;
4265                                     /* TODO:
4266                                         WINED3DPMISCCAPS_NULLREFERENCE
4267                                         WINED3DPMISCCAPS_FOGANDSPECULARALPHA
4268                                         WINED3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS
4269                                         WINED3DPMISCCAPS_FOGVERTEXCLAMPED */
4270
4271     if (gl_info->supported[EXT_BLEND_EQUATION_SEPARATE] && gl_info->supported[EXT_BLEND_FUNC_SEPARATE])
4272         pCaps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_SEPARATEALPHABLEND;
4273     if (gl_info->supported[EXT_DRAW_BUFFERS2])
4274         pCaps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_INDEPENDENTWRITEMASKS;
4275
4276     pCaps->RasterCaps              = WINED3DPRASTERCAPS_DITHER    |
4277                                      WINED3DPRASTERCAPS_PAT       |
4278                                      WINED3DPRASTERCAPS_WFOG      |
4279                                      WINED3DPRASTERCAPS_ZFOG      |
4280                                      WINED3DPRASTERCAPS_FOGVERTEX |
4281                                      WINED3DPRASTERCAPS_FOGTABLE  |
4282                                      WINED3DPRASTERCAPS_STIPPLE   |
4283                                      WINED3DPRASTERCAPS_SUBPIXEL  |
4284                                      WINED3DPRASTERCAPS_ZTEST     |
4285                                      WINED3DPRASTERCAPS_SCISSORTEST   |
4286                                      WINED3DPRASTERCAPS_SLOPESCALEDEPTHBIAS |
4287                                      WINED3DPRASTERCAPS_DEPTHBIAS;
4288
4289     if (gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC])
4290     {
4291         pCaps->RasterCaps |= WINED3DPRASTERCAPS_ANISOTROPY    |
4292                              WINED3DPRASTERCAPS_ZBIAS         |
4293                              WINED3DPRASTERCAPS_MIPMAPLODBIAS;
4294     }
4295     if (gl_info->supported[NV_FOG_DISTANCE])
4296     {
4297         pCaps->RasterCaps         |= WINED3DPRASTERCAPS_FOGRANGE;
4298     }
4299                         /* FIXME Add:
4300                            WINED3DPRASTERCAPS_COLORPERSPECTIVE
4301                            WINED3DPRASTERCAPS_STRETCHBLTMULTISAMPLE
4302                            WINED3DPRASTERCAPS_ANTIALIASEDGES
4303                            WINED3DPRASTERCAPS_ZBUFFERLESSHSR
4304                            WINED3DPRASTERCAPS_WBUFFER */
4305
4306     pCaps->ZCmpCaps = WINED3DPCMPCAPS_ALWAYS       |
4307                       WINED3DPCMPCAPS_EQUAL        |
4308                       WINED3DPCMPCAPS_GREATER      |
4309                       WINED3DPCMPCAPS_GREATEREQUAL |
4310                       WINED3DPCMPCAPS_LESS         |
4311                       WINED3DPCMPCAPS_LESSEQUAL    |
4312                       WINED3DPCMPCAPS_NEVER        |
4313                       WINED3DPCMPCAPS_NOTEQUAL;
4314
4315     pCaps->SrcBlendCaps  = WINED3DPBLENDCAPS_BOTHINVSRCALPHA |
4316                            WINED3DPBLENDCAPS_BOTHSRCALPHA    |
4317                            WINED3DPBLENDCAPS_DESTALPHA       |
4318                            WINED3DPBLENDCAPS_DESTCOLOR       |
4319                            WINED3DPBLENDCAPS_INVDESTALPHA    |
4320                            WINED3DPBLENDCAPS_INVDESTCOLOR    |
4321                            WINED3DPBLENDCAPS_INVSRCALPHA     |
4322                            WINED3DPBLENDCAPS_INVSRCCOLOR     |
4323                            WINED3DPBLENDCAPS_ONE             |
4324                            WINED3DPBLENDCAPS_SRCALPHA        |
4325                            WINED3DPBLENDCAPS_SRCALPHASAT     |
4326                            WINED3DPBLENDCAPS_SRCCOLOR        |
4327                            WINED3DPBLENDCAPS_ZERO;
4328
4329     pCaps->DestBlendCaps = WINED3DPBLENDCAPS_DESTALPHA       |
4330                            WINED3DPBLENDCAPS_DESTCOLOR       |
4331                            WINED3DPBLENDCAPS_INVDESTALPHA    |
4332                            WINED3DPBLENDCAPS_INVDESTCOLOR    |
4333                            WINED3DPBLENDCAPS_INVSRCALPHA     |
4334                            WINED3DPBLENDCAPS_INVSRCCOLOR     |
4335                            WINED3DPBLENDCAPS_ONE             |
4336                            WINED3DPBLENDCAPS_SRCALPHA        |
4337                            WINED3DPBLENDCAPS_SRCCOLOR        |
4338                            WINED3DPBLENDCAPS_ZERO;
4339     /* NOTE: WINED3DPBLENDCAPS_SRCALPHASAT is not supported as dest blend factor,
4340      * according to the glBlendFunc manpage
4341      *
4342      * WINED3DPBLENDCAPS_BOTHINVSRCALPHA and WINED3DPBLENDCAPS_BOTHSRCALPHA are
4343      * legacy settings for srcblend only
4344      */
4345
4346     if (gl_info->supported[EXT_BLEND_COLOR])
4347     {
4348         pCaps->SrcBlendCaps |= WINED3DPBLENDCAPS_BLENDFACTOR;
4349         pCaps->DestBlendCaps |= WINED3DPBLENDCAPS_BLENDFACTOR;
4350     }
4351
4352
4353     pCaps->AlphaCmpCaps = WINED3DPCMPCAPS_ALWAYS       |
4354                           WINED3DPCMPCAPS_EQUAL        |
4355                           WINED3DPCMPCAPS_GREATER      |
4356                           WINED3DPCMPCAPS_GREATEREQUAL |
4357                           WINED3DPCMPCAPS_LESS         |
4358                           WINED3DPCMPCAPS_LESSEQUAL    |
4359                           WINED3DPCMPCAPS_NEVER        |
4360                           WINED3DPCMPCAPS_NOTEQUAL;
4361
4362     pCaps->ShadeCaps     = WINED3DPSHADECAPS_SPECULARGOURAUDRGB |
4363                            WINED3DPSHADECAPS_COLORGOURAUDRGB    |
4364                            WINED3DPSHADECAPS_ALPHAFLATBLEND     |
4365                            WINED3DPSHADECAPS_ALPHAGOURAUDBLEND  |
4366                            WINED3DPSHADECAPS_COLORFLATRGB       |
4367                            WINED3DPSHADECAPS_FOGFLAT            |
4368                            WINED3DPSHADECAPS_FOGGOURAUD         |
4369                            WINED3DPSHADECAPS_SPECULARFLATRGB;
4370
4371     pCaps->TextureCaps =  WINED3DPTEXTURECAPS_ALPHA              |
4372                           WINED3DPTEXTURECAPS_ALPHAPALETTE       |
4373                           WINED3DPTEXTURECAPS_TRANSPARENCY       |
4374                           WINED3DPTEXTURECAPS_BORDER             |
4375                           WINED3DPTEXTURECAPS_MIPMAP             |
4376                           WINED3DPTEXTURECAPS_PROJECTED          |
4377                           WINED3DPTEXTURECAPS_PERSPECTIVE;
4378
4379     if (!gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO])
4380     {
4381         pCaps->TextureCaps |= WINED3DPTEXTURECAPS_POW2 |
4382                               WINED3DPTEXTURECAPS_NONPOW2CONDITIONAL;
4383     }
4384
4385     if (gl_info->supported[EXT_TEXTURE3D])
4386     {
4387         pCaps->TextureCaps |=  WINED3DPTEXTURECAPS_VOLUMEMAP      |
4388                                WINED3DPTEXTURECAPS_MIPVOLUMEMAP   |
4389                                WINED3DPTEXTURECAPS_VOLUMEMAP_POW2;
4390     }
4391
4392     if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
4393     {
4394         pCaps->TextureCaps |= WINED3DPTEXTURECAPS_CUBEMAP     |
4395                               WINED3DPTEXTURECAPS_MIPCUBEMAP    |
4396                               WINED3DPTEXTURECAPS_CUBEMAP_POW2;
4397
4398     }
4399
4400     pCaps->TextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR       |
4401                                WINED3DPTFILTERCAPS_MAGFPOINT        |
4402                                WINED3DPTFILTERCAPS_MINFLINEAR       |
4403                                WINED3DPTFILTERCAPS_MINFPOINT        |
4404                                WINED3DPTFILTERCAPS_MIPFLINEAR       |
4405                                WINED3DPTFILTERCAPS_MIPFPOINT        |
4406                                WINED3DPTFILTERCAPS_LINEAR           |
4407                                WINED3DPTFILTERCAPS_LINEARMIPLINEAR  |
4408                                WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
4409                                WINED3DPTFILTERCAPS_MIPLINEAR        |
4410                                WINED3DPTFILTERCAPS_MIPNEAREST       |
4411                                WINED3DPTFILTERCAPS_NEAREST;
4412
4413     if (gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC])
4414     {
4415         pCaps->TextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC |
4416                                     WINED3DPTFILTERCAPS_MINFANISOTROPIC;
4417     }
4418
4419     if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
4420     {
4421         pCaps->CubeTextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR       |
4422                                        WINED3DPTFILTERCAPS_MAGFPOINT        |
4423                                        WINED3DPTFILTERCAPS_MINFLINEAR       |
4424                                        WINED3DPTFILTERCAPS_MINFPOINT        |
4425                                        WINED3DPTFILTERCAPS_MIPFLINEAR       |
4426                                        WINED3DPTFILTERCAPS_MIPFPOINT        |
4427                                        WINED3DPTFILTERCAPS_LINEAR           |
4428                                        WINED3DPTFILTERCAPS_LINEARMIPLINEAR  |
4429                                        WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
4430                                        WINED3DPTFILTERCAPS_MIPLINEAR        |
4431                                        WINED3DPTFILTERCAPS_MIPNEAREST       |
4432                                        WINED3DPTFILTERCAPS_NEAREST;
4433
4434         if (gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC])
4435         {
4436             pCaps->CubeTextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC |
4437                                             WINED3DPTFILTERCAPS_MINFANISOTROPIC;
4438         }
4439     } else
4440         pCaps->CubeTextureFilterCaps = 0;
4441
4442     if (gl_info->supported[EXT_TEXTURE3D])
4443     {
4444         pCaps->VolumeTextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR       |
4445                                          WINED3DPTFILTERCAPS_MAGFPOINT        |
4446                                          WINED3DPTFILTERCAPS_MINFLINEAR       |
4447                                          WINED3DPTFILTERCAPS_MINFPOINT        |
4448                                          WINED3DPTFILTERCAPS_MIPFLINEAR       |
4449                                          WINED3DPTFILTERCAPS_MIPFPOINT        |
4450                                          WINED3DPTFILTERCAPS_LINEAR           |
4451                                          WINED3DPTFILTERCAPS_LINEARMIPLINEAR  |
4452                                          WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
4453                                          WINED3DPTFILTERCAPS_MIPLINEAR        |
4454                                          WINED3DPTFILTERCAPS_MIPNEAREST       |
4455                                          WINED3DPTFILTERCAPS_NEAREST;
4456     } else
4457         pCaps->VolumeTextureFilterCaps = 0;
4458
4459     pCaps->TextureAddressCaps =  WINED3DPTADDRESSCAPS_INDEPENDENTUV |
4460                                  WINED3DPTADDRESSCAPS_CLAMP  |
4461                                  WINED3DPTADDRESSCAPS_WRAP;
4462
4463     if (gl_info->supported[ARB_TEXTURE_BORDER_CLAMP])
4464     {
4465         pCaps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_BORDER;
4466     }
4467     if (gl_info->supported[ARB_TEXTURE_MIRRORED_REPEAT])
4468     {
4469         pCaps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRROR;
4470     }
4471     if (gl_info->supported[ATI_TEXTURE_MIRROR_ONCE])
4472     {
4473         pCaps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRRORONCE;
4474     }
4475
4476     if (gl_info->supported[EXT_TEXTURE3D])
4477     {
4478         pCaps->VolumeTextureAddressCaps =  WINED3DPTADDRESSCAPS_INDEPENDENTUV |
4479                                            WINED3DPTADDRESSCAPS_CLAMP  |
4480                                            WINED3DPTADDRESSCAPS_WRAP;
4481         if (gl_info->supported[ARB_TEXTURE_BORDER_CLAMP])
4482         {
4483             pCaps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_BORDER;
4484         }
4485         if (gl_info->supported[ARB_TEXTURE_MIRRORED_REPEAT])
4486         {
4487             pCaps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRROR;
4488         }
4489         if (gl_info->supported[ATI_TEXTURE_MIRROR_ONCE])
4490         {
4491             pCaps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRRORONCE;
4492         }
4493     } else
4494         pCaps->VolumeTextureAddressCaps = 0;
4495
4496     pCaps->LineCaps = WINED3DLINECAPS_TEXTURE       |
4497                       WINED3DLINECAPS_ZTEST         |
4498                       WINED3DLINECAPS_BLEND         |
4499                       WINED3DLINECAPS_ALPHACMP      |
4500                       WINED3DLINECAPS_FOG;
4501     /* WINED3DLINECAPS_ANTIALIAS is not supported on Windows, and dx and gl seem to have a different
4502      * idea how generating the smoothing alpha values works; the result is different
4503      */
4504
4505     pCaps->MaxTextureWidth = gl_info->limits.texture_size;
4506     pCaps->MaxTextureHeight = gl_info->limits.texture_size;
4507
4508     if (gl_info->supported[EXT_TEXTURE3D])
4509         pCaps->MaxVolumeExtent = gl_info->limits.texture3d_size;
4510     else
4511         pCaps->MaxVolumeExtent = 0;
4512
4513     pCaps->MaxTextureRepeat = 32768;
4514     pCaps->MaxTextureAspectRatio = gl_info->limits.texture_size;
4515     pCaps->MaxVertexW = 1.0f;
4516
4517     pCaps->GuardBandLeft = 0.0f;
4518     pCaps->GuardBandTop = 0.0f;
4519     pCaps->GuardBandRight = 0.0f;
4520     pCaps->GuardBandBottom = 0.0f;
4521
4522     pCaps->ExtentsAdjust = 0.0f;
4523
4524     pCaps->StencilCaps =  WINED3DSTENCILCAPS_DECRSAT |
4525                           WINED3DSTENCILCAPS_INCRSAT |
4526                           WINED3DSTENCILCAPS_INVERT  |
4527                           WINED3DSTENCILCAPS_KEEP    |
4528                           WINED3DSTENCILCAPS_REPLACE |
4529                           WINED3DSTENCILCAPS_ZERO;
4530     if (gl_info->supported[EXT_STENCIL_WRAP])
4531     {
4532         pCaps->StencilCaps |= WINED3DSTENCILCAPS_DECR  |
4533                               WINED3DSTENCILCAPS_INCR;
4534     }
4535     if (gl_info->supported[EXT_STENCIL_TWO_SIDE] || gl_info->supported[ATI_SEPARATE_STENCIL])
4536     {
4537         pCaps->StencilCaps |= WINED3DSTENCILCAPS_TWOSIDED;
4538     }
4539
4540     pCaps->FVFCaps = WINED3DFVFCAPS_PSIZE | 0x0008; /* 8 texture coords */
4541
4542     pCaps->MaxUserClipPlanes = gl_info->limits.clipplanes;
4543     pCaps->MaxActiveLights = gl_info->limits.lights;
4544
4545     pCaps->MaxVertexBlendMatrices = gl_info->limits.blends;
4546     pCaps->MaxVertexBlendMatrixIndex   = 0;
4547
4548     pCaps->MaxAnisotropy = gl_info->limits.anisotropy;
4549     pCaps->MaxPointSize = gl_info->limits.pointsize_max;
4550
4551
4552     /* FIXME: Add D3DVTXPCAPS_TWEENING, D3DVTXPCAPS_TEXGEN_SPHEREMAP */
4553     pCaps->VertexProcessingCaps = WINED3DVTXPCAPS_DIRECTIONALLIGHTS |
4554                                   WINED3DVTXPCAPS_MATERIALSOURCE7   |
4555                                   WINED3DVTXPCAPS_POSITIONALLIGHTS  |
4556                                   WINED3DVTXPCAPS_LOCALVIEWER       |
4557                                   WINED3DVTXPCAPS_VERTEXFOG         |
4558                                   WINED3DVTXPCAPS_TEXGEN;
4559
4560     pCaps->MaxPrimitiveCount   = 0xFFFFF; /* For now set 2^20-1 which is used by most >=Geforce3/Radeon8500 cards */
4561     pCaps->MaxVertexIndex      = 0xFFFFF;
4562     pCaps->MaxStreams          = MAX_STREAMS;
4563     pCaps->MaxStreamStride     = 1024;
4564
4565     /* d3d9.dll sets D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES here because StretchRects is implemented in d3d9 */
4566     pCaps->DevCaps2                          = WINED3DDEVCAPS2_STREAMOFFSET |
4567                                                WINED3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET;
4568     pCaps->MaxNpatchTessellationLevel        = 0;
4569     pCaps->MasterAdapterOrdinal              = 0;
4570     pCaps->AdapterOrdinalInGroup             = 0;
4571     pCaps->NumberOfAdaptersInGroup           = 1;
4572
4573     pCaps->NumSimultaneousRTs = gl_info->limits.buffers;
4574
4575     pCaps->StretchRectFilterCaps             = WINED3DPTFILTERCAPS_MINFPOINT  |
4576                                                 WINED3DPTFILTERCAPS_MAGFPOINT  |
4577                                                 WINED3DPTFILTERCAPS_MINFLINEAR |
4578                                                 WINED3DPTFILTERCAPS_MAGFLINEAR;
4579     pCaps->VertexTextureFilterCaps           = 0;
4580
4581     memset(&shader_caps, 0, sizeof(shader_caps));
4582     adapter->shader_backend->shader_get_caps(&adapter->gl_info, &shader_caps);
4583
4584     memset(&fragment_caps, 0, sizeof(fragment_caps));
4585     adapter->fragment_pipe->get_caps(&adapter->gl_info, &fragment_caps);
4586
4587     /* Add shader misc caps. Only some of them belong to the shader parts of the pipeline */
4588     pCaps->PrimitiveMiscCaps |= fragment_caps.PrimitiveMiscCaps;
4589
4590     /* This takes care for disabling vertex shader or pixel shader caps while leaving the other one enabled.
4591      * Ignore shader model capabilities if disabled in config
4592      */
4593     if(vs_selected_mode == SHADER_NONE) {
4594         TRACE_(d3d_caps)("Vertex shader disabled in config, reporting version 0.0\n");
4595         pCaps->VertexShaderVersion          = WINED3DVS_VERSION(0,0);
4596         pCaps->MaxVertexShaderConst         = 0;
4597     } else {
4598         pCaps->VertexShaderVersion          = shader_caps.VertexShaderVersion;
4599         pCaps->MaxVertexShaderConst         = shader_caps.MaxVertexShaderConst;
4600     }
4601
4602     if(ps_selected_mode == SHADER_NONE) {
4603         TRACE_(d3d_caps)("Pixel shader disabled in config, reporting version 0.0\n");
4604         pCaps->PixelShaderVersion           = WINED3DPS_VERSION(0,0);
4605         pCaps->PixelShader1xMaxValue        = 0.0f;
4606     } else {
4607         pCaps->PixelShaderVersion           = shader_caps.PixelShaderVersion;
4608         pCaps->PixelShader1xMaxValue        = shader_caps.PixelShader1xMaxValue;
4609     }
4610
4611     pCaps->TextureOpCaps                    = fragment_caps.TextureOpCaps;
4612     pCaps->MaxTextureBlendStages            = fragment_caps.MaxTextureBlendStages;
4613     pCaps->MaxSimultaneousTextures          = fragment_caps.MaxSimultaneousTextures;
4614
4615     pCaps->VS20Caps                         = shader_caps.VS20Caps;
4616     pCaps->MaxVShaderInstructionsExecuted   = shader_caps.MaxVShaderInstructionsExecuted;
4617     pCaps->MaxVertexShader30InstructionSlots= shader_caps.MaxVertexShader30InstructionSlots;
4618     pCaps->PS20Caps                         = shader_caps.PS20Caps;
4619     pCaps->MaxPShaderInstructionsExecuted   = shader_caps.MaxPShaderInstructionsExecuted;
4620     pCaps->MaxPixelShader30InstructionSlots = shader_caps.MaxPixelShader30InstructionSlots;
4621
4622     /* The following caps are shader specific, but they are things we cannot detect, or which
4623      * are the same among all shader models. So to avoid code duplication set the shader version
4624      * specific, but otherwise constant caps here
4625      */
4626     if(pCaps->VertexShaderVersion == WINED3DVS_VERSION(3,0)) {
4627         /* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering)
4628         use the VS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum VS3.0 value. */
4629         pCaps->VS20Caps.Caps                     = WINED3DVS20CAPS_PREDICATION;
4630         pCaps->VS20Caps.DynamicFlowControlDepth  = WINED3DVS20_MAX_DYNAMICFLOWCONTROLDEPTH; /* VS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
4631         pCaps->VS20Caps.NumTemps = max(32, adapter->gl_info.limits.arb_vs_temps);
4632         pCaps->VS20Caps.StaticFlowControlDepth   = WINED3DVS20_MAX_STATICFLOWCONTROLDEPTH ; /* level of nesting in loops / if-statements; VS 3.0 requires MAX (4) */
4633
4634         pCaps->MaxVShaderInstructionsExecuted    = 65535; /* VS 3.0 needs at least 65535, some cards even use 2^32-1 */
4635         pCaps->MaxVertexShader30InstructionSlots = max(512, adapter->gl_info.limits.arb_vs_instructions);
4636     }
4637     else if (pCaps->VertexShaderVersion == WINED3DVS_VERSION(2,0))
4638     {
4639         pCaps->VS20Caps.Caps                     = 0;
4640         pCaps->VS20Caps.DynamicFlowControlDepth  = WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH;
4641         pCaps->VS20Caps.NumTemps = max(12, adapter->gl_info.limits.arb_vs_temps);
4642         pCaps->VS20Caps.StaticFlowControlDepth   = 1;
4643
4644         pCaps->MaxVShaderInstructionsExecuted    = 65535;
4645         pCaps->MaxVertexShader30InstructionSlots = 0;
4646     } else { /* VS 1.x */
4647         pCaps->VS20Caps.Caps                     = 0;
4648         pCaps->VS20Caps.DynamicFlowControlDepth  = 0;
4649         pCaps->VS20Caps.NumTemps                 = 0;
4650         pCaps->VS20Caps.StaticFlowControlDepth   = 0;
4651
4652         pCaps->MaxVShaderInstructionsExecuted    = 0;
4653         pCaps->MaxVertexShader30InstructionSlots = 0;
4654     }
4655
4656     if(pCaps->PixelShaderVersion == WINED3DPS_VERSION(3,0)) {
4657         /* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering)
4658         use the PS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum PS 3.0 value. */
4659
4660         /* 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 */
4661         pCaps->PS20Caps.Caps                     = WINED3DPS20CAPS_ARBITRARYSWIZZLE     |
4662                 WINED3DPS20CAPS_GRADIENTINSTRUCTIONS |
4663                 WINED3DPS20CAPS_PREDICATION          |
4664                 WINED3DPS20CAPS_NODEPENDENTREADLIMIT |
4665                 WINED3DPS20CAPS_NOTEXINSTRUCTIONLIMIT;
4666         pCaps->PS20Caps.DynamicFlowControlDepth  = WINED3DPS20_MAX_DYNAMICFLOWCONTROLDEPTH; /* PS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
4667         pCaps->PS20Caps.NumTemps = max(32, adapter->gl_info.limits.arb_ps_temps);
4668         pCaps->PS20Caps.StaticFlowControlDepth   = WINED3DPS20_MAX_STATICFLOWCONTROLDEPTH; /* PS 3.0 requires MAX_STATICFLOWCONTROLDEPTH (4) */
4669         pCaps->PS20Caps.NumInstructionSlots      = WINED3DPS20_MAX_NUMINSTRUCTIONSLOTS; /* PS 3.0 requires MAX_NUMINSTRUCTIONSLOTS (512) */
4670
4671         pCaps->MaxPShaderInstructionsExecuted    = 65535;
4672         pCaps->MaxPixelShader30InstructionSlots = max(WINED3DMIN30SHADERINSTRUCTIONS,
4673                 adapter->gl_info.limits.arb_ps_instructions);
4674     }
4675     else if(pCaps->PixelShaderVersion == WINED3DPS_VERSION(2,0))
4676     {
4677         /* Below we assume PS2.0 specs, not extended 2.0a(GeforceFX)/2.0b(Radeon R3xx) ones */
4678         pCaps->PS20Caps.Caps                     = 0;
4679         pCaps->PS20Caps.DynamicFlowControlDepth  = 0; /* WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH = 0 */
4680         pCaps->PS20Caps.NumTemps = max(12, adapter->gl_info.limits.arb_ps_temps);
4681         pCaps->PS20Caps.StaticFlowControlDepth   = WINED3DPS20_MIN_STATICFLOWCONTROLDEPTH; /* Minimum: 1 */
4682         pCaps->PS20Caps.NumInstructionSlots      = WINED3DPS20_MIN_NUMINSTRUCTIONSLOTS; /* Minimum number (64 ALU + 32 Texture), a GeforceFX uses 512 */
4683
4684         pCaps->MaxPShaderInstructionsExecuted    = 512; /* Minimum value, a GeforceFX uses 1024 */
4685         pCaps->MaxPixelShader30InstructionSlots  = 0;
4686     } else { /* PS 1.x */
4687         pCaps->PS20Caps.Caps                     = 0;
4688         pCaps->PS20Caps.DynamicFlowControlDepth  = 0;
4689         pCaps->PS20Caps.NumTemps                 = 0;
4690         pCaps->PS20Caps.StaticFlowControlDepth   = 0;
4691         pCaps->PS20Caps.NumInstructionSlots      = 0;
4692
4693         pCaps->MaxPShaderInstructionsExecuted    = 0;
4694         pCaps->MaxPixelShader30InstructionSlots  = 0;
4695     }
4696
4697     if(pCaps->VertexShaderVersion >= WINED3DVS_VERSION(2,0)) {
4698         /* OpenGL supports all the formats below, perhaps not always
4699          * without conversion, but it supports them.
4700          * Further GLSL doesn't seem to have an official unsigned type so
4701          * don't advertise it yet as I'm not sure how we handle it.
4702          * We might need to add some clamping in the shader engine to
4703          * support it.
4704          * TODO: WINED3DDTCAPS_USHORT2N, WINED3DDTCAPS_USHORT4N, WINED3DDTCAPS_UDEC3, WINED3DDTCAPS_DEC3N */
4705         pCaps->DeclTypes = WINED3DDTCAPS_UBYTE4    |
4706                            WINED3DDTCAPS_UBYTE4N   |
4707                            WINED3DDTCAPS_SHORT2N   |
4708                            WINED3DDTCAPS_SHORT4N;
4709         if (gl_info->supported[ARB_HALF_FLOAT_VERTEX])
4710         {
4711             pCaps->DeclTypes |= WINED3DDTCAPS_FLOAT16_2 |
4712                                 WINED3DDTCAPS_FLOAT16_4;
4713         }
4714     } else
4715         pCaps->DeclTypes                         = 0;
4716
4717     /* Set DirectDraw helper Caps */
4718     ckey_caps =                         WINEDDCKEYCAPS_DESTBLT              |
4719                                         WINEDDCKEYCAPS_SRCBLT;
4720     fx_caps =                           WINEDDFXCAPS_BLTALPHA               |
4721                                         WINEDDFXCAPS_BLTMIRRORLEFTRIGHT     |
4722                                         WINEDDFXCAPS_BLTMIRRORUPDOWN        |
4723                                         WINEDDFXCAPS_BLTROTATION90          |
4724                                         WINEDDFXCAPS_BLTSHRINKX             |
4725                                         WINEDDFXCAPS_BLTSHRINKXN            |
4726                                         WINEDDFXCAPS_BLTSHRINKY             |
4727                                         WINEDDFXCAPS_BLTSHRINKXN            |
4728                                         WINEDDFXCAPS_BLTSTRETCHX            |
4729                                         WINEDDFXCAPS_BLTSTRETCHXN           |
4730                                         WINEDDFXCAPS_BLTSTRETCHY            |
4731                                         WINEDDFXCAPS_BLTSTRETCHYN;
4732     blit_caps =                         WINEDDCAPS_BLT                      |
4733                                         WINEDDCAPS_BLTCOLORFILL             |
4734                                         WINEDDCAPS_BLTDEPTHFILL             |
4735                                         WINEDDCAPS_BLTSTRETCH               |
4736                                         WINEDDCAPS_CANBLTSYSMEM             |
4737                                         WINEDDCAPS_CANCLIP                  |
4738                                         WINEDDCAPS_CANCLIPSTRETCHED         |
4739                                         WINEDDCAPS_COLORKEY                 |
4740                                         WINEDDCAPS_COLORKEYHWASSIST         |
4741                                         WINEDDCAPS_ALIGNBOUNDARYSRC;
4742
4743     /* Fill the ddraw caps structure */
4744     pCaps->DirectDrawCaps.Caps =        WINEDDCAPS_GDI                      |
4745                                         WINEDDCAPS_PALETTE                  |
4746                                         blit_caps;
4747     pCaps->DirectDrawCaps.Caps2 =       WINEDDCAPS2_CERTIFIED                |
4748                                         WINEDDCAPS2_NOPAGELOCKREQUIRED       |
4749                                         WINEDDCAPS2_PRIMARYGAMMA             |
4750                                         WINEDDCAPS2_WIDESURFACES             |
4751                                         WINEDDCAPS2_CANRENDERWINDOWED;
4752     pCaps->DirectDrawCaps.SVBCaps =     blit_caps;
4753     pCaps->DirectDrawCaps.SVBCKeyCaps = ckey_caps;
4754     pCaps->DirectDrawCaps.SVBFXCaps =   fx_caps;
4755     pCaps->DirectDrawCaps.VSBCaps =     blit_caps;
4756     pCaps->DirectDrawCaps.VSBCKeyCaps = ckey_caps;
4757     pCaps->DirectDrawCaps.VSBFXCaps =   fx_caps;
4758     pCaps->DirectDrawCaps.SSBCaps =     blit_caps;
4759     pCaps->DirectDrawCaps.SSBCKeyCaps = ckey_caps;
4760     pCaps->DirectDrawCaps.SSBFXCaps =   fx_caps;
4761
4762     pCaps->DirectDrawCaps.ddsCaps =     WINEDDSCAPS_ALPHA                   |
4763                                         WINEDDSCAPS_BACKBUFFER              |
4764                                         WINEDDSCAPS_FLIP                    |
4765                                         WINEDDSCAPS_FRONTBUFFER             |
4766                                         WINEDDSCAPS_OFFSCREENPLAIN          |
4767                                         WINEDDSCAPS_PALETTE                 |
4768                                         WINEDDSCAPS_PRIMARYSURFACE          |
4769                                         WINEDDSCAPS_SYSTEMMEMORY            |
4770                                         WINEDDSCAPS_VIDEOMEMORY             |
4771                                         WINEDDSCAPS_VISIBLE;
4772     pCaps->DirectDrawCaps.StrideAlign = DDRAW_PITCH_ALIGNMENT;
4773
4774     /* Set D3D caps if OpenGL is available. */
4775     if (adapter->opengl)
4776     {
4777         pCaps->DirectDrawCaps.ddsCaps |=WINEDDSCAPS_3DDEVICE                |
4778                                         WINEDDSCAPS_MIPMAP                  |
4779                                         WINEDDSCAPS_TEXTURE                 |
4780                                         WINEDDSCAPS_ZBUFFER;
4781         pCaps->DirectDrawCaps.Caps |=   WINEDDCAPS_3D;
4782     }
4783
4784     return WINED3D_OK;
4785 }
4786
4787 static HRESULT WINAPI IWineD3DImpl_CreateDevice(IWineD3D *iface, UINT adapter_idx,
4788         WINED3DDEVTYPE device_type, HWND focus_window, DWORD flags, IUnknown *parent,
4789         IWineD3DDeviceParent *device_parent, IWineD3DDevice **device)
4790 {
4791     IWineD3DImpl *This = (IWineD3DImpl *)iface;
4792     IWineD3DDeviceImpl *object;
4793     HRESULT hr;
4794
4795     TRACE("iface %p, adapter_idx %u, device_type %#x, focus_window %p, flags %#x.\n"
4796             "parent %p, device_parent %p, device %p.\n",
4797             iface, adapter_idx, device_type, focus_window, flags,
4798             parent, device_parent, device);
4799
4800     /* Validate the adapter number. If no adapters are available(no GL), ignore the adapter
4801      * number and create a device without a 3D adapter for 2D only operation. */
4802     if (IWineD3D_GetAdapterCount(iface) && adapter_idx >= IWineD3D_GetAdapterCount(iface))
4803     {
4804         return WINED3DERR_INVALIDCALL;
4805     }
4806
4807     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
4808     if (!object)
4809     {
4810         ERR("Failed to allocate device memory.\n");
4811         return E_OUTOFMEMORY;
4812     }
4813
4814     hr = device_init(object, This, adapter_idx, device_type, focus_window, flags, parent, device_parent);
4815     if (FAILED(hr))
4816     {
4817         WARN("Failed to initialize device, hr %#x.\n", hr);
4818         HeapFree(GetProcessHeap(), 0, object);
4819         return hr;
4820     }
4821
4822     TRACE("Created device %p.\n", object);
4823     *device = (IWineD3DDevice *)object;
4824
4825     IWineD3DDeviceParent_WineD3DDeviceCreated(device_parent, *device);
4826
4827     return WINED3D_OK;
4828 }
4829
4830 static HRESULT WINAPI IWineD3DImpl_GetParent(IWineD3D *iface, IUnknown **pParent) {
4831     IWineD3DImpl *This = (IWineD3DImpl *)iface;
4832     IUnknown_AddRef(This->parent);
4833     *pParent = This->parent;
4834     return WINED3D_OK;
4835 }
4836
4837 static void WINE_GLAPI invalid_func(const void *data)
4838 {
4839     ERR("Invalid vertex attribute function called\n");
4840     DebugBreak();
4841 }
4842
4843 static void WINE_GLAPI invalid_texcoord_func(GLenum unit, const void *data)
4844 {
4845     ERR("Invalid texcoord function called\n");
4846     DebugBreak();
4847 }
4848
4849 /* Helper functions for providing vertex data to opengl. The arrays are initialized based on
4850  * the extension detection and are used in drawStridedSlow
4851  */
4852 static void WINE_GLAPI position_d3dcolor(const void *data)
4853 {
4854     DWORD pos = *((const DWORD *)data);
4855
4856     FIXME("Add a test for fixed function position from d3dcolor type\n");
4857     glVertex4s(D3DCOLOR_B_R(pos),
4858                D3DCOLOR_B_G(pos),
4859                D3DCOLOR_B_B(pos),
4860                D3DCOLOR_B_A(pos));
4861 }
4862
4863 static void WINE_GLAPI position_float4(const void *data)
4864 {
4865     const GLfloat *pos = data;
4866
4867     if (pos[3] != 0.0f && pos[3] != 1.0f)
4868     {
4869         float w = 1.0f / pos[3];
4870
4871         glVertex4f(pos[0] * w, pos[1] * w, pos[2] * w, w);
4872     }
4873     else
4874     {
4875         glVertex3fv(pos);
4876     }
4877 }
4878
4879 static void WINE_GLAPI diffuse_d3dcolor(const void *data)
4880 {
4881     DWORD diffuseColor = *((const DWORD *)data);
4882
4883     glColor4ub(D3DCOLOR_B_R(diffuseColor),
4884                D3DCOLOR_B_G(diffuseColor),
4885                D3DCOLOR_B_B(diffuseColor),
4886                D3DCOLOR_B_A(diffuseColor));
4887 }
4888
4889 static void WINE_GLAPI specular_d3dcolor(const void *data)
4890 {
4891     DWORD specularColor = *((const DWORD *)data);
4892     GLbyte d[] = {D3DCOLOR_B_R(specularColor),
4893             D3DCOLOR_B_G(specularColor),
4894             D3DCOLOR_B_B(specularColor)};
4895
4896     specular_func_3ubv(d);
4897 }
4898
4899 static void WINE_GLAPI warn_no_specular_func(const void *data)
4900 {
4901     WARN("GL_EXT_secondary_color not supported\n");
4902 }
4903
4904 static void fillGLAttribFuncs(const struct wined3d_gl_info *gl_info)
4905 {
4906     position_funcs[WINED3D_FFP_EMIT_FLOAT1]      = invalid_func;
4907     position_funcs[WINED3D_FFP_EMIT_FLOAT2]      = invalid_func;
4908     position_funcs[WINED3D_FFP_EMIT_FLOAT3]      = (glAttribFunc)glVertex3fv;
4909     position_funcs[WINED3D_FFP_EMIT_FLOAT4]      = position_float4;
4910     position_funcs[WINED3D_FFP_EMIT_D3DCOLOR]    = position_d3dcolor;
4911     position_funcs[WINED3D_FFP_EMIT_UBYTE4]      = invalid_func;
4912     position_funcs[WINED3D_FFP_EMIT_SHORT2]      = invalid_func;
4913     position_funcs[WINED3D_FFP_EMIT_SHORT4]      = (glAttribFunc)glVertex2sv;
4914     position_funcs[WINED3D_FFP_EMIT_UBYTE4N]     = invalid_func;
4915     position_funcs[WINED3D_FFP_EMIT_SHORT2N]     = invalid_func;
4916     position_funcs[WINED3D_FFP_EMIT_SHORT4N]     = invalid_func;
4917     position_funcs[WINED3D_FFP_EMIT_USHORT2N]    = invalid_func;
4918     position_funcs[WINED3D_FFP_EMIT_USHORT4N]    = invalid_func;
4919     position_funcs[WINED3D_FFP_EMIT_UDEC3]       = invalid_func;
4920     position_funcs[WINED3D_FFP_EMIT_DEC3N]       = invalid_func;
4921     position_funcs[WINED3D_FFP_EMIT_FLOAT16_2]   = invalid_func;
4922     position_funcs[WINED3D_FFP_EMIT_FLOAT16_4]   = invalid_func;
4923
4924     diffuse_funcs[WINED3D_FFP_EMIT_FLOAT1]       = invalid_func;
4925     diffuse_funcs[WINED3D_FFP_EMIT_FLOAT2]       = invalid_func;
4926     diffuse_funcs[WINED3D_FFP_EMIT_FLOAT3]       = (glAttribFunc)glColor3fv;
4927     diffuse_funcs[WINED3D_FFP_EMIT_FLOAT4]       = (glAttribFunc)glColor4fv;
4928     diffuse_funcs[WINED3D_FFP_EMIT_D3DCOLOR]     = diffuse_d3dcolor;
4929     diffuse_funcs[WINED3D_FFP_EMIT_UBYTE4]       = invalid_func;
4930     diffuse_funcs[WINED3D_FFP_EMIT_SHORT2]       = invalid_func;
4931     diffuse_funcs[WINED3D_FFP_EMIT_SHORT4]       = invalid_func;
4932     diffuse_funcs[WINED3D_FFP_EMIT_UBYTE4N]      = (glAttribFunc)glColor4ubv;
4933     diffuse_funcs[WINED3D_FFP_EMIT_SHORT2N]      = invalid_func;
4934     diffuse_funcs[WINED3D_FFP_EMIT_SHORT4N]      = (glAttribFunc)glColor4sv;
4935     diffuse_funcs[WINED3D_FFP_EMIT_USHORT2N]     = invalid_func;
4936     diffuse_funcs[WINED3D_FFP_EMIT_USHORT4N]     = (glAttribFunc)glColor4usv;
4937     diffuse_funcs[WINED3D_FFP_EMIT_UDEC3]        = invalid_func;
4938     diffuse_funcs[WINED3D_FFP_EMIT_DEC3N]        = invalid_func;
4939     diffuse_funcs[WINED3D_FFP_EMIT_FLOAT16_2]    = invalid_func;
4940     diffuse_funcs[WINED3D_FFP_EMIT_FLOAT16_4]    = invalid_func;
4941
4942     /* No 4 component entry points here */
4943     specular_funcs[WINED3D_FFP_EMIT_FLOAT1]      = invalid_func;
4944     specular_funcs[WINED3D_FFP_EMIT_FLOAT2]      = invalid_func;
4945     if (gl_info->supported[EXT_SECONDARY_COLOR])
4946     {
4947         specular_funcs[WINED3D_FFP_EMIT_FLOAT3]  = (glAttribFunc)GL_EXTCALL(glSecondaryColor3fvEXT);
4948     }
4949     else
4950     {
4951         specular_funcs[WINED3D_FFP_EMIT_FLOAT3]  = warn_no_specular_func;
4952     }
4953     specular_funcs[WINED3D_FFP_EMIT_FLOAT4]      = invalid_func;
4954     if (gl_info->supported[EXT_SECONDARY_COLOR])
4955     {
4956         specular_func_3ubv = (glAttribFunc)GL_EXTCALL(glSecondaryColor3ubvEXT);
4957         specular_funcs[WINED3D_FFP_EMIT_D3DCOLOR] = specular_d3dcolor;
4958     }
4959     else
4960     {
4961         specular_funcs[WINED3D_FFP_EMIT_D3DCOLOR] = warn_no_specular_func;
4962     }
4963     specular_funcs[WINED3D_FFP_EMIT_UBYTE4]      = invalid_func;
4964     specular_funcs[WINED3D_FFP_EMIT_SHORT2]      = invalid_func;
4965     specular_funcs[WINED3D_FFP_EMIT_SHORT4]      = invalid_func;
4966     specular_funcs[WINED3D_FFP_EMIT_UBYTE4N]     = invalid_func;
4967     specular_funcs[WINED3D_FFP_EMIT_SHORT2N]     = invalid_func;
4968     specular_funcs[WINED3D_FFP_EMIT_SHORT4N]     = invalid_func;
4969     specular_funcs[WINED3D_FFP_EMIT_USHORT2N]    = invalid_func;
4970     specular_funcs[WINED3D_FFP_EMIT_USHORT4N]    = invalid_func;
4971     specular_funcs[WINED3D_FFP_EMIT_UDEC3]       = invalid_func;
4972     specular_funcs[WINED3D_FFP_EMIT_DEC3N]       = invalid_func;
4973     specular_funcs[WINED3D_FFP_EMIT_FLOAT16_2]   = invalid_func;
4974     specular_funcs[WINED3D_FFP_EMIT_FLOAT16_4]   = invalid_func;
4975
4976     /* Only 3 component entry points here. Test how others behave. Float4 normals are used
4977      * by one of our tests, trying to pass it to the pixel shader, which fails on Windows.
4978      */
4979     normal_funcs[WINED3D_FFP_EMIT_FLOAT1]         = invalid_func;
4980     normal_funcs[WINED3D_FFP_EMIT_FLOAT2]         = invalid_func;
4981     normal_funcs[WINED3D_FFP_EMIT_FLOAT3]         = (glAttribFunc)glNormal3fv;
4982     normal_funcs[WINED3D_FFP_EMIT_FLOAT4]         = (glAttribFunc)glNormal3fv; /* Just ignore the 4th value */
4983     normal_funcs[WINED3D_FFP_EMIT_D3DCOLOR]       = invalid_func;
4984     normal_funcs[WINED3D_FFP_EMIT_UBYTE4]         = invalid_func;
4985     normal_funcs[WINED3D_FFP_EMIT_SHORT2]         = invalid_func;
4986     normal_funcs[WINED3D_FFP_EMIT_SHORT4]         = invalid_func;
4987     normal_funcs[WINED3D_FFP_EMIT_UBYTE4N]        = invalid_func;
4988     normal_funcs[WINED3D_FFP_EMIT_SHORT2N]        = invalid_func;
4989     normal_funcs[WINED3D_FFP_EMIT_SHORT4N]        = invalid_func;
4990     normal_funcs[WINED3D_FFP_EMIT_USHORT2N]       = invalid_func;
4991     normal_funcs[WINED3D_FFP_EMIT_USHORT4N]       = invalid_func;
4992     normal_funcs[WINED3D_FFP_EMIT_UDEC3]          = invalid_func;
4993     normal_funcs[WINED3D_FFP_EMIT_DEC3N]          = invalid_func;
4994     normal_funcs[WINED3D_FFP_EMIT_FLOAT16_2]      = invalid_func;
4995     normal_funcs[WINED3D_FFP_EMIT_FLOAT16_4]      = invalid_func;
4996
4997     multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT1]    = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord1fvARB);
4998     multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT2]    = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord2fvARB);
4999     multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT3]    = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord3fvARB);
5000     multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT4]    = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord4fvARB);
5001     multi_texcoord_funcs[WINED3D_FFP_EMIT_D3DCOLOR]  = invalid_texcoord_func;
5002     multi_texcoord_funcs[WINED3D_FFP_EMIT_UBYTE4]    = invalid_texcoord_func;
5003     multi_texcoord_funcs[WINED3D_FFP_EMIT_SHORT2]    = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord2svARB);
5004     multi_texcoord_funcs[WINED3D_FFP_EMIT_SHORT4]    = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord4svARB);
5005     multi_texcoord_funcs[WINED3D_FFP_EMIT_UBYTE4N]   = invalid_texcoord_func;
5006     multi_texcoord_funcs[WINED3D_FFP_EMIT_SHORT2N]   = invalid_texcoord_func;
5007     multi_texcoord_funcs[WINED3D_FFP_EMIT_SHORT4N]   = invalid_texcoord_func;
5008     multi_texcoord_funcs[WINED3D_FFP_EMIT_USHORT2N]  = invalid_texcoord_func;
5009     multi_texcoord_funcs[WINED3D_FFP_EMIT_USHORT4N]  = invalid_texcoord_func;
5010     multi_texcoord_funcs[WINED3D_FFP_EMIT_UDEC3]     = invalid_texcoord_func;
5011     multi_texcoord_funcs[WINED3D_FFP_EMIT_DEC3N]     = invalid_texcoord_func;
5012     if (gl_info->supported[NV_HALF_FLOAT])
5013     {
5014         /* Not supported by ARB_HALF_FLOAT_VERTEX, so check for NV_HALF_FLOAT */
5015         multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT16_2] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord2hvNV);
5016         multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT16_4] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord4hvNV);
5017     } else {
5018         multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT16_2] = invalid_texcoord_func;
5019         multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT16_4] = invalid_texcoord_func;
5020     }
5021 }
5022
5023 BOOL InitAdapters(IWineD3DImpl *This)
5024 {
5025     static HMODULE mod_gl;
5026     BOOL ret;
5027     int ps_selected_mode, vs_selected_mode;
5028
5029     /* No need to hold any lock. The calling library makes sure only one thread calls
5030      * wined3d simultaneously
5031      */
5032
5033     TRACE("Initializing adapters\n");
5034
5035     if(!mod_gl) {
5036 #ifdef USE_WIN32_OPENGL
5037 #define USE_GL_FUNC(pfn) pfn = (void*)GetProcAddress(mod_gl, #pfn);
5038         mod_gl = LoadLibraryA("opengl32.dll");
5039         if(!mod_gl) {
5040             ERR("Can't load opengl32.dll!\n");
5041             goto nogl_adapter;
5042         }
5043 #else
5044 #define USE_GL_FUNC(pfn) pfn = (void*)pwglGetProcAddress(#pfn);
5045         /* To bypass the opengl32 thunks load wglGetProcAddress from gdi32 (glXGetProcAddress wrapper) instead of opengl32's */
5046         mod_gl = GetModuleHandleA("gdi32.dll");
5047 #endif
5048     }
5049
5050 /* Load WGL core functions from opengl32.dll */
5051 #define USE_WGL_FUNC(pfn) p##pfn = (void*)GetProcAddress(mod_gl, #pfn);
5052     WGL_FUNCS_GEN;
5053 #undef USE_WGL_FUNC
5054
5055     if(!pwglGetProcAddress) {
5056         ERR("Unable to load wglGetProcAddress!\n");
5057         goto nogl_adapter;
5058     }
5059
5060 /* Dynamically load all GL core functions */
5061     GL_FUNCS_GEN;
5062 #undef USE_GL_FUNC
5063
5064     /* Load glFinish and glFlush from opengl32.dll even if we're not using WIN32 opengl
5065      * otherwise because we have to use winex11.drv's override
5066      */
5067 #ifdef USE_WIN32_OPENGL
5068     wglFinish = (void*)GetProcAddress(mod_gl, "glFinish");
5069     wglFlush = (void*)GetProcAddress(mod_gl, "glFlush");
5070 #else
5071     wglFinish = (void*)pwglGetProcAddress("wglFinish");
5072     wglFlush = (void*)pwglGetProcAddress("wglFlush");
5073 #endif
5074
5075     glEnableWINE = glEnable;
5076     glDisableWINE = glDisable;
5077
5078     /* For now only one default adapter */
5079     {
5080         struct wined3d_adapter *adapter = &This->adapters[0];
5081         const struct wined3d_gl_info *gl_info = &adapter->gl_info;
5082         struct wined3d_fake_gl_ctx fake_gl_ctx = {0};
5083         int iPixelFormat;
5084         int res;
5085         int i;
5086         WineD3D_PixelFormat *cfgs;
5087         DISPLAY_DEVICEW DisplayDevice;
5088         HDC hdc;
5089
5090         TRACE("Initializing default adapter\n");
5091         adapter->ordinal = 0;
5092         adapter->monitorPoint.x = -1;
5093         adapter->monitorPoint.y = -1;
5094
5095         if (!AllocateLocallyUniqueId(&adapter->luid))
5096         {
5097             DWORD err = GetLastError();
5098             ERR("Failed to set adapter LUID (%#x).\n", err);
5099             goto nogl_adapter;
5100         }
5101         TRACE("Allocated LUID %08x:%08x for adapter.\n",
5102                 adapter->luid.HighPart, adapter->luid.LowPart);
5103
5104         if (!WineD3D_CreateFakeGLContext(&fake_gl_ctx))
5105         {
5106             ERR("Failed to get a gl context for default adapter\n");
5107             goto nogl_adapter;
5108         }
5109
5110         ret = IWineD3DImpl_FillGLCaps(adapter);
5111         if(!ret) {
5112             ERR("Failed to initialize gl caps for default adapter\n");
5113             WineD3D_ReleaseFakeGLContext(&fake_gl_ctx);
5114             goto nogl_adapter;
5115         }
5116         ret = initPixelFormats(&adapter->gl_info, adapter->driver_info.vendor);
5117         if(!ret) {
5118             ERR("Failed to init gl formats\n");
5119             WineD3D_ReleaseFakeGLContext(&fake_gl_ctx);
5120             goto nogl_adapter;
5121         }
5122
5123         hdc = fake_gl_ctx.dc;
5124
5125         /* Use the VideoRamSize registry setting when set */
5126         if(wined3d_settings.emulated_textureram)
5127             adapter->TextureRam = wined3d_settings.emulated_textureram;
5128         else
5129             adapter->TextureRam = adapter->gl_info.vidmem;
5130         adapter->UsedTextureRam = 0;
5131         TRACE("Emulating %dMB of texture ram\n", adapter->TextureRam/(1024*1024));
5132
5133         /* Initialize the Adapter's DeviceName which is required for ChangeDisplaySettings and friends */
5134         DisplayDevice.cb = sizeof(DisplayDevice);
5135         EnumDisplayDevicesW(NULL, 0 /* Adapter 0 = iDevNum 0 */, &DisplayDevice, 0);
5136         TRACE("DeviceName: %s\n", debugstr_w(DisplayDevice.DeviceName));
5137         strcpyW(adapter->DeviceName, DisplayDevice.DeviceName);
5138
5139         if (gl_info->supported[WGL_ARB_PIXEL_FORMAT])
5140         {
5141             int attribute;
5142             int attribs[11];
5143             int values[11];
5144             int nAttribs = 0;
5145
5146             attribute = WGL_NUMBER_PIXEL_FORMATS_ARB;
5147             GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc, 0, 0, 1, &attribute, &adapter->nCfgs));
5148
5149             adapter->cfgs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, adapter->nCfgs *sizeof(WineD3D_PixelFormat));
5150             cfgs = adapter->cfgs;
5151             attribs[nAttribs++] = WGL_RED_BITS_ARB;
5152             attribs[nAttribs++] = WGL_GREEN_BITS_ARB;
5153             attribs[nAttribs++] = WGL_BLUE_BITS_ARB;
5154             attribs[nAttribs++] = WGL_ALPHA_BITS_ARB;
5155             attribs[nAttribs++] = WGL_COLOR_BITS_ARB;
5156             attribs[nAttribs++] = WGL_DEPTH_BITS_ARB;
5157             attribs[nAttribs++] = WGL_STENCIL_BITS_ARB;
5158             attribs[nAttribs++] = WGL_DRAW_TO_WINDOW_ARB;
5159             attribs[nAttribs++] = WGL_PIXEL_TYPE_ARB;
5160             attribs[nAttribs++] = WGL_DOUBLE_BUFFER_ARB;
5161             attribs[nAttribs++] = WGL_AUX_BUFFERS_ARB;
5162
5163             for (iPixelFormat=1; iPixelFormat <= adapter->nCfgs; ++iPixelFormat)
5164             {
5165                 res = GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc, iPixelFormat, 0, nAttribs, attribs, values));
5166
5167                 if(!res)
5168                     continue;
5169
5170                 /* Cache the pixel format */
5171                 cfgs->iPixelFormat = iPixelFormat;
5172                 cfgs->redSize = values[0];
5173                 cfgs->greenSize = values[1];
5174                 cfgs->blueSize = values[2];
5175                 cfgs->alphaSize = values[3];
5176                 cfgs->colorSize = values[4];
5177                 cfgs->depthSize = values[5];
5178                 cfgs->stencilSize = values[6];
5179                 cfgs->windowDrawable = values[7];
5180                 cfgs->iPixelType = values[8];
5181                 cfgs->doubleBuffer = values[9];
5182                 cfgs->auxBuffers = values[10];
5183
5184                 cfgs->numSamples = 0;
5185                 /* Check multisample support */
5186                 if (gl_info->supported[ARB_MULTISAMPLE])
5187                 {
5188                     int attrib[2] = {WGL_SAMPLE_BUFFERS_ARB, WGL_SAMPLES_ARB};
5189                     int value[2];
5190                     if(GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc, iPixelFormat, 0, 2, attrib, value))) {
5191                         /* value[0] = WGL_SAMPLE_BUFFERS_ARB which tells whether multisampling is supported.
5192                         * value[1] = number of multi sample buffers*/
5193                         if(value[0])
5194                             cfgs->numSamples = value[1];
5195                     }
5196                 }
5197
5198                 TRACE("iPixelFormat=%d, iPixelType=%#x, doubleBuffer=%d, RGBA=%d/%d/%d/%d, "
5199                         "depth=%d, stencil=%d, samples=%d, windowDrawable=%d\n",
5200                         cfgs->iPixelFormat, cfgs->iPixelType, cfgs->doubleBuffer,
5201                         cfgs->redSize, cfgs->greenSize, cfgs->blueSize, cfgs->alphaSize,
5202                         cfgs->depthSize, cfgs->stencilSize, cfgs->numSamples, cfgs->windowDrawable);
5203                 cfgs++;
5204             }
5205         }
5206         else
5207         {
5208             int nCfgs = DescribePixelFormat(hdc, 0, 0, 0);
5209             adapter->cfgs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, nCfgs*sizeof(WineD3D_PixelFormat));
5210             adapter->nCfgs = 0; /* We won't accept all formats e.g. software accelerated ones will be skipped */
5211
5212             cfgs = adapter->cfgs;
5213             for(iPixelFormat=1; iPixelFormat<=nCfgs; iPixelFormat++)
5214             {
5215                 PIXELFORMATDESCRIPTOR ppfd;
5216
5217                 res = DescribePixelFormat(hdc, iPixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &ppfd);
5218                 if(!res)
5219                     continue;
5220
5221                 /* We only want HW acceleration using an OpenGL ICD driver.
5222                  * PFD_GENERIC_FORMAT = slow opengl 1.1 gdi software rendering
5223                  * PFD_GENERIC_ACCELERATED = partial hw acceleration using a MCD driver (e.g. 3dfx minigl)
5224                  */
5225                 if(ppfd.dwFlags & (PFD_GENERIC_FORMAT | PFD_GENERIC_ACCELERATED))
5226                 {
5227                     TRACE("Skipping iPixelFormat=%d because it isn't ICD accelerated\n", iPixelFormat);
5228                     continue;
5229                 }
5230
5231                 cfgs->iPixelFormat = iPixelFormat;
5232                 cfgs->redSize = ppfd.cRedBits;
5233                 cfgs->greenSize = ppfd.cGreenBits;
5234                 cfgs->blueSize = ppfd.cBlueBits;
5235                 cfgs->alphaSize = ppfd.cAlphaBits;
5236                 cfgs->colorSize = ppfd.cColorBits;
5237                 cfgs->depthSize = ppfd.cDepthBits;
5238                 cfgs->stencilSize = ppfd.cStencilBits;
5239                 cfgs->windowDrawable = (ppfd.dwFlags & PFD_DRAW_TO_WINDOW) ? 1 : 0;
5240                 cfgs->iPixelType = (ppfd.iPixelType == PFD_TYPE_RGBA) ? WGL_TYPE_RGBA_ARB : WGL_TYPE_COLORINDEX_ARB;
5241                 cfgs->doubleBuffer = (ppfd.dwFlags & PFD_DOUBLEBUFFER) ? 1 : 0;
5242                 cfgs->auxBuffers = ppfd.cAuxBuffers;
5243                 cfgs->numSamples = 0;
5244
5245                 TRACE("iPixelFormat=%d, iPixelType=%#x, doubleBuffer=%d, RGBA=%d/%d/%d/%d, "
5246                         "depth=%d, stencil=%d, windowDrawable=%d\n",
5247                         cfgs->iPixelFormat, cfgs->iPixelType, cfgs->doubleBuffer,
5248                         cfgs->redSize, cfgs->greenSize, cfgs->blueSize, cfgs->alphaSize,
5249                         cfgs->depthSize, cfgs->stencilSize, cfgs->windowDrawable);
5250                 cfgs++;
5251                 adapter->nCfgs++;
5252             }
5253
5254             /* 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 */
5255             if(!adapter->nCfgs)
5256             {
5257                 ERR("Disabling Direct3D because no hardware accelerated pixel formats have been found!\n");
5258
5259                 WineD3D_ReleaseFakeGLContext(&fake_gl_ctx);
5260                 HeapFree(GetProcessHeap(), 0, adapter->cfgs);
5261                 goto nogl_adapter;
5262             }
5263         }
5264
5265         /* D16, D24X8 and D24S8 are common depth / depth+stencil formats. All drivers support them though this doesn't
5266          * mean that the format is offered in hardware. For instance Geforce8 cards don't have offer D16 in hardware
5267          * but just fake it using D24(X8?) which is fine. D3D also allows that.
5268          * Some display drivers (i915 on Linux) only report mixed depth+stencil formats like D24S8. MSDN clearly mentions
5269          * that only on lockable formats (e.g. D16_locked) the bit order is guaranteed and that on other formats the
5270          * driver is allowed to consume more bits EXCEPT for stencil bits.
5271          *
5272          * Mark an adapter with this broken stencil behavior.
5273          */
5274         adapter->brokenStencil = TRUE;
5275         for (i = 0, cfgs = adapter->cfgs; i < adapter->nCfgs; ++i)
5276         {
5277             /* Nearly all drivers offer depth formats without stencil, only on i915 this if-statement won't be entered. */
5278             if(cfgs[i].depthSize && !cfgs[i].stencilSize) {
5279                 adapter->brokenStencil = FALSE;
5280                 break;
5281             }
5282         }
5283
5284         WineD3D_ReleaseFakeGLContext(&fake_gl_ctx);
5285
5286         select_shader_mode(&adapter->gl_info, &ps_selected_mode, &vs_selected_mode);
5287         fillGLAttribFuncs(&adapter->gl_info);
5288         adapter->opengl = TRUE;
5289     }
5290     This->adapter_count = 1;
5291     TRACE("%u adapters successfully initialized\n", This->adapter_count);
5292
5293     return TRUE;
5294
5295 nogl_adapter:
5296     /* Initialize an adapter for ddraw-only memory counting */
5297     memset(This->adapters, 0, sizeof(This->adapters));
5298     This->adapters[0].ordinal = 0;
5299     This->adapters[0].opengl = FALSE;
5300     This->adapters[0].monitorPoint.x = -1;
5301     This->adapters[0].monitorPoint.y = -1;
5302
5303     This->adapters[0].driver_info.name = "Display";
5304     This->adapters[0].driver_info.description = "WineD3D DirectDraw Emulation";
5305     if(wined3d_settings.emulated_textureram) {
5306         This->adapters[0].TextureRam = wined3d_settings.emulated_textureram;
5307     } else {
5308         This->adapters[0].TextureRam = 8 * 1024 * 1024; /* This is plenty for a DDraw-only card */
5309     }
5310
5311     initPixelFormatsNoGL(&This->adapters[0].gl_info);
5312
5313     This->adapter_count = 1;
5314     return FALSE;
5315 }
5316
5317 /**********************************************************
5318  * IWineD3D VTbl follows
5319  **********************************************************/
5320
5321 const IWineD3DVtbl IWineD3D_Vtbl =
5322 {
5323     /* IUnknown */
5324     IWineD3DImpl_QueryInterface,
5325     IWineD3DImpl_AddRef,
5326     IWineD3DImpl_Release,
5327     /* IWineD3D */
5328     IWineD3DImpl_GetParent,
5329     IWineD3DImpl_GetAdapterCount,
5330     IWineD3DImpl_RegisterSoftwareDevice,
5331     IWineD3DImpl_GetAdapterMonitor,
5332     IWineD3DImpl_GetAdapterModeCount,
5333     IWineD3DImpl_EnumAdapterModes,
5334     IWineD3DImpl_GetAdapterDisplayMode,
5335     IWineD3DImpl_GetAdapterIdentifier,
5336     IWineD3DImpl_CheckDeviceMultiSampleType,
5337     IWineD3DImpl_CheckDepthStencilMatch,
5338     IWineD3DImpl_CheckDeviceType,
5339     IWineD3DImpl_CheckDeviceFormat,
5340     IWineD3DImpl_CheckDeviceFormatConversion,
5341     IWineD3DImpl_GetDeviceCaps,
5342     IWineD3DImpl_CreateDevice
5343 };
5344
5345 static void STDMETHODCALLTYPE wined3d_null_wined3d_object_destroyed(void *parent) {}
5346
5347 const struct wined3d_parent_ops wined3d_null_parent_ops =
5348 {
5349     wined3d_null_wined3d_object_destroyed,
5350 };