crypt32/tests: Fix some test failures on Win9x.
[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  *
10  * This library is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * This library is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with this library; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23  */
24
25 /* Compile time diagnostics: */
26
27 #ifndef DEBUG_SINGLE_MODE
28 /* Set to 1 to force only a single display mode to be exposed: */
29 #define DEBUG_SINGLE_MODE 0
30 #endif
31
32 #include "config.h"
33 #include <assert.h>
34 #include "wined3d_private.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
37 WINE_DECLARE_DEBUG_CHANNEL(d3d_caps);
38
39 #define GLINFO_LOCATION (*gl_info)
40
41 /* The d3d device ID */
42 static const GUID IID_D3DDEVICE_D3DUID = { 0xaeb2cdd4, 0x6e41, 0x43ea, { 0x94,0x1c,0x83,0x61,0xcc,0x76,0x07,0x81 } };
43
44 /* Extension detection */
45 static const struct {
46     const char *extension_string;
47     GL_SupportedExt extension;
48     DWORD version;
49 } EXTENSION_MAP[] = {
50     /* APPLE */
51     {"GL_APPLE_client_storage",             APPLE_CLIENT_STORAGE,           0                           },
52     {"GL_APPLE_fence",                      APPLE_FENCE,                    0                           },
53     {"GL_APPLE_flush_render",               APPLE_FLUSH_RENDER,             0                           },
54     {"GL_APPLE_ycbcr_422",                  APPLE_YCBCR_422,                0                           },
55     {"GL_APPLE_float_pixels",               APPLE_FLOAT_PIXELS,             0                           },
56
57     /* ATI */
58     {"GL_ATI_separate_stencil",             ATI_SEPARATE_STENCIL,           0                           },
59     {"GL_ATI_texture_env_combine3",         ATI_TEXTURE_ENV_COMBINE3,       0                           },
60     {"GL_ATI_texture_mirror_once",          ATI_TEXTURE_MIRROR_ONCE,        0                           },
61     {"GL_ATI_fragment_shader",              ATI_FRAGMENT_SHADER,            0                           },
62     {"GL_ATI_texture_compression_3dc",      ATI_TEXTURE_COMPRESSION_3DC,    0                           },
63
64     /* ARB */
65     {"GL_ARB_color_buffer_float",           ARB_COLOR_BUFFER_FLOAT,         0                           },
66     {"GL_ARB_draw_buffers",                 ARB_DRAW_BUFFERS,               0                           },
67     {"GL_ARB_fragment_program",             ARB_FRAGMENT_PROGRAM,           0                           },
68     {"GL_ARB_fragment_shader",              ARB_FRAGMENT_SHADER,            0                           },
69     {"GL_ARB_geometry_shader4",             ARB_GEOMETRY_SHADER4,           0                           },
70     {"GL_ARB_half_float_pixel",             ARB_HALF_FLOAT_PIXEL,           0                           },
71     {"GL_ARB_imaging",                      ARB_IMAGING,                    0                           },
72     {"GL_ARB_multisample",                  ARB_MULTISAMPLE,                0                           }, /* needs GLX_ARB_MULTISAMPLE as well */
73     {"GL_ARB_multitexture",                 ARB_MULTITEXTURE,               0                           },
74     {"GL_ARB_occlusion_query",              ARB_OCCLUSION_QUERY,            0                           },
75     {"GL_ARB_pixel_buffer_object",          ARB_PIXEL_BUFFER_OBJECT,        0                           },
76     {"GL_ARB_point_parameters",             ARB_POINT_PARAMETERS,           0                           },
77     {"GL_ARB_point_sprite",                 ARB_POINT_SPRITE,               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_blend",                 ARB_VERTEX_BLEND,               0                           },
90     {"GL_ARB_vertex_buffer_object",         ARB_VERTEX_BUFFER_OBJECT,       0                           },
91     {"GL_ARB_vertex_program",               ARB_VERTEX_PROGRAM,             0                           },
92     {"GL_ARB_vertex_shader",                ARB_VERTEX_SHADER,              0                           },
93     {"GL_ARB_shader_objects",               ARB_SHADER_OBJECTS,             0                           },
94
95     /* EXT */
96     {"GL_EXT_blend_color",                  EXT_BLEND_COLOR,                0                           },
97     {"GL_EXT_blend_minmax",                 EXT_BLEND_MINMAX,               0                           },
98     {"GL_EXT_blend_equation_separate",      EXT_BLEND_EQUATION_SEPARATE,    0                           },
99     {"GL_EXT_blend_func_separate",          EXT_BLEND_FUNC_SEPARATE,        0                           },
100     {"GL_EXT_fog_coord",                    EXT_FOG_COORD,                  0                           },
101     {"GL_EXT_framebuffer_blit",             EXT_FRAMEBUFFER_BLIT,           0                           },
102     {"GL_EXT_framebuffer_multisample",      EXT_FRAMEBUFFER_MULTISAMPLE,    0                           },
103     {"GL_EXT_framebuffer_object",           EXT_FRAMEBUFFER_OBJECT,         0                           },
104     {"GL_EXT_paletted_texture",             EXT_PALETTED_TEXTURE,           0                           },
105     {"GL_EXT_point_parameters",             EXT_POINT_PARAMETERS,           0                           },
106     {"GL_EXT_secondary_color",              EXT_SECONDARY_COLOR,            0                           },
107     {"GL_EXT_stencil_two_side",             EXT_STENCIL_TWO_SIDE,           0                           },
108     {"GL_EXT_stencil_wrap",                 EXT_STENCIL_WRAP,               0                           },
109     {"GL_EXT_texture3D",                    EXT_TEXTURE3D,                  MAKEDWORD_VERSION(1, 2)     },
110     {"GL_EXT_texture_compression_s3tc",     EXT_TEXTURE_COMPRESSION_S3TC,   0                           },
111     {"GL_EXT_texture_compression_rgtc",     EXT_TEXTURE_COMPRESSION_RGTC,   0                           },
112     {"GL_EXT_texture_env_add",              EXT_TEXTURE_ENV_ADD,            0                           },
113     {"GL_EXT_texture_env_combine",          EXT_TEXTURE_ENV_COMBINE,        0                           },
114     {"GL_EXT_texture_env_dot3",             EXT_TEXTURE_ENV_DOT3,           0                           },
115     {"GL_EXT_texture_sRGB",                 EXT_TEXTURE_SRGB,               0                           },
116     {"GL_EXT_texture_swizzle",              EXT_TEXTURE_SWIZZLE,            0                           },
117     {"GL_EXT_texture_filter_anisotropic",   EXT_TEXTURE_FILTER_ANISOTROPIC, 0                           },
118     {"GL_EXT_texture_lod",                  EXT_TEXTURE_LOD,                0                           },
119     {"GL_EXT_texture_lod_bias",             EXT_TEXTURE_LOD_BIAS,           0                           },
120     {"GL_EXT_vertex_array_bgra",            EXT_VERTEX_ARRAY_BGRA,          0                           },
121     {"GL_EXT_vertex_shader",                EXT_VERTEX_SHADER,              0                           },
122     {"GL_EXT_gpu_program_parameters",       EXT_GPU_PROGRAM_PARAMETERS,     0                           },
123
124     /* NV */
125     {"GL_NV_half_float",                    NV_HALF_FLOAT,                  0                           },
126     {"GL_NV_fence",                         NV_FENCE,                       0                           },
127     {"GL_NV_fog_distance",                  NV_FOG_DISTANCE,                0                           },
128     {"GL_NV_fragment_program",              NV_FRAGMENT_PROGRAM,            0                           },
129     {"GL_NV_fragment_program2",             NV_FRAGMENT_PROGRAM2,           0                           },
130     {"GL_NV_register_combiners",            NV_REGISTER_COMBINERS,          0                           },
131     {"GL_NV_register_combiners2",           NV_REGISTER_COMBINERS2,         0                           },
132     {"GL_NV_texgen_reflection",             NV_TEXGEN_REFLECTION,           0                           },
133     {"GL_NV_texture_env_combine4",          NV_TEXTURE_ENV_COMBINE4,        0                           },
134     {"GL_NV_texture_shader",                NV_TEXTURE_SHADER,              0                           },
135     {"GL_NV_texture_shader2",               NV_TEXTURE_SHADER2,             0                           },
136     {"GL_NV_texture_shader3",               NV_TEXTURE_SHADER3,             0                           },
137     {"GL_NV_occlusion_query",               NV_OCCLUSION_QUERY,             0                           },
138     {"GL_NV_vertex_program",                NV_VERTEX_PROGRAM,              0                           },
139     {"GL_NV_vertex_program1_1",             NV_VERTEX_PROGRAM1_1,           0                           },
140     {"GL_NV_vertex_program2",               NV_VERTEX_PROGRAM2,             0                           },
141     {"GL_NV_vertex_program3",               NV_VERTEX_PROGRAM3,             0                           },
142     {"GL_NV_depth_clamp",                   NV_DEPTH_CLAMP,                 0                           },
143     {"GL_NV_light_max_exponent",            NV_LIGHT_MAX_EXPONENT,          0                           },
144
145     /* SGI */
146     {"GL_SGIS_generate_mipmap",             SGIS_GENERATE_MIPMAP,           0                           },
147 };
148
149 /**********************************************************
150  * Utility functions follow
151  **********************************************************/
152
153 static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType, WINED3DFORMAT AdapterFormat, DWORD Usage, WINED3DRESOURCETYPE RType, WINED3DFORMAT CheckFormat, WINED3DSURFTYPE SurfaceType);
154 static const struct fragment_pipeline *select_fragment_implementation(struct WineD3DAdapter *adapter,
155         WINED3DDEVTYPE DeviceType);
156 static const shader_backend_t *select_shader_backend(struct WineD3DAdapter *adapter, WINED3DDEVTYPE DeviceType);
157 static const struct blit_shader *select_blit_implementation(struct WineD3DAdapter *adapter, WINED3DDEVTYPE DeviceType);
158
159 /* lookup tables */
160 const int minLookup[MAX_LOOKUPS] =
161 {
162     WINED3DTADDRESS_WRAP, /* WINELOOKUP_WARPPARAM */
163 };
164
165 const int maxLookup[MAX_LOOKUPS] =
166 {
167     WINED3DTADDRESS_MIRRORONCE, /* WINELOOKUP_WARPPARAM */
168 };
169
170 DWORD *stateLookup[MAX_LOOKUPS];
171
172 struct min_lookup minMipLookup[WINED3DTEXF_ANISOTROPIC + 1];
173 const struct min_lookup minMipLookup_noFilter[WINED3DTEXF_ANISOTROPIC + 1] =
174 {
175     {{GL_NEAREST, GL_NEAREST, GL_NEAREST}},
176     {{GL_NEAREST, GL_NEAREST, GL_NEAREST}},
177     {{GL_NEAREST, GL_NEAREST, GL_NEAREST}},
178     {{GL_NEAREST, GL_NEAREST, GL_NEAREST}},
179 };
180
181 GLenum magLookup[WINED3DTEXF_ANISOTROPIC + 1];
182 const GLenum magLookup_noFilter[WINED3DTEXF_ANISOTROPIC + 1] =
183 {
184     GL_NEAREST, GL_NEAREST, GL_NEAREST, GL_NEAREST
185 };
186
187 /* drawStridedSlow attributes */
188 glAttribFunc position_funcs[WINED3DDECLTYPE_UNUSED];
189 glAttribFunc diffuse_funcs[WINED3DDECLTYPE_UNUSED];
190 glAttribFunc specular_func_3ubv;
191 glAttribFunc specular_funcs[WINED3DDECLTYPE_UNUSED];
192 glAttribFunc normal_funcs[WINED3DDECLTYPE_UNUSED];
193 glMultiTexCoordFunc multi_texcoord_funcs[WINED3DDECLTYPE_UNUSED];
194
195 /**
196  * Note: GL seems to trap if GetDeviceCaps is called before any HWND's created,
197  * i.e., there is no GL Context - Get a default rendering context to enable the
198  * function query some info from GL.
199  */
200
201 static int             wined3d_fake_gl_context_ref = 0;
202 static BOOL            wined3d_fake_gl_context_foreign;
203 static BOOL            wined3d_fake_gl_context_available = FALSE;
204 static HDC             wined3d_fake_gl_context_hdc = NULL;
205 static HWND            wined3d_fake_gl_context_hwnd = NULL;
206
207 static CRITICAL_SECTION wined3d_fake_gl_context_cs;
208 static CRITICAL_SECTION_DEBUG wined3d_fake_gl_context_cs_debug =
209 {
210     0, 0, &wined3d_fake_gl_context_cs,
211     { &wined3d_fake_gl_context_cs_debug.ProcessLocksList,
212       &wined3d_fake_gl_context_cs_debug.ProcessLocksList },
213     0, 0, { (DWORD_PTR)(__FILE__ ": wined3d_fake_gl_context_cs") }
214 };
215 static CRITICAL_SECTION wined3d_fake_gl_context_cs = { &wined3d_fake_gl_context_cs_debug, -1, 0, 0, 0, 0 };
216
217 static void WineD3D_ReleaseFakeGLContext(void) {
218     HGLRC glCtx;
219
220     EnterCriticalSection(&wined3d_fake_gl_context_cs);
221
222     if(!wined3d_fake_gl_context_available) {
223         TRACE_(d3d_caps)("context not available\n");
224         LeaveCriticalSection(&wined3d_fake_gl_context_cs);
225         return;
226     }
227
228     glCtx = pwglGetCurrentContext();
229
230     TRACE_(d3d_caps)("decrementing ref from %i\n", wined3d_fake_gl_context_ref);
231     if (0 == (--wined3d_fake_gl_context_ref) ) {
232         if(!wined3d_fake_gl_context_foreign && glCtx) {
233             TRACE_(d3d_caps)("destroying fake GL context\n");
234             pwglMakeCurrent(NULL, NULL);
235             pwglDeleteContext(glCtx);
236         }
237         if(wined3d_fake_gl_context_hdc)
238             ReleaseDC(wined3d_fake_gl_context_hwnd, wined3d_fake_gl_context_hdc);
239         wined3d_fake_gl_context_hdc = NULL; /* Make sure we don't think that it is still around */
240         if(wined3d_fake_gl_context_hwnd)
241             DestroyWindow(wined3d_fake_gl_context_hwnd);
242         wined3d_fake_gl_context_hwnd = NULL;
243         wined3d_fake_gl_context_available = FALSE;
244     }
245     assert(wined3d_fake_gl_context_ref >= 0);
246
247     LeaveCriticalSection(&wined3d_fake_gl_context_cs);
248 }
249
250 static BOOL WineD3D_CreateFakeGLContext(void) {
251     HGLRC glCtx = NULL;
252
253     EnterCriticalSection(&wined3d_fake_gl_context_cs);
254
255     TRACE("getting context...\n");
256     if(wined3d_fake_gl_context_ref > 0) goto ret;
257     assert(0 == wined3d_fake_gl_context_ref);
258
259     wined3d_fake_gl_context_foreign = TRUE;
260
261     glCtx = pwglGetCurrentContext();
262     if (!glCtx) {
263         PIXELFORMATDESCRIPTOR pfd;
264         int iPixelFormat;
265
266         wined3d_fake_gl_context_foreign = FALSE;
267
268         /* We need a fake window as a hdc retrieved using GetDC(0) can't be used for much GL purposes */
269         wined3d_fake_gl_context_hwnd = CreateWindowA("WineD3D_OpenGL", "WineD3D fake window", WS_OVERLAPPEDWINDOW,        10, 10, 10, 10, NULL, NULL, NULL, NULL);
270         if(!wined3d_fake_gl_context_hwnd) {
271             ERR("HWND creation failed!\n");
272             goto fail;
273         }
274         wined3d_fake_gl_context_hdc = GetDC(wined3d_fake_gl_context_hwnd);
275         if(!wined3d_fake_gl_context_hdc) {
276             ERR("GetDC failed!\n");
277             goto fail;
278         }
279
280         /* PixelFormat selection */
281         ZeroMemory(&pfd, sizeof(pfd));
282         pfd.nSize      = sizeof(pfd);
283         pfd.nVersion   = 1;
284         pfd.dwFlags    = PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER | PFD_DRAW_TO_WINDOW;/*PFD_GENERIC_ACCELERATED*/
285         pfd.iPixelType = PFD_TYPE_RGBA;
286         pfd.cColorBits = 32;
287         pfd.iLayerType = PFD_MAIN_PLANE;
288
289         iPixelFormat = ChoosePixelFormat(wined3d_fake_gl_context_hdc, &pfd);
290         if(!iPixelFormat) {
291             /* If this happens something is very wrong as ChoosePixelFormat barely fails */
292             ERR("Can't find a suitable iPixelFormat\n");
293             goto fail;
294         }
295         DescribePixelFormat(wined3d_fake_gl_context_hdc, iPixelFormat, sizeof(pfd), &pfd);
296         SetPixelFormat(wined3d_fake_gl_context_hdc, iPixelFormat, &pfd);
297
298         /* Create a GL context */
299         glCtx = pwglCreateContext(wined3d_fake_gl_context_hdc);
300         if (!glCtx) {
301             WARN_(d3d_caps)("Error creating default context for capabilities initialization\n");
302             goto fail;
303         }
304
305         /* Make it the current GL context */
306         if (!pwglMakeCurrent(wined3d_fake_gl_context_hdc, glCtx)) {
307             WARN_(d3d_caps)("Error setting default context as current for capabilities initialization\n");
308             goto fail;
309         }
310     }
311
312   ret:
313     TRACE("incrementing ref from %i\n", wined3d_fake_gl_context_ref);
314     wined3d_fake_gl_context_ref++;
315     wined3d_fake_gl_context_available = TRUE;
316     LeaveCriticalSection(&wined3d_fake_gl_context_cs);
317     return TRUE;
318   fail:
319     if(wined3d_fake_gl_context_hdc)
320         ReleaseDC(wined3d_fake_gl_context_hwnd, wined3d_fake_gl_context_hdc);
321     wined3d_fake_gl_context_hdc = NULL;
322     if(wined3d_fake_gl_context_hwnd)
323         DestroyWindow(wined3d_fake_gl_context_hwnd);
324     wined3d_fake_gl_context_hwnd = NULL;
325     if(glCtx) pwglDeleteContext(glCtx);
326     LeaveCriticalSection(&wined3d_fake_gl_context_cs);
327     return FALSE;
328 }
329
330 /* Adjust the amount of used texture memory */
331 long WineD3DAdapterChangeGLRam(IWineD3DDeviceImpl *D3DDevice, long glram){
332     struct WineD3DAdapter *adapter = D3DDevice->adapter;
333
334     adapter->UsedTextureRam += glram;
335     TRACE("Adjusted gl ram by %ld to %d\n", glram, adapter->UsedTextureRam);
336     return adapter->UsedTextureRam;
337 }
338
339 /**********************************************************
340  * IUnknown parts follows
341  **********************************************************/
342
343 static HRESULT WINAPI IWineD3DImpl_QueryInterface(IWineD3D *iface,REFIID riid,LPVOID *ppobj)
344 {
345     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
346
347     TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppobj);
348     if (IsEqualGUID(riid, &IID_IUnknown)
349         || IsEqualGUID(riid, &IID_IWineD3DBase)
350         || IsEqualGUID(riid, &IID_IWineD3DDevice)) {
351         IUnknown_AddRef(iface);
352         *ppobj = This;
353         return S_OK;
354     }
355     *ppobj = NULL;
356     return E_NOINTERFACE;
357 }
358
359 static ULONG WINAPI IWineD3DImpl_AddRef(IWineD3D *iface) {
360     IWineD3DImpl *This = (IWineD3DImpl *)iface;
361     ULONG refCount = InterlockedIncrement(&This->ref);
362
363     TRACE("(%p) : AddRef increasing from %d\n", This, refCount - 1);
364     return refCount;
365 }
366
367 static ULONG WINAPI IWineD3DImpl_Release(IWineD3D *iface) {
368     IWineD3DImpl *This = (IWineD3DImpl *)iface;
369     ULONG ref;
370     TRACE("(%p) : Releasing from %d\n", This, This->ref);
371     ref = InterlockedDecrement(&This->ref);
372     if (ref == 0) {
373         unsigned int i;
374
375         for (i = 0; i < This->adapter_count; ++i)
376         {
377             HeapFree(GetProcessHeap(), 0, This->adapters[i].cfgs);
378         }
379         HeapFree(GetProcessHeap(), 0, This);
380     }
381
382     return ref;
383 }
384
385 /* Set the shader type for this device, depending on the given capabilities,
386  * the device type, and the user preferences in wined3d_settings */
387
388 static void select_shader_mode(const WineD3D_GL_Info *gl_info, WINED3DDEVTYPE DeviceType, int *ps_selected, int *vs_selected)
389 {
390     if (wined3d_settings.vs_mode == VS_NONE) {
391         *vs_selected = SHADER_NONE;
392     } else if (gl_info->supported[ARB_VERTEX_SHADER] && wined3d_settings.glslRequested) {
393         /* Geforce4 cards support GLSL but for vertex shaders only. Further its reported GLSL caps are
394          * wrong. This combined with the fact that glsl won't offer more features or performance, use ARB
395          * shaders only on this card. */
396         if(gl_info->vs_nv_version && gl_info->vs_nv_version < VS_VERSION_20)
397             *vs_selected = SHADER_ARB;
398         else
399             *vs_selected = SHADER_GLSL;
400     } else if (gl_info->supported[ARB_VERTEX_PROGRAM]) {
401         *vs_selected = SHADER_ARB;
402     } else {
403         *vs_selected = SHADER_NONE;
404     }
405
406     if (wined3d_settings.ps_mode == PS_NONE) {
407         *ps_selected = SHADER_NONE;
408     } else if (gl_info->supported[ARB_FRAGMENT_SHADER] && wined3d_settings.glslRequested) {
409         *ps_selected = SHADER_GLSL;
410     } else if (gl_info->supported[ARB_FRAGMENT_PROGRAM]) {
411         *ps_selected = SHADER_ARB;
412     } else if (gl_info->supported[ATI_FRAGMENT_SHADER]) {
413         *ps_selected = SHADER_ATI;
414     } else {
415         *ps_selected = SHADER_NONE;
416     }
417 }
418
419 /** Select the number of report maximum shader constants based on the selected shader modes */
420 static void select_shader_max_constants(
421     int ps_selected_mode,
422     int vs_selected_mode,
423     WineD3D_GL_Info *gl_info) {
424
425     switch (vs_selected_mode) {
426         case SHADER_GLSL:
427             /* Subtract the other potential uniforms from the max available (bools, ints, and 1 row of projection matrix) */
428             gl_info->max_vshader_constantsF = gl_info->vs_glsl_constantsF - (MAX_CONST_B / 4) - MAX_CONST_I - 1;
429             break;
430         case SHADER_ARB:
431             /* We have to subtract any other PARAMs that we might use in our shader programs.
432              * ATI seems to count 2 implicit PARAMs when we use fog and NVIDIA counts 1,
433              * and we reference one row of the PROJECTION matrix which counts as 1 PARAM. */
434             gl_info->max_vshader_constantsF = gl_info->vs_arb_constantsF - 3;
435             break;
436         default:
437             gl_info->max_vshader_constantsF = 0;
438             break;
439     }
440
441     switch (ps_selected_mode) {
442         case SHADER_GLSL:
443             /* Subtract the other potential uniforms from the max available (bools & ints), and 2 states for fog.
444              * In theory the texbem instruction may need one more shader constant too. But lets assume
445              * that a sm <= 1.3 shader does not need all the uniforms provided by a glsl-capable card,
446              * and lets not take away a uniform needlessly from all other shaders.
447              */
448             gl_info->max_pshader_constantsF = gl_info->ps_glsl_constantsF - (MAX_CONST_B / 4) - MAX_CONST_I - 2;
449             break;
450         case SHADER_ARB:
451             /* The arb shader only loads the bump mapping environment matrix into the shader if it finds
452              * a free constant to do that, so only reduce the number of available constants by 2 for the fog states.
453              */
454             gl_info->max_pshader_constantsF = gl_info->ps_arb_constantsF - 2;
455             break;
456         default:
457             gl_info->max_pshader_constantsF = 0;
458             break;
459     }
460 }
461
462 /**********************************************************
463  * IWineD3D parts follows
464  **********************************************************/
465
466 static inline BOOL test_arb_vs_offset_limit(const WineD3D_GL_Info *gl_info)
467 {
468     GLuint prog;
469     BOOL ret = FALSE;
470     const char *testcode =
471         "!!ARBvp1.0\n"
472         "PARAM C[66] = { program.env[0..65] };\n"
473         "ADDRESS A0;"
474         "PARAM zero = {0.0, 0.0, 0.0, 0.0};\n"
475         "ARL A0.x, zero.x;\n"
476         "MOV result.position, C[A0.x + 65];\n"
477         "END\n";
478
479     while(glGetError());
480     GL_EXTCALL(glGenProgramsARB(1, &prog));
481     if(!prog) {
482         ERR("Failed to create an ARB offset limit test program\n");
483     }
484     GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, prog));
485     GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
486                                   strlen(testcode), testcode));
487     if(glGetError() != 0) {
488         TRACE("OpenGL implementation does not allow indirect addressing offsets > 63\n");
489         TRACE("error: %s\n", debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
490         ret = TRUE;
491     } else TRACE("OpenGL implementation allows offsets > 63\n");
492
493     GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, 0));
494     GL_EXTCALL(glDeleteProgramsARB(1, &prog));
495     checkGLcall("ARB vp offset limit test cleanup\n");
496
497     return ret;
498 }
499
500 static DWORD ver_for_ext(GL_SupportedExt ext)
501 {
502     unsigned int i;
503     for (i = 0; i < (sizeof(EXTENSION_MAP) / sizeof(*EXTENSION_MAP)); ++i) {
504         if(EXTENSION_MAP[i].extension == ext) {
505             return EXTENSION_MAP[i].version;
506         }
507     }
508     return 0;
509 }
510
511 static BOOL IWineD3DImpl_FillGLCaps(WineD3D_GL_Info *gl_info) {
512     const char *GL_Extensions    = NULL;
513     const char *WGL_Extensions   = NULL;
514     const char *gl_string        = NULL;
515     const char *gl_string_cursor = NULL;
516     GLint       gl_max;
517     GLfloat     gl_floatv[2];
518     int         major = 1, minor = 0;
519     BOOL        return_value = TRUE;
520     unsigned    i;
521     HDC         hdc;
522     unsigned int vidmem=0;
523
524     TRACE_(d3d_caps)("(%p)\n", gl_info);
525
526     ENTER_GL();
527
528     gl_string = (const char *) glGetString(GL_RENDERER);
529     if (!gl_string) gl_string = "None";
530     strcpy(gl_info->gl_renderer, gl_string);
531
532     gl_string = (const char *) glGetString(GL_VENDOR);
533     TRACE_(d3d_caps)("Filling vendor string %s\n", gl_string);
534     if (gl_string != NULL) {
535         /* Fill in the GL vendor */
536         if (strstr(gl_string, "NVIDIA")) {
537             gl_info->gl_vendor = VENDOR_NVIDIA;
538         } else if (strstr(gl_string, "ATI")) {
539             gl_info->gl_vendor = VENDOR_ATI;
540         } else if (strstr(gl_string, "Intel(R)") ||
541                    strstr(gl_info->gl_renderer, "Intel(R)") ||
542                    strstr(gl_string, "Intel Inc.")) {
543             gl_info->gl_vendor = VENDOR_INTEL;
544         } else if (strstr(gl_string, "Mesa")) {
545             gl_info->gl_vendor = VENDOR_MESA;
546         } else {
547             gl_info->gl_vendor = VENDOR_WINE;
548         }
549     } else {
550         gl_info->gl_vendor = VENDOR_WINE;
551     }
552
553
554     TRACE_(d3d_caps)("found GL_VENDOR (%s)->(0x%04x)\n", debugstr_a(gl_string), gl_info->gl_vendor);
555
556     /* Parse the GL_VERSION field into major and minor information */
557     gl_string = (const char *) glGetString(GL_VERSION);
558     if (gl_string != NULL) {
559
560         /* First, parse the generic opengl version. This is supposed not to be convoluted with
561          * driver specific information
562          */
563         gl_string_cursor = gl_string;
564         major = atoi(gl_string_cursor);
565         if(major <= 0) {
566             ERR("Invalid opengl major version: %d\n", major);
567         }
568         while (*gl_string_cursor <= '9' && *gl_string_cursor >= '0') {
569             ++gl_string_cursor;
570         }
571         if (*gl_string_cursor++ != '.') {
572             ERR_(d3d_caps)("Invalid opengl version string: %s\n", debugstr_a(gl_string));
573         }
574         minor = atoi(gl_string_cursor);
575         TRACE_(d3d_caps)("Found OpenGL version: %d.%d\n", major, minor);
576         gl_info->gl_version = MAKEDWORD_VERSION(major, minor);
577
578         /* Now parse the driver specific string which we'll report to the app */
579         switch (gl_info->gl_vendor) {
580         case VENDOR_NVIDIA:
581             gl_string_cursor = strstr(gl_string, "NVIDIA");
582             if (!gl_string_cursor) {
583                 ERR_(d3d_caps)("Invalid nVidia version string: %s\n", debugstr_a(gl_string));
584                 break;
585             }
586
587             gl_string_cursor = strstr(gl_string_cursor, " ");
588             if (!gl_string_cursor) {
589                 ERR_(d3d_caps)("Invalid nVidia version string: %s\n", debugstr_a(gl_string));
590                 break;
591             }
592
593             while (*gl_string_cursor == ' ') {
594                 ++gl_string_cursor;
595             }
596
597             if (!*gl_string_cursor) {
598                 ERR_(d3d_caps)("Invalid nVidia version string: %s\n", debugstr_a(gl_string));
599                 break;
600             }
601
602             major = atoi(gl_string_cursor);
603             while (*gl_string_cursor <= '9' && *gl_string_cursor >= '0') {
604                 ++gl_string_cursor;
605             }
606
607             if (*gl_string_cursor++ != '.') {
608                 ERR_(d3d_caps)("Invalid nVidia version string: %s\n", debugstr_a(gl_string));
609                 break;
610             }
611
612             minor = atoi(gl_string_cursor);
613             minor = major*100+minor;
614             major = 10;
615
616             break;
617
618         case VENDOR_ATI:
619             major = minor = 0;
620             gl_string_cursor = strchr(gl_string, '-');
621             if (gl_string_cursor) {
622                 int error = 0;
623                 gl_string_cursor++;
624
625                 /* Check if version number is of the form x.y.z */
626                 if (*gl_string_cursor > '9' && *gl_string_cursor < '0')
627                     error = 1;
628                 if (!error && *(gl_string_cursor+2) > '9' && *(gl_string_cursor+2) < '0')
629                     error = 1;
630                 if (!error && *(gl_string_cursor+4) > '9' && *(gl_string_cursor+4) < '0')
631                     error = 1;
632                 if (!error && *(gl_string_cursor+1) != '.' && *(gl_string_cursor+3) != '.')
633                     error = 1;
634
635                 /* Mark version number as malformed */
636                 if (error)
637                     gl_string_cursor = 0;
638             }
639
640             if (!gl_string_cursor)
641                 WARN_(d3d_caps)("malformed GL_VERSION (%s)\n", debugstr_a(gl_string));
642             else {
643                 major = *gl_string_cursor - '0';
644                 minor = (*(gl_string_cursor+2) - '0') * 256 + (*(gl_string_cursor+4) - '0');
645             }
646             break;
647
648         case VENDOR_INTEL:
649             /* Apple and Mesa version strings look differently, but both provide intel drivers */
650             if(strstr(gl_string, "APPLE")) {
651                 /* [0-9]+.[0-9]+ APPLE-[0-9]+.[0.9]+.[0.9]+
652                  * We only need the first part, and use the APPLE as identification
653                  * "1.2 APPLE-1.4.56"
654                  */
655                 gl_string_cursor = gl_string;
656                 major = atoi(gl_string_cursor);
657                 while (*gl_string_cursor <= '9' && *gl_string_cursor >= '0') {
658                     ++gl_string_cursor;
659                 }
660
661                 if (*gl_string_cursor++ != '.') {
662                     ERR_(d3d_caps)("Invalid MacOS-Intel version string: %s\n", debugstr_a(gl_string));
663                     break;
664                 }
665
666                 minor = atoi(gl_string_cursor);
667                 break;
668             }
669
670         case VENDOR_MESA:
671             gl_string_cursor = strstr(gl_string, "Mesa");
672             gl_string_cursor = strstr(gl_string_cursor, " ");
673             while (*gl_string_cursor && ' ' == *gl_string_cursor) ++gl_string_cursor;
674             if (*gl_string_cursor) {
675                 char tmp[16];
676                 int cursor = 0;
677
678                 while (*gl_string_cursor <= '9' && *gl_string_cursor >= '0') {
679                     tmp[cursor++] = *gl_string_cursor;
680                     ++gl_string_cursor;
681                 }
682                 tmp[cursor] = 0;
683                 major = atoi(tmp);
684
685                 if (*gl_string_cursor != '.') WARN_(d3d_caps)("malformed GL_VERSION (%s)\n", debugstr_a(gl_string));
686                 ++gl_string_cursor;
687
688                 cursor = 0;
689                 while (*gl_string_cursor <= '9' && *gl_string_cursor >= '0') {
690                     tmp[cursor++] = *gl_string_cursor;
691                     ++gl_string_cursor;
692                 }
693                 tmp[cursor] = 0;
694                 minor = atoi(tmp);
695             }
696             break;
697
698         default:
699             major = 0;
700             minor = 9;
701         }
702         gl_info->driver_version = MAKEDWORD_VERSION(major, minor);
703         TRACE_(d3d_caps)("found driver version (%s)->%i.%i->(0x%08x)\n", debugstr_a(gl_string), major, minor, gl_info->driver_version);
704         /* Current Windows drivers have versions like 6.14.... (some older have an earlier version) */
705         gl_info->driver_version_hipart = MAKEDWORD_VERSION(6, 14);
706     } else {
707         FIXME("OpenGL driver did not return version information\n");
708         gl_info->driver_version = MAKEDWORD_VERSION(0, 0);
709         gl_info->driver_version_hipart = MAKEDWORD_VERSION(6, 14);
710     }
711
712     TRACE_(d3d_caps)("found GL_RENDERER (%s)->(0x%04x)\n", debugstr_a(gl_info->gl_renderer), gl_info->gl_card);
713
714     /*
715      * Initialize openGL extension related variables
716      *  with Default values
717      */
718     memset(gl_info->supported, 0, sizeof(gl_info->supported));
719     gl_info->max_buffers        = 1;
720     gl_info->max_textures       = 1;
721     gl_info->max_texture_stages = 1;
722     gl_info->max_fragment_samplers = 1;
723     gl_info->max_vertex_samplers = 0;
724     gl_info->max_combined_samplers = gl_info->max_fragment_samplers + gl_info->max_vertex_samplers;
725     gl_info->max_sampler_stages = 1;
726     gl_info->ps_arb_version = PS_VERSION_NOT_SUPPORTED;
727     gl_info->ps_arb_max_temps = 0;
728     gl_info->ps_arb_max_instructions = 0;
729     gl_info->vs_arb_version = VS_VERSION_NOT_SUPPORTED;
730     gl_info->vs_arb_max_temps = 0;
731     gl_info->vs_arb_max_instructions = 0;
732     gl_info->vs_nv_version  = VS_VERSION_NOT_SUPPORTED;
733     gl_info->vs_ati_version = VS_VERSION_NOT_SUPPORTED;
734     gl_info->vs_glsl_constantsF = 0;
735     gl_info->ps_glsl_constantsF = 0;
736     gl_info->vs_arb_constantsF = 0;
737     gl_info->ps_arb_constantsF = 0;
738
739     /* Retrieve opengl defaults */
740     glGetIntegerv(GL_MAX_CLIP_PLANES, &gl_max);
741     gl_info->max_clipplanes = min(WINED3DMAXUSERCLIPPLANES, gl_max);
742     TRACE_(d3d_caps)("ClipPlanes support - num Planes=%d\n", gl_max);
743
744     glGetIntegerv(GL_MAX_LIGHTS, &gl_max);
745     gl_info->max_lights = gl_max;
746     TRACE_(d3d_caps)("Lights support - max lights=%d\n", gl_max);
747
748     glGetIntegerv(GL_MAX_TEXTURE_SIZE, &gl_max);
749     gl_info->max_texture_size = gl_max;
750     TRACE_(d3d_caps)("Maximum texture size support - max texture size=%d\n", gl_max);
751
752     glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, gl_floatv);
753     gl_info->max_pointsizemin = gl_floatv[0];
754     gl_info->max_pointsize = gl_floatv[1];
755     TRACE_(d3d_caps)("Maximum point size support - max point size=%f\n", gl_floatv[1]);
756
757     /* Parse the gl supported features, in theory enabling parts of our code appropriately */
758     GL_Extensions = (const char *) glGetString(GL_EXTENSIONS);
759     TRACE_(d3d_caps)("GL_Extensions reported:\n");
760
761     if (NULL == GL_Extensions) {
762         ERR("   GL_Extensions returns NULL\n");
763     } else {
764         while (*GL_Extensions != 0x00) {
765             const char *Start;
766             char        ThisExtn[256];
767             size_t      len;
768
769             while (isspace(*GL_Extensions)) GL_Extensions++;
770             Start = GL_Extensions;
771             while (!isspace(*GL_Extensions) && *GL_Extensions != 0x00) {
772                 GL_Extensions++;
773             }
774
775             len = GL_Extensions - Start;
776             if (len == 0 || len >= sizeof(ThisExtn))
777                 continue;
778
779             memcpy(ThisExtn, Start, len);
780             ThisExtn[len] = '\0';
781             TRACE_(d3d_caps)("- %s\n", ThisExtn);
782
783             for (i = 0; i < (sizeof(EXTENSION_MAP) / sizeof(*EXTENSION_MAP)); ++i) {
784                 if (!strcmp(ThisExtn, EXTENSION_MAP[i].extension_string)) {
785                     TRACE_(d3d_caps)(" FOUND: %s support\n", EXTENSION_MAP[i].extension_string);
786                     gl_info->supported[EXTENSION_MAP[i].extension] = TRUE;
787                     break;
788                 }
789             }
790         }
791
792         LEAVE_GL();
793
794         /* Now work out what GL support this card really has */
795 #define USE_GL_FUNC(type, pfn, ext, replace) { \
796             DWORD ver = ver_for_ext(ext); \
797             if(gl_info->supported[ext]) gl_info->pfn = (type) pwglGetProcAddress(#pfn); \
798             else if(ver && ver <= gl_info->gl_version) gl_info->pfn = (type) pwglGetProcAddress(#replace); \
799             else gl_info->pfn = NULL; \
800         }
801         GL_EXT_FUNCS_GEN;
802 #undef USE_GL_FUNC
803
804 #define USE_GL_FUNC(type, pfn, ext, replace) gl_info->pfn = (type) pwglGetProcAddress(#pfn);
805         WGL_EXT_FUNCS_GEN;
806 #undef USE_GL_FUNC
807
808         ENTER_GL();
809         /* Now mark all the extensions supported which are included in the opengl core version. Do this *after*
810          * loading the functions, otherwise the code above will load the extension entry points instead of the
811          * core functions, which may not work
812          */
813         for (i = 0; i < (sizeof(EXTENSION_MAP) / sizeof(*EXTENSION_MAP)); ++i) {
814             if (gl_info->supported[EXTENSION_MAP[i].extension] == FALSE &&
815                 EXTENSION_MAP[i].version <= gl_info->gl_version && EXTENSION_MAP[i].version) {
816                 TRACE_(d3d_caps)(" GL CORE: %s support\n", EXTENSION_MAP[i].extension_string);
817                 gl_info->supported[EXTENSION_MAP[i].extension] = TRUE;
818             }
819         }
820
821         if (gl_info->supported[APPLE_FENCE]) {
822             /* GL_NV_fence and GL_APPLE_fence provide the same functionality basically.
823              * The apple extension interacts with some other apple exts. Disable the NV
824              * extension if the apple one is support to prevent confusion in other parts
825              * of the code
826              */
827             gl_info->supported[NV_FENCE] = FALSE;
828         }
829         if (gl_info->supported[APPLE_FLOAT_PIXELS]) {
830             /* GL_APPLE_float_pixels == GL_ARB_texture_float + GL_ARB_half_float_pixel
831              *
832              * The enums are the same:
833              * GL_RGBA16F_ARB     = GL_RGBA_FLOAT16_APPLE = 0x881A
834              * GL_RGB16F_ARB      = GL_RGB_FLOAT16_APPLE  = 0x881B
835              * GL_RGBA32F_ARB     = GL_RGBA_FLOAT32_APPLE = 0x8814
836              * GL_RGB32F_ARB      = GL_RGB_FLOAT32_APPLE  = 0x8815
837              * GL_HALF_FLOAT_ARB  = GL_HALF_APPLE         =  0x140B
838              */
839             if(!gl_info->supported[ARB_TEXTURE_FLOAT]) {
840                 TRACE_(d3d_caps)(" IMPLIED: GL_ARB_texture_float support(from GL_APPLE_float_pixels\n");
841                 gl_info->supported[ARB_TEXTURE_FLOAT] = TRUE;
842             }
843             if(!gl_info->supported[ARB_HALF_FLOAT_PIXEL]) {
844                 TRACE_(d3d_caps)(" IMPLIED: GL_ARB_half_float_pixel support(from GL_APPLE_float_pixels\n");
845                 gl_info->supported[ARB_HALF_FLOAT_PIXEL] = TRUE;
846             }
847         }
848         if (gl_info->supported[ARB_TEXTURE_CUBE_MAP]) {
849             TRACE_(d3d_caps)(" IMPLIED: NVIDIA (NV) Texture Gen Reflection support\n");
850             gl_info->supported[NV_TEXGEN_REFLECTION] = TRUE;
851         }
852         if (gl_info->supported[NV_TEXTURE_SHADER2]) {
853             if(gl_info->supported[NV_REGISTER_COMBINERS]) {
854                 /* Also disable ATI_FRAGMENT_SHADER if register combiners and texture_shader2
855                  * are supported. The nv extensions provide the same functionality as the
856                  * ATI one, and a bit more(signed pixelformats)
857                  */
858                 gl_info->supported[ATI_FRAGMENT_SHADER] = FALSE;
859             }
860         }
861         if (gl_info->supported[ARB_DRAW_BUFFERS]) {
862             glGetIntegerv(GL_MAX_DRAW_BUFFERS_ARB, &gl_max);
863             gl_info->max_buffers = gl_max;
864             TRACE_(d3d_caps)("Max draw buffers: %u\n", gl_max);
865         }
866         if (gl_info->supported[ARB_MULTITEXTURE]) {
867             glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &gl_max);
868             gl_info->max_textures = min(MAX_TEXTURES, gl_max);
869             TRACE_(d3d_caps)("Max textures: %d\n", gl_info->max_textures);
870
871             if (gl_info->supported[NV_REGISTER_COMBINERS]) {
872                 GLint tmp;
873                 glGetIntegerv(GL_MAX_GENERAL_COMBINERS_NV, &tmp);
874                 gl_info->max_texture_stages = min(MAX_TEXTURES, tmp);
875             } else {
876                 gl_info->max_texture_stages = min(MAX_TEXTURES, gl_max);
877             }
878             TRACE_(d3d_caps)("Max texture stages: %d\n", gl_info->max_texture_stages);
879
880             if (gl_info->supported[ARB_FRAGMENT_PROGRAM]) {
881                 GLint tmp;
882                 glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS_ARB, &tmp);
883                 gl_info->max_fragment_samplers = min(MAX_FRAGMENT_SAMPLERS, tmp);
884             } else {
885                 gl_info->max_fragment_samplers = max(gl_info->max_fragment_samplers, gl_max);
886             }
887             TRACE_(d3d_caps)("Max fragment samplers: %d\n", gl_info->max_fragment_samplers);
888
889             if (gl_info->supported[ARB_VERTEX_SHADER]) {
890                 GLint tmp;
891                 glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB, &tmp);
892                 gl_info->max_vertex_samplers = tmp;
893                 glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB, &tmp);
894                 gl_info->max_combined_samplers = tmp;
895
896                 /* Loading GLSL sampler uniforms is much simpler if we can assume that the sampler setup
897                  * is known at shader link time. In a vertex shader + pixel shader combination this isn't
898                  * an issue because then the sampler setup only depends on the two shaders. If a pixel
899                  * shader is used with fixed function vertex processing we're fine too because fixed function
900                  * vertex processing doesn't use any samplers. If fixed function fragment processing is
901                  * used we have to make sure that all vertex sampler setups are valid together with all
902                  * possible fixed function fragment processing setups. This is true if vsamplers + MAX_TEXTURES
903                  * <= max_samplers. This is true on all d3d9 cards that support vtf(gf 6 and gf7 cards).
904                  * dx9 radeon cards do not support vertex texture fetch. DX10 cards have 128 samplers, and
905                  * dx9 is limited to 8 fixed function texture stages and 4 vertex samplers. DX10 does not have
906                  * a fixed function pipeline anymore.
907                  *
908                  * So this is just a check to check that our assumption holds true. If not, write a warning
909                  * and reduce the number of vertex samplers or probably disable vertex texture fetch.
910                  */
911                 if(gl_info->max_vertex_samplers &&
912                    MAX_TEXTURES + gl_info->max_vertex_samplers > gl_info->max_combined_samplers) {
913                     FIXME("OpenGL implementation supports %u vertex samplers and %u total samplers\n",
914                           gl_info->max_vertex_samplers, gl_info->max_combined_samplers);
915                     FIXME("Expected vertex samplers + MAX_TEXTURES(=8) > combined_samplers\n");
916                     if( gl_info->max_combined_samplers > MAX_TEXTURES )
917                         gl_info->max_vertex_samplers =
918                             gl_info->max_combined_samplers - MAX_TEXTURES;
919                     else
920                         gl_info->max_vertex_samplers = 0;
921                 }
922             } else {
923                 gl_info->max_combined_samplers = gl_info->max_fragment_samplers;
924             }
925             TRACE_(d3d_caps)("Max vertex samplers: %u\n", gl_info->max_vertex_samplers);
926             TRACE_(d3d_caps)("Max combined samplers: %u\n", gl_info->max_combined_samplers);
927         }
928         if (gl_info->supported[ARB_VERTEX_BLEND]) {
929             glGetIntegerv(GL_MAX_VERTEX_UNITS_ARB, &gl_max);
930             gl_info->max_blends = gl_max;
931             TRACE_(d3d_caps)("Max blends: %u\n", gl_info->max_blends);
932         }
933         if (gl_info->supported[EXT_TEXTURE3D]) {
934             glGetIntegerv(GL_MAX_3D_TEXTURE_SIZE_EXT, &gl_max);
935             gl_info->max_texture3d_size = gl_max;
936             TRACE_(d3d_caps)("Max texture3D size: %d\n", gl_info->max_texture3d_size);
937         }
938         if (gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC]) {
939             glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &gl_max);
940             gl_info->max_anisotropy = gl_max;
941             TRACE_(d3d_caps)("Max anisotropy: %d\n", gl_info->max_anisotropy);
942         }
943         if (gl_info->supported[ARB_FRAGMENT_PROGRAM]) {
944             gl_info->ps_arb_version = PS_VERSION_11;
945             GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max));
946             gl_info->ps_arb_constantsF = gl_max;
947             TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM float constants: %d\n", gl_info->ps_arb_constantsF);
948             GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, &gl_max));
949             gl_info->ps_arb_max_temps = gl_max;
950             TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM native temporaries: %d\n", gl_info->ps_arb_max_temps);
951             GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, &gl_max));
952             gl_info->ps_arb_max_instructions = gl_max;
953             TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM native instructions: %d\n", gl_info->ps_arb_max_instructions);
954         }
955         if (gl_info->supported[ARB_VERTEX_PROGRAM]) {
956             gl_info->vs_arb_version = VS_VERSION_11;
957             GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max));
958             gl_info->vs_arb_constantsF = gl_max;
959             TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM float constants: %d\n", gl_info->vs_arb_constantsF);
960             GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, &gl_max));
961             gl_info->vs_arb_max_temps = gl_max;
962             TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM native temporaries: %d\n", gl_info->vs_arb_max_temps);
963             GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, &gl_max));
964             gl_info->vs_arb_max_instructions = gl_max;
965             TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM native instructions: %d\n", gl_info->vs_arb_max_instructions);
966
967             gl_info->arb_vs_offset_limit = test_arb_vs_offset_limit(gl_info);
968         }
969         if (gl_info->supported[ARB_VERTEX_SHADER]) {
970             glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB, &gl_max);
971             gl_info->vs_glsl_constantsF = gl_max / 4;
972             TRACE_(d3d_caps)("Max ARB_VERTEX_SHADER float constants: %u\n", gl_info->vs_glsl_constantsF);
973         }
974         if (gl_info->supported[ARB_FRAGMENT_SHADER]) {
975             glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB, &gl_max);
976             gl_info->ps_glsl_constantsF = gl_max / 4;
977             TRACE_(d3d_caps)("Max ARB_FRAGMENT_SHADER float constants: %u\n", gl_info->ps_glsl_constantsF);
978             glGetIntegerv(GL_MAX_VARYING_FLOATS_ARB, &gl_max);
979             gl_info->max_glsl_varyings = gl_max;
980             TRACE_(d3d_caps)("Max GLSL varyings: %u (%u 4 component varyings)\n", gl_max, gl_max / 4);
981         }
982         if (gl_info->supported[EXT_VERTEX_SHADER]) {
983             gl_info->vs_ati_version = VS_VERSION_11;
984         }
985         if (gl_info->supported[NV_VERTEX_PROGRAM3]) {
986             gl_info->vs_nv_version = VS_VERSION_30;
987         } else if (gl_info->supported[NV_VERTEX_PROGRAM2]) {
988             gl_info->vs_nv_version = VS_VERSION_20;
989         } else if (gl_info->supported[NV_VERTEX_PROGRAM1_1]) {
990             gl_info->vs_nv_version = VS_VERSION_11;
991         } else if (gl_info->supported[NV_VERTEX_PROGRAM]) {
992             gl_info->vs_nv_version = VS_VERSION_10;
993         }
994         if (gl_info->supported[NV_FRAGMENT_PROGRAM2]) {
995             gl_info->ps_nv_version = PS_VERSION_30;
996         } else if (gl_info->supported[NV_FRAGMENT_PROGRAM]) {
997             gl_info->ps_nv_version = PS_VERSION_20;
998         }
999         if (gl_info->supported[NV_LIGHT_MAX_EXPONENT]) {
1000             glGetFloatv(GL_MAX_SHININESS_NV, &gl_info->max_shininess);
1001         } else {
1002             gl_info->max_shininess = 128.0;
1003         }
1004         if (gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO]) {
1005             /* If we have full NP2 texture support, disable GL_ARB_texture_rectangle because we will never use it.
1006              * This saves a few redundant glDisable calls
1007              */
1008             gl_info->supported[ARB_TEXTURE_RECTANGLE] = FALSE;
1009         }
1010         if(gl_info->supported[ATI_FRAGMENT_SHADER]) {
1011             /* Disable NV_register_combiners and fragment shader if this is supported.
1012              * generally the NV extensions are preferred over the ATI ones, and this
1013              * extension is disabled if register_combiners and texture_shader2 are both
1014              * supported. So we reach this place only if we have incomplete NV dxlevel 8
1015              * fragment processing support
1016              */
1017             gl_info->supported[NV_REGISTER_COMBINERS] = FALSE;
1018             gl_info->supported[NV_REGISTER_COMBINERS2] = FALSE;
1019             gl_info->supported[NV_TEXTURE_SHADER] = FALSE;
1020             gl_info->supported[NV_TEXTURE_SHADER2] = FALSE;
1021             gl_info->supported[NV_TEXTURE_SHADER3] = FALSE;
1022         }
1023
1024     }
1025     checkGLcall("extension detection\n");
1026
1027     /* In some cases the number of texture stages can be larger than the number
1028      * of samplers. The GF4 for example can use only 2 samplers (no fragment
1029      * shaders), but 8 texture stages (register combiners). */
1030     gl_info->max_sampler_stages = max(gl_info->max_fragment_samplers, gl_info->max_texture_stages);
1031
1032     /* We can only use ORM_FBO when the hardware supports it. */
1033     if (wined3d_settings.offscreen_rendering_mode == ORM_FBO && !gl_info->supported[EXT_FRAMEBUFFER_OBJECT]) {
1034         WARN_(d3d_caps)("GL_EXT_framebuffer_object not supported, falling back to PBuffer offscreen rendering mode.\n");
1035         wined3d_settings.offscreen_rendering_mode = ORM_PBUFFER;
1036     }
1037
1038     /* MRTs are currently only supported when FBOs are used. */
1039     if (wined3d_settings.offscreen_rendering_mode != ORM_FBO) {
1040         gl_info->max_buffers = 1;
1041     }
1042
1043     /* Below is a list of Nvidia and ATI GPUs. Both vendors have dozens of different GPUs with roughly the same
1044      * features. In most cases GPUs from a certain family differ in clockspeeds, the amount of video memory and
1045      * in case of the latest videocards in the number of pixel/vertex pipelines.
1046      *
1047      * A Direct3D device object contains the PCI id (vendor + device) of the videocard which is used for
1048      * rendering. Various games use this information to get a rough estimation of the features of the card
1049      * and some might use it for enabling 3d effects only on certain types of videocards. In some cases
1050      * games might even use it to work around bugs which happen on certain videocards/driver combinations.
1051      * The problem is that OpenGL only exposes a rendering string containing the name of the videocard and
1052      * not the PCI id.
1053      *
1054      * Various games depend on the PCI id, so somehow we need to provide one. A simple option is to parse
1055      * the renderer string and translate this to the right PCI id. This is a lot of work because there are more
1056      * than 200 GPUs just for Nvidia. Various cards share the same renderer string, so the amount of code might
1057      * be 'small' but there are quite a number of exceptions which would make this a pain to maintain.
1058      * Another way would be to query the PCI id from the operating system (assuming this is the videocard which
1059      * is used for rendering which is not always the case). This would work but it is not very portable. Second
1060      * it would not work well in, let's say, a remote X situation in which the amount of 3d features which can be used
1061      * is limited.
1062      *
1063      * As said most games only use the PCI id to get an indication of the capabilities of the card.
1064      * It doesn't really matter if the given id is the correct one if we return the id of a card with
1065      * similar 3d features.
1066      *
1067      * The code below checks the OpenGL capabilities of a videocard and matches that to a certain level of
1068      * Direct3D functionality. Once a card passes the Direct3D9 check, we know that the card (in case of Nvidia)
1069      * is at least a GeforceFX. To give a better estimate we do a basic check on the renderer string but if that
1070      * won't pass we return a default card. This way is better than maintaining a full card database as even
1071      * without a full database we can return a card with similar features. Second the size of the database
1072      * can be made quite small because when you know what type of 3d functionality a card has, you know to which
1073      * GPU family the GPU must belong. Because of this you only have to check a small part of the renderer string
1074      * to distinguishes between different models from that family.
1075      *
1076      * The code also selects a default amount of video memory which we will use for an estimation of the amount
1077      * of free texture memory. In case of real D3D the amount of texture memory includes video memory and system
1078      * memory (to be specific AGP memory or in case of PCIE TurboCache/HyperMemory). We don't know how much
1079      * system memory can be addressed by the system but we can make a reasonable estimation about the amount of
1080      * video memory. If the value is slightly wrong it doesn't matter as we didn't include AGP-like memory which
1081      * makes the amount of addressable memory higher and second OpenGL isn't that critical it moves to system
1082      * memory behind our backs if really needed.
1083      * Note that the amount of video memory can be overruled using a registry setting.
1084      */
1085     switch (gl_info->gl_vendor) {
1086         case VENDOR_NVIDIA:
1087             /* Both the GeforceFX, 6xxx and 7xxx series support D3D9. The last two types have more
1088              * shader capabilities, so we use the shader capabilities to distinguish between FX and 6xxx/7xxx.
1089              */
1090             if(WINE_D3D9_CAPABLE(gl_info) && (gl_info->vs_nv_version == VS_VERSION_30)) {
1091                 /* Geforce GTX - highend */
1092                 if(strstr(gl_info->gl_renderer, "GTX 280")) {
1093                     gl_info->gl_card = CARD_NVIDIA_GEFORCE_GTX280;
1094                     vidmem = 1024;
1095                 }
1096                 /* Geforce9 - highend */
1097                 else if(strstr(gl_info->gl_renderer, "9800")) {
1098                     gl_info->gl_card = CARD_NVIDIA_GEFORCE_9800GT;
1099                     vidmem = 512;
1100                 }
1101                 /* Geforce9 - midend */
1102                 else if(strstr(gl_info->gl_renderer, "9600")) {
1103                     gl_info->gl_card = CARD_NVIDIA_GEFORCE_9600GT;
1104                     vidmem = 384; /* The 9600GSO has 384MB, the 9600GT has 512-1024MB */
1105                 }
1106                 /* Geforce8 - highend */
1107                 else if (strstr(gl_info->gl_renderer, "8800")) {
1108                     gl_info->gl_card = CARD_NVIDIA_GEFORCE_8800GTS;
1109                     vidmem = 320; /* The 8800GTS uses 320MB, a 8800GTX can have 768MB */
1110                 }
1111                 /* Geforce8 - midend mobile */
1112                 else if(strstr(gl_info->gl_renderer, "8600 M")) {
1113                     gl_info->gl_card = CARD_NVIDIA_GEFORCE_8600MGT;
1114                     vidmem = 512;
1115                 }
1116                 /* Geforce8 - midend */
1117                 else if(strstr(gl_info->gl_renderer, "8600") ||
1118                         strstr(gl_info->gl_renderer, "8700"))
1119                 {
1120                     gl_info->gl_card = CARD_NVIDIA_GEFORCE_8600GT;
1121                     vidmem = 256;
1122                 }
1123                 /* Geforce8 - lowend */
1124                 else if(strstr(gl_info->gl_renderer, "8300") ||
1125                         strstr(gl_info->gl_renderer, "8400") ||
1126                         strstr(gl_info->gl_renderer, "8500"))
1127                 {
1128                     gl_info->gl_card = CARD_NVIDIA_GEFORCE_8300GS;
1129                     vidmem = 128; /* 128-256MB for a 8300, 256-512MB for a 8400 */
1130                 }
1131                 /* Geforce7 - highend */
1132                 else if(strstr(gl_info->gl_renderer, "7800") ||
1133                         strstr(gl_info->gl_renderer, "7900") ||
1134                         strstr(gl_info->gl_renderer, "7950") ||
1135                         strstr(gl_info->gl_renderer, "Quadro FX 4") ||
1136                         strstr(gl_info->gl_renderer, "Quadro FX 5"))
1137                 {
1138                     gl_info->gl_card = CARD_NVIDIA_GEFORCE_7800GT;
1139                     vidmem = 256; /* A 7800GT uses 256MB while highend 7900 cards can use 512MB */
1140                 }
1141                 /* Geforce7 midend */
1142                 else if(strstr(gl_info->gl_renderer, "7600") ||
1143                         strstr(gl_info->gl_renderer, "7700")) {
1144                     gl_info->gl_card = CARD_NVIDIA_GEFORCE_7600;
1145                     vidmem = 256; /* The 7600 uses 256-512MB */
1146                 /* Geforce7 lower medium */
1147                 } else if(strstr(gl_info->gl_renderer, "7400")) {
1148                     gl_info->gl_card = CARD_NVIDIA_GEFORCE_7400;
1149                     vidmem = 256; /* The 7400 uses 256-512MB */
1150                 }
1151                 /* Geforce7 lowend */
1152                 else if(strstr(gl_info->gl_renderer, "7300")) {
1153                     gl_info->gl_card = CARD_NVIDIA_GEFORCE_7300;
1154                     vidmem = 256; /* Mac Pros with this card have 256 MB */
1155                 }
1156                 /* Geforce6 highend */
1157                 else if(strstr(gl_info->gl_renderer, "6800"))
1158                 {
1159                     gl_info->gl_card = CARD_NVIDIA_GEFORCE_6800;
1160                     vidmem = 128; /* The 6800 uses 128-256MB, the 7600 uses 256-512MB */
1161                 }
1162                 /* Geforce6 - midend */
1163                 else if(strstr(gl_info->gl_renderer, "6600") ||
1164                         strstr(gl_info->gl_renderer, "6610") ||
1165                         strstr(gl_info->gl_renderer, "6700"))
1166                 {
1167                     gl_info->gl_card = CARD_NVIDIA_GEFORCE_6600GT;
1168                     vidmem = 128; /* A 6600GT has 128-256MB */
1169                 }
1170                 /* Geforce6/7 lowend */
1171                 else {
1172                     gl_info->gl_card = CARD_NVIDIA_GEFORCE_6200; /* Geforce 6100/6150/6200/7300/7400/7500 */
1173                     vidmem = 64; /* */
1174                 }
1175             } else if(WINE_D3D9_CAPABLE(gl_info)) {
1176                 /* GeforceFX - highend */
1177                 if (strstr(gl_info->gl_renderer, "5800") ||
1178                     strstr(gl_info->gl_renderer, "5900") ||
1179                     strstr(gl_info->gl_renderer, "5950") ||
1180                     strstr(gl_info->gl_renderer, "Quadro FX"))
1181                 {
1182                     gl_info->gl_card = CARD_NVIDIA_GEFORCEFX_5800;
1183                     vidmem = 256; /* 5800-5900 cards use 256MB */
1184                 }
1185                 /* GeforceFX - midend */
1186                 else if(strstr(gl_info->gl_renderer, "5600") ||
1187                         strstr(gl_info->gl_renderer, "5650") ||
1188                         strstr(gl_info->gl_renderer, "5700") ||
1189                         strstr(gl_info->gl_renderer, "5750"))
1190                 {
1191                     gl_info->gl_card = CARD_NVIDIA_GEFORCEFX_5600;
1192                     vidmem = 128; /* A 5600 uses 128-256MB */
1193                 }
1194                 /* GeforceFX - lowend */
1195                 else {
1196                     gl_info->gl_card = CARD_NVIDIA_GEFORCEFX_5200; /* GeforceFX 5100/5200/5250/5300/5500 */
1197                     vidmem = 64; /* Normal FX5200 cards use 64-256MB; laptop (non-standard) can have less */
1198                 }
1199             } else if(WINE_D3D8_CAPABLE(gl_info)) {
1200                 if (strstr(gl_info->gl_renderer, "GeForce4 Ti") || strstr(gl_info->gl_renderer, "Quadro4")) {
1201                     gl_info->gl_card = CARD_NVIDIA_GEFORCE4_TI4200; /* Geforce4 Ti4200/Ti4400/Ti4600/Ti4800, Quadro4 */
1202                     vidmem = 64; /* Geforce4 Ti cards have 64-128MB */
1203                 }
1204                 else {
1205                     gl_info->gl_card = CARD_NVIDIA_GEFORCE3; /* Geforce3 standard/Ti200/Ti500, Quadro DCC */
1206                     vidmem = 64; /* Geforce3 cards have 64-128MB */
1207                 }
1208             } else if(WINE_D3D7_CAPABLE(gl_info)) {
1209                 if (strstr(gl_info->gl_renderer, "GeForce4 MX")) {
1210                     gl_info->gl_card = CARD_NVIDIA_GEFORCE4_MX; /* MX420/MX440/MX460/MX4000 */
1211                     vidmem = 64; /* Most Geforce4MX GPUs have at least 64MB of memory, some early models had 32MB but most have 64MB or even 128MB */
1212                 }
1213                 else if(strstr(gl_info->gl_renderer, "GeForce2 MX") || strstr(gl_info->gl_renderer, "Quadro2 MXR")) {
1214                     gl_info->gl_card = CARD_NVIDIA_GEFORCE2_MX; /* Geforce2 standard/MX100/MX200/MX400, Quadro2 MXR */
1215                     vidmem = 32; /* Geforce2MX GPUs have 32-64MB of video memory */
1216                 }
1217                 else if(strstr(gl_info->gl_renderer, "GeForce2") || strstr(gl_info->gl_renderer, "Quadro2")) {
1218                     gl_info->gl_card = CARD_NVIDIA_GEFORCE2; /* Geforce2 GTS/Pro/Ti/Ultra, Quadro2 */
1219                     vidmem = 32; /* Geforce2 GPUs have 32-64MB of video memory */
1220                 }
1221                 else {
1222                     gl_info->gl_card = CARD_NVIDIA_GEFORCE; /* Geforce 256/DDR, Quadro */
1223                     vidmem = 32; /* Most Geforce1 cards have 32MB, there are also some rare 16 and 64MB (Dell) models */
1224                 }
1225             } else {
1226                 if (strstr(gl_info->gl_renderer, "TNT2")) {
1227                     gl_info->gl_card = CARD_NVIDIA_RIVA_TNT2; /* Riva TNT2 standard/M64/Pro/Ultra */
1228                     vidmem = 32; /* Most TNT2 boards have 32MB, though there are 16MB boards too */
1229                 }
1230                 else {
1231                     gl_info->gl_card = CARD_NVIDIA_RIVA_TNT; /* Riva TNT, Vanta */
1232                     vidmem = 16; /* Most TNT boards have 16MB, some rare models have 8MB */
1233                 }
1234             }
1235             break;
1236         case VENDOR_ATI:
1237             if(WINE_D3D9_CAPABLE(gl_info)) {
1238                 /* Radeon R6xx HD2900/HD3800 - highend */
1239                 if (strstr(gl_info->gl_renderer, "HD 2900") ||
1240                     strstr(gl_info->gl_renderer, "HD 3870") ||
1241                     strstr(gl_info->gl_renderer, "HD 3850"))
1242                 {
1243                     gl_info->gl_card = CARD_ATI_RADEON_HD2900;
1244                     vidmem = 512; /* HD2900/HD3800 uses 256-1024MB */
1245                 }
1246                 /* Radeon R6xx HD2600/HD3600 - midend; HD3830 is China-only midend */
1247                 else if (strstr(gl_info->gl_renderer, "HD 2600") ||
1248                          strstr(gl_info->gl_renderer, "HD 3830") ||
1249                          strstr(gl_info->gl_renderer, "HD 3690") ||
1250                          strstr(gl_info->gl_renderer, "HD 3650"))
1251                 {
1252                     gl_info->gl_card = CARD_ATI_RADEON_HD2600;
1253                     vidmem = 256; /* HD2600/HD3600 uses 256-512MB */
1254                 }
1255                 /* Radeon R6xx HD2300/HD2400/HD3400 - lowend */
1256                 else if (strstr(gl_info->gl_renderer, "HD 2300") ||
1257                          strstr(gl_info->gl_renderer, "HD 2400") ||
1258                          strstr(gl_info->gl_renderer, "HD 3470") ||
1259                          strstr(gl_info->gl_renderer, "HD 3450") ||
1260                          strstr(gl_info->gl_renderer, "HD 3430"))
1261                 {
1262                     gl_info->gl_card = CARD_ATI_RADEON_HD2300;
1263                     vidmem = 128; /* HD2300 uses at least 128MB, HD2400 uses 256MB */
1264                 }
1265                 /* Radeon R6xx/R7xx integrated */
1266                 else if (strstr(gl_info->gl_renderer, "HD 3100") ||
1267                          strstr(gl_info->gl_renderer, "HD 3200") ||
1268                          strstr(gl_info->gl_renderer, "HD 3300"))
1269                 {
1270                     gl_info->gl_card = CARD_ATI_RADEON_HD3200;
1271                     vidmem = 128; /* 128MB */
1272                 }
1273                 /* Radeon R5xx */
1274                 else if (strstr(gl_info->gl_renderer, "X1600") ||
1275                          strstr(gl_info->gl_renderer, "X1650") ||
1276                          strstr(gl_info->gl_renderer, "X1800") ||
1277                          strstr(gl_info->gl_renderer, "X1900") ||
1278                          strstr(gl_info->gl_renderer, "X1950"))
1279                 {
1280                     gl_info->gl_card = CARD_ATI_RADEON_X1600;
1281                     vidmem = 128; /* X1600 uses 128-256MB, >=X1800 uses 256MB */
1282                 }
1283                 /* Radeon R4xx + X1300/X1400/X1450/X1550/X2300 (lowend R5xx) */
1284                 else if(strstr(gl_info->gl_renderer, "X700") ||
1285                         strstr(gl_info->gl_renderer, "X800") ||
1286                         strstr(gl_info->gl_renderer, "X850") ||
1287                         strstr(gl_info->gl_renderer, "X1300") ||
1288                         strstr(gl_info->gl_renderer, "X1400") ||
1289                         strstr(gl_info->gl_renderer, "X1450") ||
1290                         strstr(gl_info->gl_renderer, "X1550"))
1291                 {
1292                     gl_info->gl_card = CARD_ATI_RADEON_X700;
1293                     vidmem = 128; /* x700/x8*0 use 128-256MB, >=x1300 128-512MB */
1294                 }
1295                 /* Radeon Xpress Series - onboard, DX9b, Shader 2.0, 300-400MHz */
1296                 else if(strstr(gl_info->gl_renderer, "Radeon Xpress"))
1297                 {
1298                     gl_info->gl_card = CARD_ATI_RADEON_XPRESS_200M;
1299                     vidmem = 64; /* Shared RAM, BIOS configurable, 64-256M */
1300                 }
1301                 /* Radeon R3xx */ 
1302                 else {
1303                     gl_info->gl_card = CARD_ATI_RADEON_9500; /* Radeon 9500/9550/9600/9700/9800/X300/X550/X600 */
1304                     vidmem = 64; /* Radeon 9500 uses 64MB, higher models use up to 256MB */
1305                 }
1306             } else if(WINE_D3D8_CAPABLE(gl_info)) {
1307                 gl_info->gl_card = CARD_ATI_RADEON_8500; /* Radeon 8500/9000/9100/9200/9300 */
1308                 vidmem = 64; /* 8500/9000 cards use mostly 64MB, though there are 32MB and 128MB models */
1309             } else if(WINE_D3D7_CAPABLE(gl_info)) {
1310                 gl_info->gl_card = CARD_ATI_RADEON_7200; /* Radeon 7000/7100/7200/7500 */
1311                 vidmem = 32; /* There are models with up to 64MB */
1312             } else {
1313                 gl_info->gl_card = CARD_ATI_RAGE_128PRO;
1314                 vidmem = 16; /* There are 16-32MB models */
1315             }
1316             break;
1317         case VENDOR_INTEL:
1318             if (strstr(gl_info->gl_renderer, "GMA 950") ||
1319                 strstr(gl_info->gl_renderer, "945GM")) {
1320                 /* MacOS calls the card GMA 950, but everywhere else the PCI ID is named 945GM */
1321                 gl_info->gl_card = CARD_INTEL_I945GM;
1322                 vidmem = 64;
1323             } else if (strstr(gl_info->gl_renderer, "915GM")) {
1324                 gl_info->gl_card = CARD_INTEL_I915GM;
1325             } else if (strstr(gl_info->gl_renderer, "915G")) {
1326                 gl_info->gl_card = CARD_INTEL_I915G;
1327             } else if (strstr(gl_info->gl_renderer, "865G")) {
1328                 gl_info->gl_card = CARD_INTEL_I865G;
1329             } else if (strstr(gl_info->gl_renderer, "855G")) {
1330                 gl_info->gl_card = CARD_INTEL_I855G;
1331             } else if (strstr(gl_info->gl_renderer, "830G")) {
1332                 gl_info->gl_card = CARD_INTEL_I830G;
1333             } else {
1334                 gl_info->gl_card = CARD_INTEL_I915G;
1335             }
1336             break;
1337         case VENDOR_MESA:
1338         case VENDOR_WINE:
1339         default:
1340             /* Default to generic Nvidia hardware based on the supported OpenGL extensions. The choice 
1341              * for Nvidia was because the hardware and drivers they make are of good quality. This makes
1342              * them a good generic choice.
1343              */
1344             gl_info->gl_vendor = VENDOR_NVIDIA;
1345             if(WINE_D3D9_CAPABLE(gl_info))
1346                 gl_info->gl_card = CARD_NVIDIA_GEFORCEFX_5600;
1347             else if(WINE_D3D8_CAPABLE(gl_info))
1348                 gl_info->gl_card = CARD_NVIDIA_GEFORCE3;
1349             else if(WINE_D3D7_CAPABLE(gl_info))
1350                 gl_info->gl_card = CARD_NVIDIA_GEFORCE;
1351             else if(WINE_D3D6_CAPABLE(gl_info))
1352                 gl_info->gl_card = CARD_NVIDIA_RIVA_TNT;
1353             else
1354                 gl_info->gl_card = CARD_NVIDIA_RIVA_128;
1355     }
1356     TRACE_(d3d_caps)("FOUND (fake) card: 0x%x (vendor id), 0x%x (device id)\n", gl_info->gl_vendor, gl_info->gl_card);
1357
1358     /* If we have an estimate use it, else default to 64MB;  */
1359     if(vidmem)
1360         gl_info->vidmem = vidmem*1024*1024; /* convert from MBs to bytes */
1361     else
1362         gl_info->vidmem = WINE_DEFAULT_VIDMEM;
1363
1364     /* Load all the lookup tables */
1365     for (i = 0; i < MAX_LOOKUPS; i++) {
1366         stateLookup[i] = HeapAlloc(GetProcessHeap(), 0, sizeof(*stateLookup[i]) * (1 + maxLookup[i] - minLookup[i]) );
1367     }
1368
1369     stateLookup[WINELOOKUP_WARPPARAM][WINED3DTADDRESS_WRAP   - minLookup[WINELOOKUP_WARPPARAM]] = GL_REPEAT;
1370     stateLookup[WINELOOKUP_WARPPARAM][WINED3DTADDRESS_CLAMP  - minLookup[WINELOOKUP_WARPPARAM]] = GL_CLAMP_TO_EDGE;
1371     stateLookup[WINELOOKUP_WARPPARAM][WINED3DTADDRESS_BORDER - minLookup[WINELOOKUP_WARPPARAM]] =
1372              gl_info->supported[ARB_TEXTURE_BORDER_CLAMP] ? GL_CLAMP_TO_BORDER_ARB : GL_REPEAT;
1373     stateLookup[WINELOOKUP_WARPPARAM][WINED3DTADDRESS_BORDER - minLookup[WINELOOKUP_WARPPARAM]] =
1374              gl_info->supported[ARB_TEXTURE_BORDER_CLAMP] ? GL_CLAMP_TO_BORDER_ARB : GL_REPEAT;
1375     stateLookup[WINELOOKUP_WARPPARAM][WINED3DTADDRESS_MIRROR - minLookup[WINELOOKUP_WARPPARAM]] =
1376              gl_info->supported[ARB_TEXTURE_MIRRORED_REPEAT] ? GL_MIRRORED_REPEAT_ARB : GL_REPEAT;
1377     stateLookup[WINELOOKUP_WARPPARAM][WINED3DTADDRESS_MIRRORONCE - minLookup[WINELOOKUP_WARPPARAM]] =
1378              gl_info->supported[ATI_TEXTURE_MIRROR_ONCE] ? GL_MIRROR_CLAMP_TO_EDGE_ATI : GL_REPEAT;
1379
1380     magLookup[WINED3DTEXF_NONE        - WINED3DTEXF_NONE]  = GL_NEAREST;
1381     magLookup[WINED3DTEXF_POINT       - WINED3DTEXF_NONE] = GL_NEAREST;
1382     magLookup[WINED3DTEXF_LINEAR      - WINED3DTEXF_NONE] = GL_LINEAR;
1383     magLookup[WINED3DTEXF_ANISOTROPIC - WINED3DTEXF_NONE] =
1384              gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC] ? GL_LINEAR : GL_NEAREST;
1385
1386
1387     minMipLookup[WINED3DTEXF_NONE].mip[WINED3DTEXF_NONE]     = GL_LINEAR;
1388     minMipLookup[WINED3DTEXF_NONE].mip[WINED3DTEXF_POINT]    = GL_LINEAR;
1389     minMipLookup[WINED3DTEXF_NONE].mip[WINED3DTEXF_LINEAR]   = GL_LINEAR;
1390     minMipLookup[WINED3DTEXF_POINT].mip[WINED3DTEXF_NONE]    = GL_NEAREST;
1391     minMipLookup[WINED3DTEXF_POINT].mip[WINED3DTEXF_POINT]   = GL_NEAREST_MIPMAP_NEAREST;
1392     minMipLookup[WINED3DTEXF_POINT].mip[WINED3DTEXF_LINEAR]  = GL_NEAREST_MIPMAP_LINEAR;
1393     minMipLookup[WINED3DTEXF_LINEAR].mip[WINED3DTEXF_NONE]   = GL_LINEAR;
1394     minMipLookup[WINED3DTEXF_LINEAR].mip[WINED3DTEXF_POINT]  = GL_LINEAR_MIPMAP_NEAREST;
1395     minMipLookup[WINED3DTEXF_LINEAR].mip[WINED3DTEXF_LINEAR] = GL_LINEAR_MIPMAP_LINEAR;
1396     minMipLookup[WINED3DTEXF_ANISOTROPIC].mip[WINED3DTEXF_NONE]
1397             = gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC] ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR;
1398     minMipLookup[WINED3DTEXF_ANISOTROPIC].mip[WINED3DTEXF_POINT]
1399             = gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC] ? GL_LINEAR_MIPMAP_NEAREST : GL_LINEAR;
1400     minMipLookup[WINED3DTEXF_ANISOTROPIC].mip[WINED3DTEXF_LINEAR]
1401             = gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC] ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR;
1402
1403 /* TODO: config lookups */
1404
1405     /* Make sure there's an active HDC else the WGL extensions will fail */
1406     hdc = pwglGetCurrentDC();
1407     if (hdc) {
1408         WGL_Extensions = GL_EXTCALL(wglGetExtensionsStringARB(hdc));
1409         TRACE_(d3d_caps)("WGL_Extensions reported:\n");
1410
1411         if (NULL == WGL_Extensions) {
1412             ERR("   WGL_Extensions returns NULL\n");
1413         } else {
1414             while (*WGL_Extensions != 0x00) {
1415                 const char *Start;
1416                 char ThisExtn[256];
1417                 size_t len;
1418
1419                 while (isspace(*WGL_Extensions)) WGL_Extensions++;
1420                 Start = WGL_Extensions;
1421                 while (!isspace(*WGL_Extensions) && *WGL_Extensions != 0x00) {
1422                     WGL_Extensions++;
1423                 }
1424
1425                 len = WGL_Extensions - Start;
1426                 if (len == 0 || len >= sizeof(ThisExtn))
1427                     continue;
1428
1429                 memcpy(ThisExtn, Start, len);
1430                 ThisExtn[len] = '\0';
1431                 TRACE_(d3d_caps)("- %s\n", ThisExtn);
1432
1433                 if (!strcmp(ThisExtn, "WGL_ARB_pbuffer")) {
1434                     gl_info->supported[WGL_ARB_PBUFFER] = TRUE;
1435                     TRACE_(d3d_caps)("FOUND: WGL_ARB_pbuffer support\n");
1436                 }
1437                 if (!strcmp(ThisExtn, "WGL_WINE_pixel_format_passthrough")) {
1438                     gl_info->supported[WGL_WINE_PIXEL_FORMAT_PASSTHROUGH] = TRUE;
1439                     TRACE_(d3d_caps)("FOUND: WGL_WINE_pixel_format_passthrough support\n");
1440                 }
1441             }
1442         }
1443     }
1444     LEAVE_GL();
1445
1446     return return_value;
1447 }
1448
1449 /**********************************************************
1450  * IWineD3D implementation follows
1451  **********************************************************/
1452
1453 static UINT     WINAPI IWineD3DImpl_GetAdapterCount (IWineD3D *iface) {
1454     IWineD3DImpl *This = (IWineD3DImpl *)iface;
1455
1456     TRACE_(d3d_caps)("(%p): Reporting %u adapters\n", This, This->adapter_count);
1457
1458     return This->adapter_count;
1459 }
1460
1461 static HRESULT  WINAPI IWineD3DImpl_RegisterSoftwareDevice(IWineD3D *iface, void* pInitializeFunction) {
1462     IWineD3DImpl *This = (IWineD3DImpl *)iface;
1463     FIXME("(%p)->(%p): stub\n", This, pInitializeFunction);
1464     return WINED3D_OK;
1465 }
1466
1467 static HMONITOR WINAPI IWineD3DImpl_GetAdapterMonitor(IWineD3D *iface, UINT Adapter) {
1468     IWineD3DImpl *This = (IWineD3DImpl *)iface;
1469
1470     TRACE_(d3d_caps)("(%p)->(%d)\n", This, Adapter);
1471
1472     if (Adapter >= IWineD3DImpl_GetAdapterCount(iface)) {
1473         return NULL;
1474     }
1475
1476     return MonitorFromPoint(This->adapters[Adapter].monitorPoint, MONITOR_DEFAULTTOPRIMARY);
1477 }
1478
1479 /* FIXME: GetAdapterModeCount and EnumAdapterModes currently only returns modes
1480      of the same bpp but different resolutions                                  */
1481
1482 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */
1483 static UINT     WINAPI IWineD3DImpl_GetAdapterModeCount(IWineD3D *iface, UINT Adapter, WINED3DFORMAT Format) {
1484     IWineD3DImpl *This = (IWineD3DImpl *)iface;
1485     TRACE_(d3d_caps)("(%p}->(Adapter: %d, Format: %s)\n", This, Adapter, debug_d3dformat(Format));
1486
1487     if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
1488         return 0;
1489     }
1490
1491     /* TODO: Store modes per adapter and read it from the adapter structure */
1492     if (Adapter == 0) { /* Display */
1493         int i = 0;
1494         int j = 0;
1495
1496         if (!DEBUG_SINGLE_MODE) {
1497             DEVMODEW DevModeW;
1498
1499             ZeroMemory(&DevModeW, sizeof(DevModeW));
1500             DevModeW.dmSize = sizeof(DevModeW);
1501             while (EnumDisplaySettingsExW(NULL, j, &DevModeW, 0)) {
1502                 j++;
1503                 switch (Format)
1504                 {
1505                     case WINED3DFMT_UNKNOWN:
1506                         /* This is for D3D8, do not enumerate P8 here */
1507                         if (DevModeW.dmBitsPerPel == 32 ||
1508                             DevModeW.dmBitsPerPel == 16) i++;
1509                         break;
1510                     case WINED3DFMT_X8R8G8B8:
1511                         if (DevModeW.dmBitsPerPel == 32) i++;
1512                         break;
1513                     case WINED3DFMT_R5G6B5:
1514                         if (DevModeW.dmBitsPerPel == 16) i++;
1515                         break;
1516                     case WINED3DFMT_P8:
1517                         if (DevModeW.dmBitsPerPel == 8) i++;
1518                         break;
1519                     default:
1520                         /* Skip other modes as they do not match the requested format */
1521                         break;
1522                 }
1523             }
1524         } else {
1525             i = 1;
1526             j = 1;
1527         }
1528
1529         TRACE_(d3d_caps)("(%p}->(Adapter: %d) => %d (out of %d)\n", This, Adapter, i, j);
1530         return i;
1531     } else {
1532         FIXME_(d3d_caps)("Adapter not primary display\n");
1533     }
1534     return 0;
1535 }
1536
1537 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */
1538 static HRESULT WINAPI IWineD3DImpl_EnumAdapterModes(IWineD3D *iface, UINT Adapter, WINED3DFORMAT Format, UINT Mode, WINED3DDISPLAYMODE* pMode) {
1539     IWineD3DImpl *This = (IWineD3DImpl *)iface;
1540     TRACE_(d3d_caps)("(%p}->(Adapter:%d, mode:%d, pMode:%p, format:%s)\n", This, Adapter, Mode, pMode, debug_d3dformat(Format));
1541
1542     /* Validate the parameters as much as possible */
1543     if (NULL == pMode ||
1544         Adapter >= IWineD3DImpl_GetAdapterCount(iface) ||
1545         Mode    >= IWineD3DImpl_GetAdapterModeCount(iface, Adapter, Format)) {
1546         return WINED3DERR_INVALIDCALL;
1547     }
1548
1549     /* TODO: Store modes per adapter and read it from the adapter structure */
1550     if (Adapter == 0 && !DEBUG_SINGLE_MODE) { /* Display */
1551         DEVMODEW DevModeW;
1552         int ModeIdx = 0;
1553         UINT i = 0;
1554         int j = 0;
1555
1556         ZeroMemory(&DevModeW, sizeof(DevModeW));
1557         DevModeW.dmSize = sizeof(DevModeW);
1558
1559         /* If we are filtering to a specific format (D3D9), then need to skip
1560            all unrelated modes, but if mode is irrelevant (D3D8), then we can
1561            just count through the ones with valid bit depths */
1562         while ((i<=Mode) && EnumDisplaySettingsExW(NULL, j++, &DevModeW, 0)) {
1563             switch (Format)
1564             {
1565                 case WINED3DFMT_UNKNOWN:
1566                     /* This is D3D8. Do not enumerate P8 here */
1567                     if (DevModeW.dmBitsPerPel == 32 ||
1568                         DevModeW.dmBitsPerPel == 16) i++;
1569                     break;
1570                 case WINED3DFMT_X8R8G8B8:
1571                     if (DevModeW.dmBitsPerPel == 32) i++;
1572                     break;
1573                 case WINED3DFMT_R5G6B5:
1574                     if (DevModeW.dmBitsPerPel == 16) i++;
1575                     break;
1576                 case WINED3DFMT_P8:
1577                     if (DevModeW.dmBitsPerPel == 8) i++;
1578                     break;
1579                 default:
1580                     /* Modes that don't match what we support can get an early-out */
1581                     TRACE_(d3d_caps)("Searching for %s, returning D3DERR_INVALIDCALL\n", debug_d3dformat(Format));
1582                     return WINED3DERR_INVALIDCALL;
1583             }
1584         }
1585
1586         if (i == 0) {
1587             TRACE_(d3d_caps)("No modes found for format (%x - %s)\n", Format, debug_d3dformat(Format));
1588             return WINED3DERR_INVALIDCALL;
1589         }
1590         ModeIdx = j - 1;
1591
1592         /* Now get the display mode via the calculated index */
1593         if (EnumDisplaySettingsExW(NULL, ModeIdx, &DevModeW, 0)) {
1594             pMode->Width        = DevModeW.dmPelsWidth;
1595             pMode->Height       = DevModeW.dmPelsHeight;
1596             pMode->RefreshRate  = WINED3DADAPTER_DEFAULT;
1597             if (DevModeW.dmFields & DM_DISPLAYFREQUENCY)
1598                 pMode->RefreshRate = DevModeW.dmDisplayFrequency;
1599
1600             if (Format == WINED3DFMT_UNKNOWN) {
1601                 pMode->Format = pixelformat_for_depth(DevModeW.dmBitsPerPel);
1602             } else {
1603                 pMode->Format = Format;
1604             }
1605         } else {
1606             TRACE_(d3d_caps)("Requested mode out of range %d\n", Mode);
1607             return WINED3DERR_INVALIDCALL;
1608         }
1609
1610         TRACE_(d3d_caps)("W %d H %d rr %d fmt (%x - %s) bpp %u\n", pMode->Width, pMode->Height,
1611                 pMode->RefreshRate, pMode->Format, debug_d3dformat(pMode->Format),
1612                 DevModeW.dmBitsPerPel);
1613
1614     } else if (DEBUG_SINGLE_MODE) {
1615         /* Return one setting of the format requested */
1616         if (Mode > 0) return WINED3DERR_INVALIDCALL;
1617         pMode->Width        = 800;
1618         pMode->Height       = 600;
1619         pMode->RefreshRate  = 60;
1620         pMode->Format       = (Format == WINED3DFMT_UNKNOWN) ? WINED3DFMT_X8R8G8B8 : Format;
1621     } else {
1622         FIXME_(d3d_caps)("Adapter not primary display\n");
1623     }
1624
1625     return WINED3D_OK;
1626 }
1627
1628 static HRESULT WINAPI IWineD3DImpl_GetAdapterDisplayMode(IWineD3D *iface, UINT Adapter, WINED3DDISPLAYMODE* pMode) {
1629     IWineD3DImpl *This = (IWineD3DImpl *)iface;
1630     TRACE_(d3d_caps)("(%p}->(Adapter: %d, pMode: %p)\n", This, Adapter, pMode);
1631
1632     if (NULL == pMode ||
1633         Adapter >= IWineD3D_GetAdapterCount(iface)) {
1634         return WINED3DERR_INVALIDCALL;
1635     }
1636
1637     if (Adapter == 0) { /* Display */
1638         int bpp = 0;
1639         DEVMODEW DevModeW;
1640
1641         ZeroMemory(&DevModeW, sizeof(DevModeW));
1642         DevModeW.dmSize = sizeof(DevModeW);
1643
1644         EnumDisplaySettingsExW(NULL, ENUM_CURRENT_SETTINGS, &DevModeW, 0);
1645         pMode->Width        = DevModeW.dmPelsWidth;
1646         pMode->Height       = DevModeW.dmPelsHeight;
1647         bpp                 = DevModeW.dmBitsPerPel;
1648         pMode->RefreshRate  = WINED3DADAPTER_DEFAULT;
1649         if (DevModeW.dmFields&DM_DISPLAYFREQUENCY)
1650         {
1651             pMode->RefreshRate = DevModeW.dmDisplayFrequency;
1652         }
1653
1654         pMode->Format = pixelformat_for_depth(bpp);
1655     } else {
1656         FIXME_(d3d_caps)("Adapter not primary display\n");
1657     }
1658
1659     TRACE_(d3d_caps)("returning w:%d, h:%d, ref:%d, fmt:%s\n", pMode->Width,
1660           pMode->Height, pMode->RefreshRate, debug_d3dformat(pMode->Format));
1661     return WINED3D_OK;
1662 }
1663
1664 /* NOTE: due to structure differences between dx8 and dx9 D3DADAPTER_IDENTIFIER,
1665    and fields being inserted in the middle, a new structure is used in place    */
1666 static HRESULT WINAPI IWineD3DImpl_GetAdapterIdentifier(IWineD3D *iface, UINT Adapter, DWORD Flags,
1667                                                    WINED3DADAPTER_IDENTIFIER* pIdentifier) {
1668     IWineD3DImpl *This = (IWineD3DImpl *)iface;
1669
1670     TRACE_(d3d_caps)("(%p}->(Adapter: %d, Flags: %x, pId=%p)\n", This, Adapter, Flags, pIdentifier);
1671
1672     if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
1673         return WINED3DERR_INVALIDCALL;
1674     }
1675
1676     /* Return the information requested */
1677     TRACE_(d3d_caps)("device/Vendor Name and Version detection using FillGLCaps\n");
1678     strcpy(pIdentifier->Driver, This->adapters[Adapter].driver);
1679     strcpy(pIdentifier->Description, This->adapters[Adapter].description);
1680
1681     /* Note dx8 doesn't supply a DeviceName */
1682     if (NULL != pIdentifier->DeviceName) strcpy(pIdentifier->DeviceName, "\\\\.\\DISPLAY"); /* FIXME: May depend on desktop? */
1683     pIdentifier->DriverVersion->u.HighPart = This->adapters[Adapter].gl_info.driver_version_hipart;
1684     pIdentifier->DriverVersion->u.LowPart = This->adapters[Adapter].gl_info.driver_version;
1685     *(pIdentifier->VendorId) = This->adapters[Adapter].gl_info.gl_vendor;
1686     *(pIdentifier->DeviceId) = This->adapters[Adapter].gl_info.gl_card;
1687     *(pIdentifier->SubSysId) = 0;
1688     *(pIdentifier->Revision) = 0;
1689     *pIdentifier->DeviceIdentifier = IID_D3DDEVICE_D3DUID;
1690
1691     if(wined3d_settings.pci_device_id != PCI_DEVICE_NONE)
1692     {
1693         TRACE_(d3d_caps)("Overriding pci device id with: %x\n", wined3d_settings.pci_device_id);
1694         *(pIdentifier->DeviceId) = wined3d_settings.pci_device_id;
1695     }
1696
1697     if(wined3d_settings.pci_vendor_id != PCI_VENDOR_NONE)
1698     {
1699         TRACE_(d3d_caps)("Overriding pci vendor id with: %x\n", wined3d_settings.pci_vendor_id);
1700         *(pIdentifier->VendorId) = wined3d_settings.pci_vendor_id;
1701     }
1702
1703     if (Flags & WINED3DENUM_NO_WHQL_LEVEL) {
1704         *(pIdentifier->WHQLLevel) = 0;
1705     } else {
1706         *(pIdentifier->WHQLLevel) = 1;
1707     }
1708
1709     return WINED3D_OK;
1710 }
1711
1712 static BOOL IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(const WineD3D_PixelFormat *cfg, WINED3DFORMAT Format) {
1713     short redSize, greenSize, blueSize, alphaSize, colorBits;
1714
1715     if(!cfg)
1716         return FALSE;
1717
1718     if(cfg->iPixelType == WGL_TYPE_RGBA_ARB) { /* Integer RGBA formats */
1719         if(!getColorBits(Format, &redSize, &greenSize, &blueSize, &alphaSize, &colorBits)) {
1720             ERR("Unable to check compatibility for Format=%s\n", debug_d3dformat(Format));
1721             return FALSE;
1722         }
1723
1724         if(cfg->redSize < redSize)
1725             return FALSE;
1726
1727         if(cfg->greenSize < greenSize)
1728             return FALSE;
1729
1730         if(cfg->blueSize < blueSize)
1731             return FALSE;
1732
1733         if(cfg->alphaSize < alphaSize)
1734             return FALSE;
1735
1736         return TRUE;
1737     } else if(cfg->iPixelType == WGL_TYPE_RGBA_FLOAT_ARB) { /* Float RGBA formats; TODO: WGL_NV_float_buffer */
1738         if(Format == WINED3DFMT_R16_FLOAT)
1739             return (cfg->redSize == 16 && cfg->greenSize == 0 && cfg->blueSize == 0 && cfg->alphaSize == 0);
1740         if(Format == WINED3DFMT_R16G16_FLOAT)
1741             return (cfg->redSize == 16 && cfg->greenSize == 16 && cfg->blueSize == 0 && cfg->alphaSize == 0);
1742         if(Format == WINED3DFMT_R16G16B16A16_FLOAT)
1743             return (cfg->redSize == 16 && cfg->greenSize == 16 && cfg->blueSize == 16 && cfg->alphaSize == 16);
1744         if(Format == WINED3DFMT_R32_FLOAT)
1745             return (cfg->redSize == 32 && cfg->greenSize == 0 && cfg->blueSize == 0 && cfg->alphaSize == 0);
1746         if(Format == WINED3DFMT_R32G32_FLOAT)
1747             return (cfg->redSize == 32 && cfg->greenSize == 32 && cfg->blueSize == 0 && cfg->alphaSize == 0);
1748         if(Format == WINED3DFMT_R32G32B32A32_FLOAT)
1749             return (cfg->redSize == 32 && cfg->greenSize == 32 && cfg->blueSize == 32 && cfg->alphaSize == 32);
1750     } else {
1751         /* Probably a color index mode */
1752         return FALSE;
1753     }
1754
1755     return FALSE;
1756 }
1757
1758 static BOOL IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(const WineD3D_PixelFormat *cfg, WINED3DFORMAT Format) {
1759     short depthSize, stencilSize;
1760     BOOL lockable = FALSE;
1761
1762     if(!cfg)
1763         return FALSE;
1764
1765     if(!getDepthStencilBits(Format, &depthSize, &stencilSize)) {
1766         ERR("Unable to check compatibility for Format=%s\n", debug_d3dformat(Format));
1767         return FALSE;
1768     }
1769
1770     if((Format == WINED3DFMT_D16_LOCKABLE) || (Format == WINED3DFMT_D32F_LOCKABLE))
1771         lockable = TRUE;
1772
1773     /* On some modern cards like the Geforce8/9 GLX doesn't offer some dephthstencil formats which D3D9 reports.
1774      * We can safely report 'compatible' formats (e.g. D24 can be used for D16) as long as we aren't dealing with
1775      * a lockable format. This also helps D3D <= 7 as they expect D16 which isn't offered without this on Geforce8 cards. */
1776     if(!(cfg->depthSize == depthSize || (!lockable && cfg->depthSize > depthSize)))
1777         return FALSE;
1778
1779     /* Some cards like Intel i915 ones only offer D24S8 but lots of games also need a format without stencil, so
1780      * allow more stencil bits than requested. */
1781     if(cfg->stencilSize < stencilSize)
1782         return FALSE;
1783
1784     return TRUE;
1785 }
1786
1787 static HRESULT WINAPI IWineD3DImpl_CheckDepthStencilMatch(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
1788                                                    WINED3DFORMAT AdapterFormat,
1789                                                    WINED3DFORMAT RenderTargetFormat,
1790                                                    WINED3DFORMAT DepthStencilFormat) {
1791     IWineD3DImpl *This = (IWineD3DImpl *)iface;
1792     int nCfgs;
1793     const WineD3D_PixelFormat *cfgs;
1794     int it;
1795
1796     WARN_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, DevType:(%x,%s), AdptFmt:(%x,%s), RendrTgtFmt:(%x,%s), DepthStencilFmt:(%x,%s))\n",
1797            This, Adapter,
1798            DeviceType, debug_d3ddevicetype(DeviceType),
1799            AdapterFormat, debug_d3dformat(AdapterFormat),
1800            RenderTargetFormat, debug_d3dformat(RenderTargetFormat),
1801            DepthStencilFormat, debug_d3dformat(DepthStencilFormat));
1802
1803     if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
1804         TRACE("(%p) Failed: Atapter (%u) higher than supported adapters (%u) returning WINED3DERR_INVALIDCALL\n", This, Adapter, IWineD3D_GetAdapterCount(iface));
1805         return WINED3DERR_INVALIDCALL;
1806     }
1807
1808     cfgs = This->adapters[Adapter].cfgs;
1809     nCfgs = This->adapters[Adapter].nCfgs;
1810     for (it = 0; it < nCfgs; ++it) {
1811         if (IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&cfgs[it], RenderTargetFormat)) {
1812             if (IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&cfgs[it], DepthStencilFormat)) {
1813                 TRACE_(d3d_caps)("(%p) : Formats matched\n", This);
1814                 return WINED3D_OK;
1815             }
1816         }
1817     }
1818     WARN_(d3d_caps)("unsupported format pair: %s and %s\n", debug_d3dformat(RenderTargetFormat), debug_d3dformat(DepthStencilFormat));
1819
1820     return WINED3DERR_NOTAVAILABLE;
1821 }
1822
1823 static HRESULT WINAPI IWineD3DImpl_CheckDeviceMultiSampleType(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType, 
1824                                                        WINED3DFORMAT SurfaceFormat,
1825                                                        BOOL Windowed, WINED3DMULTISAMPLE_TYPE MultiSampleType, DWORD*   pQualityLevels) {
1826
1827     IWineD3DImpl *This = (IWineD3DImpl *)iface;
1828     const struct GlPixelFormatDesc *glDesc;
1829     const StaticPixelFormatDesc *desc;
1830
1831     TRACE_(d3d_caps)("(%p)-> (Adptr:%d, DevType:(%x,%s), SurfFmt:(%x,%s), Win?%d, MultiSamp:%x, pQual:%p)\n",
1832           This,
1833           Adapter,
1834           DeviceType, debug_d3ddevicetype(DeviceType),
1835           SurfaceFormat, debug_d3dformat(SurfaceFormat),
1836           Windowed,
1837           MultiSampleType,
1838           pQualityLevels);
1839
1840     if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
1841         return WINED3DERR_INVALIDCALL;
1842     }
1843
1844     /* TODO: handle Windowed, add more quality levels */
1845
1846     if (WINED3DMULTISAMPLE_NONE == MultiSampleType) return WINED3D_OK;
1847
1848     /* By default multisampling is disabled right now as it causes issues
1849      * on some Nvidia driver versions and it doesn't work well in combination
1850      * with FBOs yet. */
1851     if(!wined3d_settings.allow_multisampling)
1852         return WINED3DERR_NOTAVAILABLE;
1853
1854     desc = getFormatDescEntry(SurfaceFormat, &This->adapters[Adapter].gl_info, &glDesc);
1855     if(!desc || !glDesc) {
1856         return WINED3DERR_INVALIDCALL;
1857     }
1858
1859     if(glDesc->Flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL)) {
1860         int i, nCfgs;
1861         const WineD3D_PixelFormat *cfgs;
1862
1863         cfgs = This->adapters[Adapter].cfgs;
1864         nCfgs = This->adapters[Adapter].nCfgs;
1865         for(i=0; i<nCfgs; i++) {
1866             if(cfgs[i].numSamples != MultiSampleType)
1867                 continue;
1868
1869             if(!IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&cfgs[i], SurfaceFormat))
1870                 continue;
1871
1872             TRACE("Found iPixelFormat=%d to support MultiSampleType=%d for format %s\n", cfgs[i].iPixelFormat, MultiSampleType, debug_d3dformat(SurfaceFormat));
1873
1874             if(pQualityLevels)
1875                 *pQualityLevels = 1; /* Guess at a value! */
1876             return WINED3D_OK;
1877         }
1878     }
1879     else if(glDesc->Flags & WINED3DFMT_FLAG_RENDERTARGET) {
1880         short redSize, greenSize, blueSize, alphaSize, colorBits;
1881         int i, nCfgs;
1882         const WineD3D_PixelFormat *cfgs;
1883
1884         if(!getColorBits(SurfaceFormat, &redSize, &greenSize, &blueSize, &alphaSize, &colorBits)) {
1885             ERR("Unable to color bits for format %#x, can't check multisampling capability!\n", SurfaceFormat);
1886             return WINED3DERR_NOTAVAILABLE;
1887         }
1888
1889         cfgs = This->adapters[Adapter].cfgs;
1890         nCfgs = This->adapters[Adapter].nCfgs;
1891         for(i=0; i<nCfgs; i++) {
1892             if(cfgs[i].numSamples != MultiSampleType)
1893                 continue;
1894             if(cfgs[i].redSize != redSize)
1895                 continue;
1896             if(cfgs[i].greenSize != greenSize)
1897                 continue;
1898             if(cfgs[i].blueSize != blueSize)
1899                 continue;
1900             if(cfgs[i].alphaSize != alphaSize)
1901                 continue;
1902
1903             TRACE("Found iPixelFormat=%d to support MultiSampleType=%d for format %s\n", cfgs[i].iPixelFormat, MultiSampleType, debug_d3dformat(SurfaceFormat));
1904
1905             if(pQualityLevels)
1906                 *pQualityLevels = 1; /* Guess at a value! */
1907             return WINED3D_OK;
1908         }
1909     }
1910     return WINED3DERR_NOTAVAILABLE;
1911 }
1912
1913 static HRESULT WINAPI IWineD3DImpl_CheckDeviceType(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
1914                                             WINED3DFORMAT DisplayFormat, WINED3DFORMAT BackBufferFormat, BOOL Windowed) {
1915
1916     IWineD3DImpl *This = (IWineD3DImpl *)iface;
1917     HRESULT hr = WINED3DERR_NOTAVAILABLE;
1918     UINT nmodes;
1919
1920     TRACE_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, CheckType:(%x,%s), DispFmt:(%x,%s), BackBuf:(%x,%s), Win?%d): stub\n",
1921           This,
1922           Adapter,
1923           DeviceType, debug_d3ddevicetype(DeviceType),
1924           DisplayFormat, debug_d3dformat(DisplayFormat),
1925           BackBufferFormat, debug_d3dformat(BackBufferFormat),
1926           Windowed);
1927
1928     if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
1929         WARN_(d3d_caps)("Adapter >= IWineD3D_GetAdapterCount(iface), returning WINED3DERR_INVALIDCALL\n");
1930         return WINED3DERR_INVALIDCALL;
1931     }
1932
1933     /* The task of this function is to check whether a certain display / backbuffer format
1934      * combination is available on the given adapter. In fullscreen mode microsoft specified
1935      * that the display format shouldn't provide alpha and that ignoring alpha the backbuffer
1936      * and display format should match exactly.
1937      * In windowed mode format conversion can occur and this depends on the driver. When format
1938      * conversion is done, this function should nevertheless fail and applications need to use
1939      * CheckDeviceFormatConversion.
1940      * At the moment we assume that fullscreen and windowed have the same capabilities */
1941
1942     /* There are only 4 display formats */
1943     if(!((DisplayFormat == WINED3DFMT_R5G6B5) ||
1944          (DisplayFormat == WINED3DFMT_X1R5G5B5) ||
1945          (DisplayFormat == WINED3DFMT_X8R8G8B8) ||
1946          (DisplayFormat == WINED3DFMT_A2R10G10B10)))
1947     {
1948         TRACE_(d3d_caps)("Format %s unsupported as display format\n", debug_d3dformat(DisplayFormat));
1949         return WINED3DERR_NOTAVAILABLE;
1950     }
1951
1952     /* If the requested DisplayFormat is not available, don't continue */
1953     nmodes = IWineD3DImpl_GetAdapterModeCount(iface, Adapter, DisplayFormat);
1954     if(!nmodes) {
1955         TRACE_(d3d_caps)("No available modes for display format %s\n", debug_d3dformat(DisplayFormat));
1956         return WINED3DERR_NOTAVAILABLE;
1957     }
1958
1959     /* Windowed mode allows you to specify WINED3DFMT_UNKNOWN for the backbufferformat, it means 'reuse' the display format for the backbuffer */
1960     if(!Windowed && BackBufferFormat == WINED3DFMT_UNKNOWN) {
1961         TRACE_(d3d_caps)("BackBufferFormat WINED3FMT_UNKNOWN not available in Windowed mode\n");
1962         return WINED3DERR_NOTAVAILABLE;
1963     }
1964
1965     /* In FULLSCREEN mode R5G6B5 can only be mixed with backbuffer format R5G6B5 */
1966     if( (DisplayFormat == WINED3DFMT_R5G6B5) && (BackBufferFormat != WINED3DFMT_R5G6B5) ) {
1967         TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat), debug_d3dformat(BackBufferFormat));
1968         return WINED3DERR_NOTAVAILABLE;
1969     }
1970
1971     /* In FULLSCREEN mode X1R5G5B5 can only be mixed with backbuffer format *1R5G5B5 */
1972     if( (DisplayFormat == WINED3DFMT_X1R5G5B5) && !((BackBufferFormat == WINED3DFMT_X1R5G5B5) || (BackBufferFormat == WINED3DFMT_A1R5G5B5)) ) {
1973         TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat), debug_d3dformat(BackBufferFormat));
1974         return WINED3DERR_NOTAVAILABLE;
1975     }
1976
1977     /* In FULLSCREEN mode X8R8G8B8 can only be mixed with backbuffer format *8R8G8B8 */
1978     if( (DisplayFormat == WINED3DFMT_X8R8G8B8) && !((BackBufferFormat == WINED3DFMT_X8R8G8B8) || (BackBufferFormat == WINED3DFMT_A8R8G8B8)) ) {
1979         TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat), debug_d3dformat(BackBufferFormat));
1980         return WINED3DERR_NOTAVAILABLE;
1981     }
1982
1983     /* A2R10G10B10 is only allowed in fullscreen mode and it can only be mixed with backbuffer format A2R10G10B10 */
1984     if( (DisplayFormat == WINED3DFMT_A2R10G10B10) && ((BackBufferFormat != WINED3DFMT_A2R10G10B10) || Windowed)) {
1985         TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat), debug_d3dformat(BackBufferFormat));
1986         return WINED3DERR_NOTAVAILABLE;
1987     }
1988
1989     /* Use CheckDeviceFormat to see if the BackBufferFormat is usable with the given DisplayFormat */
1990     hr = IWineD3DImpl_CheckDeviceFormat(iface, Adapter, DeviceType, DisplayFormat, WINED3DUSAGE_RENDERTARGET, WINED3DRTYPE_SURFACE, BackBufferFormat, SURFACE_OPENGL);
1991     if(FAILED(hr))
1992         TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat), debug_d3dformat(BackBufferFormat));
1993
1994     return hr;
1995 }
1996
1997
1998 /* Check if we support bumpmapping for a format */
1999 static BOOL CheckBumpMapCapability(struct WineD3DAdapter *adapter,
2000         WINED3DDEVTYPE DeviceType, WINED3DFORMAT CheckFormat)
2001 {
2002     const struct fragment_pipeline *fp;
2003     const struct GlPixelFormatDesc *glDesc;
2004
2005     switch(CheckFormat) {
2006         case WINED3DFMT_R8G8_SNORM:
2007         case WINED3DFMT_R16G16_SNORM:
2008         case WINED3DFMT_L6V5U5:
2009         case WINED3DFMT_X8L8V8U8:
2010         case WINED3DFMT_R8G8B8A8_SNORM:
2011             /* Ask the fixed function pipeline implementation if it can deal
2012              * with the conversion. If we've got a GL extension giving native
2013              * support this will be an identity conversion. */
2014             getFormatDescEntry(CheckFormat, &adapter->gl_info, &glDesc);
2015             fp = select_fragment_implementation(adapter, DeviceType);
2016             if (fp->color_fixup_supported(glDesc->color_fixup))
2017             {
2018                 TRACE_(d3d_caps)("[OK]\n");
2019                 return TRUE;
2020             }
2021             TRACE_(d3d_caps)("[FAILED]\n");
2022             return FALSE;
2023
2024         default:
2025             TRACE_(d3d_caps)("[FAILED]\n");
2026             return FALSE;
2027     }
2028 }
2029
2030 /* Check if the given DisplayFormat + DepthStencilFormat combination is valid for the Adapter */
2031 static BOOL CheckDepthStencilCapability(struct WineD3DAdapter *adapter,
2032         WINED3DFORMAT DisplayFormat, WINED3DFORMAT DepthStencilFormat)
2033 {
2034     int it=0;
2035     const struct GlPixelFormatDesc *glDesc;
2036     const StaticPixelFormatDesc *desc = getFormatDescEntry(DepthStencilFormat, &adapter->gl_info, &glDesc);
2037
2038     /* Fail if we weren't able to get a description of the format */
2039     if(!desc || !glDesc)
2040         return FALSE;
2041
2042     /* Only allow depth/stencil formats */
2043     if(!(glDesc->Flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL)))
2044         return FALSE;
2045
2046     /* Walk through all WGL pixel formats to find a match */
2047     for (it = 0; it < adapter->nCfgs; ++it)
2048     {
2049         WineD3D_PixelFormat *cfg = &adapter->cfgs[it];
2050         if (IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(cfg, DisplayFormat)) {
2051             if (IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(cfg, DepthStencilFormat)) {
2052                 return TRUE;
2053             }
2054         }
2055     }
2056
2057     return FALSE;
2058 }
2059
2060 static BOOL CheckFilterCapability(struct WineD3DAdapter *adapter, WINED3DFORMAT CheckFormat)
2061 {
2062     const struct GlPixelFormatDesc *glDesc;
2063     const StaticPixelFormatDesc *desc = getFormatDescEntry(CheckFormat, &adapter->gl_info, &glDesc);
2064
2065     /* Fail if we weren't able to get a description of the format */
2066     if(!desc || !glDesc)
2067         return FALSE;
2068
2069     /* The flags entry of a format contains the filtering capability */
2070     if(glDesc->Flags & WINED3DFMT_FLAG_FILTERING)
2071         return TRUE;
2072
2073     return FALSE;
2074 }
2075
2076 /* Check the render target capabilities of a format */
2077 static BOOL CheckRenderTargetCapability(struct WineD3DAdapter *adapter,
2078         WINED3DFORMAT AdapterFormat, WINED3DFORMAT CheckFormat)
2079 {
2080     const struct GlPixelFormatDesc *glDesc;
2081     const StaticPixelFormatDesc *desc = getFormatDescEntry(CheckFormat, &adapter->gl_info, &glDesc);
2082
2083     /* Fail if we weren't able to get a description of the format */
2084     if(!desc || !glDesc)
2085         return FALSE;
2086
2087     /* Filter out non-RT formats */
2088     if(!(glDesc->Flags & WINED3DFMT_FLAG_RENDERTARGET))
2089         return FALSE;
2090
2091     if(wined3d_settings.offscreen_rendering_mode == ORM_BACKBUFFER) {
2092         WineD3D_PixelFormat *cfgs = adapter->cfgs;
2093         int it;
2094         short AdapterRed, AdapterGreen, AdapterBlue, AdapterAlpha, AdapterTotalSize;
2095         short CheckRed, CheckGreen, CheckBlue, CheckAlpha, CheckTotalSize;
2096
2097         getColorBits(AdapterFormat, &AdapterRed, &AdapterGreen, &AdapterBlue, &AdapterAlpha, &AdapterTotalSize);
2098         getColorBits(CheckFormat, &CheckRed, &CheckGreen, &CheckBlue, &CheckAlpha, &CheckTotalSize);
2099
2100         /* In backbuffer mode the front and backbuffer share the same WGL pixelformat.
2101          * The format must match in RGB, alpha is allowed to be different. (Only the backbuffer can have alpha) */
2102         if(!((AdapterRed == CheckRed) && (AdapterGreen == CheckGreen) && (AdapterBlue == CheckBlue))) {
2103             TRACE_(d3d_caps)("[FAILED]\n");
2104             return FALSE;
2105         }
2106
2107         /* Check if there is a WGL pixel format matching the requirements, the format should also be window
2108          * drawable (not offscreen; e.g. Nvidia offers R5G6B5 for pbuffers even when X is running at 24bit) */
2109         for (it = 0; it < adapter->nCfgs; ++it)
2110         {
2111             if (cfgs[it].windowDrawable && IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&cfgs[it], CheckFormat)) {
2112                 TRACE_(d3d_caps)("iPixelFormat=%d is compatible with CheckFormat=%s\n", cfgs[it].iPixelFormat, debug_d3dformat(CheckFormat));
2113                 return TRUE;
2114             }
2115         }
2116     } else if(wined3d_settings.offscreen_rendering_mode == ORM_PBUFFER) {
2117         /* We can probably use this function in FBO mode too on some drivers to get some basic indication of the capabilities. */
2118         WineD3D_PixelFormat *cfgs = adapter->cfgs;
2119         int it;
2120
2121         /* Check if there is a WGL pixel format matching the requirements, the pixel format should also be usable with pbuffers */
2122         for (it = 0; it < adapter->nCfgs; ++it)
2123         {
2124             if (cfgs[it].pbufferDrawable && IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&cfgs[it], CheckFormat)) {
2125                 TRACE_(d3d_caps)("iPixelFormat=%d is compatible with CheckFormat=%s\n", cfgs[it].iPixelFormat, debug_d3dformat(CheckFormat));
2126                 return TRUE;
2127             }
2128         }
2129     } else if(wined3d_settings.offscreen_rendering_mode == ORM_FBO){
2130         /* For now return TRUE for FBOs until we have some proper checks.
2131          * Note that this function will only be called when the format is around for texturing. */
2132         return TRUE;
2133     }
2134     return FALSE;
2135 }
2136
2137 static BOOL CheckSrgbReadCapability(struct WineD3DAdapter *adapter, WINED3DFORMAT CheckFormat)
2138 {
2139     const WineD3D_GL_Info *gl_info = &adapter->gl_info;
2140
2141     /* Check for supported sRGB formats (Texture loading and framebuffer) */
2142     if(!GL_SUPPORT(EXT_TEXTURE_SRGB)) {
2143         TRACE_(d3d_caps)("[FAILED] GL_EXT_texture_sRGB not supported\n");
2144         return FALSE;
2145     }
2146
2147     switch (CheckFormat) {
2148         case WINED3DFMT_A8R8G8B8:
2149         case WINED3DFMT_X8R8G8B8:
2150         case WINED3DFMT_A4R4G4B4:
2151         case WINED3DFMT_L8:
2152         case WINED3DFMT_A8L8:
2153         case WINED3DFMT_DXT1:
2154         case WINED3DFMT_DXT2:
2155         case WINED3DFMT_DXT3:
2156         case WINED3DFMT_DXT4:
2157         case WINED3DFMT_DXT5:
2158             TRACE_(d3d_caps)("[OK]\n");
2159             return TRUE;
2160
2161         default:
2162             TRACE_(d3d_caps)("[FAILED] Gamma texture format %s not supported.\n", debug_d3dformat(CheckFormat));
2163             return FALSE;
2164     }
2165     return FALSE;
2166 }
2167
2168 static BOOL CheckSrgbWriteCapability(struct WineD3DAdapter *adapter,
2169         WINED3DDEVTYPE DeviceType, WINED3DFORMAT CheckFormat)
2170 {
2171     /* Only offer SRGB writing on X8R8G8B8/A8R8G8B8 when we use ARB or GLSL shaders as we are
2172      * doing the color fixup in shaders.
2173      * Note Windows drivers (at least on the Geforce 8800) also offer this on R5G6B5. */
2174     if((CheckFormat == WINED3DFMT_X8R8G8B8) || (CheckFormat == WINED3DFMT_A8R8G8B8)) {
2175         int vs_selected_mode;
2176         int ps_selected_mode;
2177         select_shader_mode(&adapter->gl_info, DeviceType, &ps_selected_mode, &vs_selected_mode);
2178
2179         if((ps_selected_mode == SHADER_ARB) || (ps_selected_mode == SHADER_GLSL)) {
2180             TRACE_(d3d_caps)("[OK]\n");
2181             return TRUE;
2182         }
2183     }
2184
2185     TRACE_(d3d_caps)("[FAILED] - no SRGB writing support on format=%s\n", debug_d3dformat(CheckFormat));
2186     return FALSE;
2187 }
2188
2189 /* Check if a format support blending in combination with pixel shaders */
2190 static BOOL CheckPostPixelShaderBlendingCapability(struct WineD3DAdapter *adapter, WINED3DFORMAT CheckFormat)
2191 {
2192     const struct GlPixelFormatDesc *glDesc;
2193     const StaticPixelFormatDesc *desc = getFormatDescEntry(CheckFormat, &adapter->gl_info, &glDesc);
2194
2195     /* Fail if we weren't able to get a description of the format */
2196     if(!desc || !glDesc)
2197         return FALSE;
2198
2199     /* The flags entry of a format contains the post pixel shader blending capability */
2200     if(glDesc->Flags & WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING)
2201         return TRUE;
2202
2203     return FALSE;
2204 }
2205
2206 static BOOL CheckWrapAndMipCapability(UINT Adapter, WINED3DFORMAT CheckFormat) {
2207     /* OpenGL supports mipmapping on all formats basically. Wrapping is unsupported,
2208      * but we have to report mipmapping so we cannot reject this flag. Tests show that
2209      * windows reports WRAPANDMIP on unfilterable surfaces as well, apparently to show
2210      * that wrapping is supported. The lack of filtering will sort out the mipmapping
2211      * capability anyway.
2212      *
2213      * For now lets report this on all formats, but in the future we may want to
2214      * restrict it to some should games need that
2215      */
2216     return TRUE;
2217 }
2218
2219 /* Check if a texture format is supported on the given adapter */
2220 static BOOL CheckTextureCapability(struct WineD3DAdapter *adapter,
2221         WINED3DDEVTYPE DeviceType, WINED3DFORMAT CheckFormat)
2222 {
2223     const WineD3D_GL_Info *gl_info = &adapter->gl_info;
2224     const shader_backend_t *shader_backend;
2225     const struct fragment_pipeline *fp;
2226     const struct GlPixelFormatDesc *glDesc;
2227
2228     switch (CheckFormat) {
2229
2230         /*****
2231          *  supported: RGB(A) formats
2232          */
2233         case WINED3DFMT_R8G8B8: /* Enable for dx7, blacklisted for 8 and 9 above */
2234         case WINED3DFMT_A8R8G8B8:
2235         case WINED3DFMT_X8R8G8B8:
2236         case WINED3DFMT_R5G6B5:
2237         case WINED3DFMT_X1R5G5B5:
2238         case WINED3DFMT_A1R5G5B5:
2239         case WINED3DFMT_A4R4G4B4:
2240         case WINED3DFMT_A8_UNORM:
2241         case WINED3DFMT_X4R4G4B4:
2242         case WINED3DFMT_R8G8B8A8_UNORM:
2243         case WINED3DFMT_X8B8G8R8:
2244         case WINED3DFMT_A2R10G10B10:
2245         case WINED3DFMT_R10G10B10A2_UNORM:
2246         case WINED3DFMT_R16G16_UNORM:
2247             TRACE_(d3d_caps)("[OK]\n");
2248             return TRUE;
2249
2250         case WINED3DFMT_R3G3B2:
2251             TRACE_(d3d_caps)("[FAILED] - Not supported on Windows\n");
2252             return FALSE;
2253
2254         /*****
2255          *  supported: Palettized
2256          */
2257         case WINED3DFMT_P8:
2258             TRACE_(d3d_caps)("[OK]\n");
2259             return TRUE;
2260         /* No Windows driver offers A8P8, so don't offer it either */
2261         case WINED3DFMT_A8P8:
2262             return FALSE;
2263
2264         /*****
2265          *  Supported: (Alpha)-Luminance
2266          */
2267         case WINED3DFMT_L8:
2268         case WINED3DFMT_A8L8:
2269         case WINED3DFMT_L16:
2270             TRACE_(d3d_caps)("[OK]\n");
2271             return TRUE;
2272
2273         /* Not supported on Windows, thus disabled */
2274         case WINED3DFMT_A4L4:
2275             TRACE_(d3d_caps)("[FAILED] - not supported on windows\n");
2276             return FALSE;
2277
2278         /*****
2279          *  Supported: Depth/Stencil formats
2280          */
2281         case WINED3DFMT_D16_LOCKABLE:
2282         case WINED3DFMT_D16_UNORM:
2283         case WINED3DFMT_D15S1:
2284         case WINED3DFMT_D24X8:
2285         case WINED3DFMT_D24X4S4:
2286         case WINED3DFMT_D24S8:
2287         case WINED3DFMT_D24FS8:
2288         case WINED3DFMT_D32:
2289         case WINED3DFMT_D32F_LOCKABLE:
2290             return TRUE;
2291
2292         /*****
2293          *  Not supported everywhere(depends on GL_ATI_envmap_bumpmap or
2294          *  GL_NV_texture_shader). Emulated by shaders
2295          */
2296         case WINED3DFMT_R8G8_SNORM:
2297         case WINED3DFMT_X8L8V8U8:
2298         case WINED3DFMT_L6V5U5:
2299         case WINED3DFMT_R8G8B8A8_SNORM:
2300         case WINED3DFMT_R16G16_SNORM:
2301             /* Ask the shader backend if it can deal with the conversion. If
2302              * we've got a GL extension giving native support this will be an
2303              * identity conversion. */
2304             getFormatDescEntry(CheckFormat, &adapter->gl_info, &glDesc);
2305             shader_backend = select_shader_backend(adapter, DeviceType);
2306             if (shader_backend->shader_color_fixup_supported(glDesc->color_fixup))
2307             {
2308                 TRACE_(d3d_caps)("[OK]\n");
2309                 return TRUE;
2310             }
2311             TRACE_(d3d_caps)("[FAILED]\n");
2312             return FALSE;
2313
2314         case WINED3DFMT_DXT1:
2315         case WINED3DFMT_DXT2:
2316         case WINED3DFMT_DXT3:
2317         case WINED3DFMT_DXT4:
2318         case WINED3DFMT_DXT5:
2319             if (GL_SUPPORT(EXT_TEXTURE_COMPRESSION_S3TC)) {
2320                 TRACE_(d3d_caps)("[OK]\n");
2321                 return TRUE;
2322             }
2323             TRACE_(d3d_caps)("[FAILED]\n");
2324             return FALSE;
2325
2326
2327         /*****
2328          *  Odd formats - not supported
2329          */
2330         case WINED3DFMT_VERTEXDATA:
2331         case WINED3DFMT_R16_UINT:
2332         case WINED3DFMT_R32_UINT:
2333         case WINED3DFMT_R16G16B16A16_SNORM:
2334         case WINED3DFMT_A2W10V10U10:
2335         case WINED3DFMT_W11V11U10:
2336             TRACE_(d3d_caps)("[FAILED]\n"); /* Enable when implemented */
2337             return FALSE;
2338
2339         /*****
2340          *  WINED3DFMT_CxV8U8: Not supported right now
2341          */
2342         case WINED3DFMT_CxV8U8:
2343             TRACE_(d3d_caps)("[FAILED]\n"); /* Enable when implemented */
2344             return FALSE;
2345
2346         /* YUV formats */
2347         case WINED3DFMT_UYVY:
2348         case WINED3DFMT_YUY2:
2349             if(GL_SUPPORT(APPLE_YCBCR_422)) {
2350                 TRACE_(d3d_caps)("[OK]\n");
2351                 return TRUE;
2352             }
2353             TRACE_(d3d_caps)("[FAILED]\n");
2354             return FALSE;
2355         case WINED3DFMT_YV12:
2356             TRACE_(d3d_caps)("[FAILED]\n");
2357             return FALSE;
2358
2359             /* Not supported */
2360         case WINED3DFMT_R16G16B16A16_UNORM:
2361         case WINED3DFMT_A8R3G3B2:
2362             TRACE_(d3d_caps)("[FAILED]\n"); /* Enable when implemented */
2363             return FALSE;
2364
2365             /* Floating point formats */
2366         case WINED3DFMT_R16_FLOAT:
2367         case WINED3DFMT_R16G16B16A16_FLOAT:
2368             if(GL_SUPPORT(ARB_TEXTURE_FLOAT) && GL_SUPPORT(ARB_HALF_FLOAT_PIXEL)) {
2369                 TRACE_(d3d_caps)("[OK]\n");
2370                 return TRUE;
2371             }
2372             TRACE_(d3d_caps)("[FAILED]\n");
2373             return FALSE;
2374
2375         case WINED3DFMT_R32_FLOAT:
2376         case WINED3DFMT_R32G32B32A32_FLOAT:
2377             if (GL_SUPPORT(ARB_TEXTURE_FLOAT)) {
2378                 TRACE_(d3d_caps)("[OK]\n");
2379                 return TRUE;
2380             }
2381             TRACE_(d3d_caps)("[FAILED]\n");
2382             return FALSE;
2383
2384         case WINED3DFMT_R16G16_FLOAT:
2385         case WINED3DFMT_R32G32_FLOAT:
2386             if(GL_SUPPORT(ARB_TEXTURE_RG)) {
2387                 TRACE_(d3d_caps)("[OK]\n");
2388                 return TRUE;
2389             }
2390             TRACE_(d3d_caps)("[FAILED]\n");
2391             return FALSE;
2392
2393         /* ATI instancing hack: Although ATI cards do not support Shader Model 3.0, they support
2394          * instancing. To query if the card supports instancing CheckDeviceFormat with the special format
2395          * MAKEFOURCC('I','N','S','T') is used. Should a (broken) app check for this provide a proper return value.
2396          * We can do instancing with all shader versions, but we need vertex shaders.
2397          *
2398          * Additionally applications have to set the D3DRS_POINTSIZE render state to MAKEFOURCC('I','N','S','T') once
2399          * to enable instancing. WineD3D doesn't need that and just ignores it.
2400          *
2401          * With Shader Model 3.0 capable cards Instancing 'just works' in Windows.
2402          */
2403         case WINEMAKEFOURCC('I','N','S','T'):
2404             TRACE("ATI Instancing check hack\n");
2405             if(GL_SUPPORT(ARB_VERTEX_PROGRAM) || GL_SUPPORT(ARB_VERTEX_SHADER)) {
2406                 TRACE_(d3d_caps)("[OK]\n");
2407                 return TRUE;
2408             }
2409             TRACE_(d3d_caps)("[FAILED]\n");
2410             return FALSE;
2411
2412         /* Some weird FOURCC formats */
2413         case WINED3DFMT_R8G8_B8G8:
2414         case WINED3DFMT_G8R8_G8B8:
2415         case WINED3DFMT_MULTI2_ARGB8:
2416             TRACE_(d3d_caps)("[FAILED]\n");
2417             return FALSE;
2418
2419         /* Vendor specific formats */
2420         case WINED3DFMT_ATI2N:
2421             if(GL_SUPPORT(ATI_TEXTURE_COMPRESSION_3DC) || GL_SUPPORT(EXT_TEXTURE_COMPRESSION_RGTC)) {
2422                 getFormatDescEntry(CheckFormat, &adapter->gl_info, &glDesc);
2423                 shader_backend = select_shader_backend(adapter, DeviceType);
2424                 fp = select_fragment_implementation(adapter, DeviceType);
2425                 if (shader_backend->shader_color_fixup_supported(glDesc->color_fixup)
2426                         && fp->color_fixup_supported(glDesc->color_fixup))
2427                 {
2428                     TRACE_(d3d_caps)("[OK]\n");
2429                     return TRUE;
2430                 }
2431
2432                 TRACE_(d3d_caps)("[OK]\n");
2433                 return TRUE;
2434             }
2435             TRACE_(d3d_caps)("[FAILED]\n");
2436             return FALSE;
2437
2438         case WINED3DFMT_NVHU:
2439         case WINED3DFMT_NVHS:
2440             /* These formats seem to be similar to the HILO formats in GL_NV_texture_shader. NVHU
2441              * is said to be GL_UNSIGNED_HILO16, NVHS GL_SIGNED_HILO16. Rumours say that d3d computes
2442              * a 3rd channel similarly to D3DFMT_CxV8U8(So NVHS could be called D3DFMT_CxV16U16).
2443              * ATI refused to support formats which can easilly be emulated with pixel shaders, so
2444              * Applications have to deal with not having NVHS and NVHU.
2445              */
2446             TRACE_(d3d_caps)("[FAILED]\n");
2447             return FALSE;
2448
2449         case WINED3DFMT_UNKNOWN:
2450             return FALSE;
2451
2452         default:
2453             ERR("Unhandled format=%s\n", debug_d3dformat(CheckFormat));
2454             break;
2455     }
2456     return FALSE;
2457 }
2458
2459 static BOOL CheckSurfaceCapability(struct WineD3DAdapter *adapter, WINED3DFORMAT AdapterFormat,
2460         WINED3DDEVTYPE DeviceType, WINED3DFORMAT CheckFormat, WINED3DSURFTYPE SurfaceType)
2461 {
2462     const struct GlPixelFormatDesc *format_desc;
2463     const struct blit_shader *blitter;
2464
2465     if(SurfaceType == SURFACE_GDI) {
2466         switch(CheckFormat) {
2467             case WINED3DFMT_R8G8B8:
2468             case WINED3DFMT_A8R8G8B8:
2469             case WINED3DFMT_X8R8G8B8:
2470             case WINED3DFMT_R5G6B5:
2471             case WINED3DFMT_X1R5G5B5:
2472             case WINED3DFMT_A1R5G5B5:
2473             case WINED3DFMT_A4R4G4B4:
2474             case WINED3DFMT_R3G3B2:
2475             case WINED3DFMT_A8_UNORM:
2476             case WINED3DFMT_A8R3G3B2:
2477             case WINED3DFMT_X4R4G4B4:
2478             case WINED3DFMT_R10G10B10A2_UNORM:
2479             case WINED3DFMT_R8G8B8A8_UNORM:
2480             case WINED3DFMT_X8B8G8R8:
2481             case WINED3DFMT_R16G16_UNORM:
2482             case WINED3DFMT_A2R10G10B10:
2483             case WINED3DFMT_R16G16B16A16_UNORM:
2484             case WINED3DFMT_P8:
2485                 TRACE_(d3d_caps)("[OK]\n");
2486                 return TRUE;
2487             default:
2488                 TRACE_(d3d_caps)("[FAILED] - not available on GDI surfaces\n");
2489                 return FALSE;
2490         }
2491     }
2492
2493     /* All format that are supported for textures are supported for surfaces as well */
2494     if(CheckTextureCapability(adapter, DeviceType, CheckFormat)) return TRUE;
2495     /* All depth stencil formats are supported on surfaces */
2496     if(CheckDepthStencilCapability(adapter, AdapterFormat, CheckFormat)) return TRUE;
2497
2498     /* If opengl can't process the format natively, the blitter may be able to convert it */
2499     getFormatDescEntry(CheckFormat, &adapter->gl_info, &format_desc);
2500     blitter = select_blit_implementation(adapter, DeviceType);
2501     if (blitter->color_fixup_supported(format_desc->color_fixup))
2502     {
2503         TRACE_(d3d_caps)("[OK]\n");
2504         return TRUE;
2505     }
2506
2507     /* Reject other formats */
2508     TRACE_(d3d_caps)("[FAILED]\n");
2509     return FALSE;
2510 }
2511
2512 static BOOL CheckVertexTextureCapability(struct WineD3DAdapter *adapter, WINED3DFORMAT CheckFormat)
2513 {
2514     const WineD3D_GL_Info *gl_info = &adapter->gl_info;
2515
2516     if (!GL_LIMITS(vertex_samplers)) {
2517         TRACE_(d3d_caps)("[FAILED]\n");
2518         return FALSE;
2519     }
2520
2521     switch (CheckFormat) {
2522         case WINED3DFMT_R32G32B32A32_FLOAT:
2523             if (!GL_SUPPORT(ARB_TEXTURE_FLOAT)) {
2524                 TRACE_(d3d_caps)("[FAILED]\n");
2525                 return FALSE;
2526             }
2527             TRACE_(d3d_caps)("[OK]\n");
2528             return TRUE;
2529
2530         default:
2531             TRACE_(d3d_caps)("[FAILED]\n");
2532             return FALSE;
2533     }
2534     return FALSE;
2535 }
2536
2537 static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType, 
2538         WINED3DFORMAT AdapterFormat, DWORD Usage, WINED3DRESOURCETYPE RType, WINED3DFORMAT CheckFormat,
2539         WINED3DSURFTYPE SurfaceType) {
2540     IWineD3DImpl *This = (IWineD3DImpl *)iface;
2541     struct WineD3DAdapter *adapter = &This->adapters[Adapter];
2542     const WineD3D_GL_Info *gl_info = &adapter->gl_info;
2543     DWORD UsageCaps = 0;
2544
2545     TRACE_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, DevType:(%u,%s), AdptFmt:(%u,%s), Use:(%u,%s,%s), ResTyp:(%x,%s), CheckFmt:(%u,%s))\n",
2546           This,
2547           Adapter,
2548           DeviceType, debug_d3ddevicetype(DeviceType),
2549           AdapterFormat, debug_d3dformat(AdapterFormat),
2550           Usage, debug_d3dusage(Usage), debug_d3dusagequery(Usage),
2551           RType, debug_d3dresourcetype(RType),
2552           CheckFormat, debug_d3dformat(CheckFormat));
2553
2554     if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
2555         return WINED3DERR_INVALIDCALL;
2556     }
2557
2558     if(RType == WINED3DRTYPE_CUBETEXTURE) {
2559
2560         if(SurfaceType != SURFACE_OPENGL) {
2561             TRACE("[FAILED]\n");
2562             return WINED3DERR_NOTAVAILABLE;
2563         }
2564
2565         /* Cubetexture allows:
2566          *                    - D3DUSAGE_AUTOGENMIPMAP
2567          *                    - D3DUSAGE_DEPTHSTENCIL
2568          *                    - D3DUSAGE_DYNAMIC
2569          *                    - D3DUSAGE_NONSECURE (d3d9ex)
2570          *                    - D3DUSAGE_RENDERTARGET
2571          *                    - D3DUSAGE_SOFTWAREPROCESSING
2572          *                    - D3DUSAGE_QUERY_WRAPANDMIP
2573          */
2574         if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
2575             /* Check if the texture format is around */
2576             if (CheckTextureCapability(adapter, DeviceType, CheckFormat))
2577             {
2578                 if(Usage & WINED3DUSAGE_AUTOGENMIPMAP) {
2579                     /* Check for automatic mipmap generation support */
2580                     if(GL_SUPPORT(SGIS_GENERATE_MIPMAP)) {
2581                         UsageCaps |= WINED3DUSAGE_AUTOGENMIPMAP;
2582                     } else {
2583                         /* When autogenmipmap isn't around continue and return WINED3DOK_NOAUTOGEN instead of D3D_OK */
2584                         TRACE_(d3d_caps)("[FAILED] - No autogenmipmap support, but continuing\n");
2585                     }
2586                 }
2587
2588                 /* Always report dynamic locking */
2589                 if(Usage & WINED3DUSAGE_DYNAMIC)
2590                     UsageCaps |= WINED3DUSAGE_DYNAMIC;
2591
2592                 if(Usage & WINED3DUSAGE_RENDERTARGET) {
2593                     if(CheckRenderTargetCapability(adapter, AdapterFormat, CheckFormat))
2594                     {
2595                         UsageCaps |= WINED3DUSAGE_RENDERTARGET;
2596                     } else {
2597                         TRACE_(d3d_caps)("[FAILED] - No rendertarget support\n");
2598                         return WINED3DERR_NOTAVAILABLE;
2599                     }
2600                 }
2601
2602                 /* Always report software processing */
2603                 if(Usage & WINED3DUSAGE_SOFTWAREPROCESSING)
2604                     UsageCaps |= WINED3DUSAGE_SOFTWAREPROCESSING;
2605
2606                 /* Check QUERY_FILTER support */
2607                 if(Usage & WINED3DUSAGE_QUERY_FILTER) {
2608                     if (CheckFilterCapability(adapter, CheckFormat))
2609                     {
2610                         UsageCaps |= WINED3DUSAGE_QUERY_FILTER;
2611                     } else {
2612                         TRACE_(d3d_caps)("[FAILED] - No query filter support\n");
2613                         return WINED3DERR_NOTAVAILABLE;
2614                     }
2615                 }
2616
2617                 /* Check QUERY_POSTPIXELSHADER_BLENDING support */
2618                 if(Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING) {
2619                     if (CheckPostPixelShaderBlendingCapability(adapter, CheckFormat))
2620                     {
2621                         UsageCaps |= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
2622                     } else {
2623                         TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
2624                         return WINED3DERR_NOTAVAILABLE;
2625                     }
2626                 }
2627
2628                 /* Check QUERY_SRGBREAD support */
2629                 if(Usage & WINED3DUSAGE_QUERY_SRGBREAD) {
2630                     if (CheckSrgbReadCapability(adapter, CheckFormat))
2631                     {
2632                         UsageCaps |= WINED3DUSAGE_QUERY_SRGBREAD;
2633                     } else {
2634                         TRACE_(d3d_caps)("[FAILED] - No query srgbread support\n");
2635                         return WINED3DERR_NOTAVAILABLE;
2636                     }
2637                 }
2638
2639                 /* Check QUERY_SRGBWRITE support */
2640                 if(Usage & WINED3DUSAGE_QUERY_SRGBWRITE) {
2641                     if (CheckSrgbWriteCapability(adapter, DeviceType, CheckFormat))
2642                     {
2643                         UsageCaps |= WINED3DUSAGE_QUERY_SRGBWRITE;
2644                     } else {
2645                         TRACE_(d3d_caps)("[FAILED] - No query srgbwrite support\n");
2646                         return WINED3DERR_NOTAVAILABLE;
2647                     }
2648                 }
2649
2650                 /* Check QUERY_VERTEXTEXTURE support */
2651                 if(Usage & WINED3DUSAGE_QUERY_VERTEXTEXTURE) {
2652                     if (CheckVertexTextureCapability(adapter, CheckFormat))
2653                     {
2654                         UsageCaps |= WINED3DUSAGE_QUERY_VERTEXTEXTURE;
2655                     } else {
2656                         TRACE_(d3d_caps)("[FAILED] - No query vertextexture support\n");
2657                         return WINED3DERR_NOTAVAILABLE;
2658                     }
2659                 }
2660
2661                 /* Check QUERY_WRAPANDMIP support */
2662                 if(Usage & WINED3DUSAGE_QUERY_WRAPANDMIP) {
2663                     if(CheckWrapAndMipCapability(Adapter, CheckFormat)) {
2664                         UsageCaps |= WINED3DUSAGE_QUERY_WRAPANDMIP;
2665                     } else {
2666                         TRACE_(d3d_caps)("[FAILED] - No wrapping and mipmapping support\n");
2667                         return WINED3DERR_NOTAVAILABLE;
2668                     }
2669                 }
2670             } else {
2671                 TRACE_(d3d_caps)("[FAILED] - Cube texture format not supported\n");
2672                 return WINED3DERR_NOTAVAILABLE;
2673             }
2674         } else {
2675             TRACE_(d3d_caps)("[FAILED] - No cube texture support\n");
2676             return WINED3DERR_NOTAVAILABLE;
2677         }
2678     } else if(RType == WINED3DRTYPE_SURFACE) {
2679         /* Surface allows:
2680          *                - D3DUSAGE_DEPTHSTENCIL
2681          *                - D3DUSAGE_NONSECURE (d3d9ex)
2682          *                - D3DUSAGE_RENDERTARGET
2683          */
2684
2685         if (CheckSurfaceCapability(adapter, AdapterFormat, DeviceType, CheckFormat, SurfaceType))
2686         {
2687             if(Usage & WINED3DUSAGE_DEPTHSTENCIL) {
2688                 if (CheckDepthStencilCapability(adapter, AdapterFormat, CheckFormat))
2689                 {
2690                     UsageCaps |= WINED3DUSAGE_DEPTHSTENCIL;
2691                 } else {
2692                     TRACE_(d3d_caps)("[FAILED] - No depthstencil support\n");
2693                     return WINED3DERR_NOTAVAILABLE;
2694                 }
2695             }
2696
2697             if(Usage & WINED3DUSAGE_RENDERTARGET) {
2698                 if (CheckRenderTargetCapability(adapter, AdapterFormat, CheckFormat))
2699                 {
2700                     UsageCaps |= WINED3DUSAGE_RENDERTARGET;
2701                 } else {
2702                     TRACE_(d3d_caps)("[FAILED] - No rendertarget support\n");
2703                     return WINED3DERR_NOTAVAILABLE;
2704                 }
2705             }
2706
2707             /* Check QUERY_POSTPIXELSHADER_BLENDING support */
2708             if(Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING) {
2709                 if (CheckPostPixelShaderBlendingCapability(adapter, CheckFormat))
2710                 {
2711                     UsageCaps |= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
2712                 } else {
2713                     TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
2714                     return WINED3DERR_NOTAVAILABLE;
2715                 }
2716             }
2717         } else {
2718             TRACE_(d3d_caps)("[FAILED] - Not supported for plain surfaces\n");
2719             return WINED3DERR_NOTAVAILABLE;
2720         }
2721
2722     } else if(RType == WINED3DRTYPE_TEXTURE) {
2723         /* Texture allows:
2724          *                - D3DUSAGE_AUTOGENMIPMAP
2725          *                - D3DUSAGE_DEPTHSTENCIL
2726          *                - D3DUSAGE_DMAP
2727          *                - D3DUSAGE_DYNAMIC
2728          *                - D3DUSAGE_NONSECURE (d3d9ex)
2729          *                - D3DUSAGE_RENDERTARGET
2730          *                - D3DUSAGE_SOFTWAREPROCESSING
2731          *                - D3DUSAGE_TEXTAPI (d3d9ex)
2732          *                - D3DUSAGE_QUERY_WRAPANDMIP
2733          */
2734
2735         if(SurfaceType != SURFACE_OPENGL) {
2736             TRACE("[FAILED]\n");
2737             return WINED3DERR_NOTAVAILABLE;
2738         }
2739
2740         /* Check if the texture format is around */
2741         if (CheckTextureCapability(adapter, DeviceType, CheckFormat))
2742         {
2743             if(Usage & WINED3DUSAGE_AUTOGENMIPMAP) {
2744                 /* Check for automatic mipmap generation support */
2745                 if(GL_SUPPORT(SGIS_GENERATE_MIPMAP)) {
2746                     UsageCaps |= WINED3DUSAGE_AUTOGENMIPMAP;
2747                 } else {
2748                     /* When autogenmipmap isn't around continue and return WINED3DOK_NOAUTOGEN instead of D3D_OK */
2749                     TRACE_(d3d_caps)("[FAILED] - No autogenmipmap support, but continuing\n");
2750                 }
2751             }
2752
2753             /* Always report dynamic locking */
2754             if(Usage & WINED3DUSAGE_DYNAMIC)
2755                 UsageCaps |= WINED3DUSAGE_DYNAMIC;
2756
2757             if(Usage & WINED3DUSAGE_RENDERTARGET) {
2758                 if (CheckRenderTargetCapability(adapter, AdapterFormat, CheckFormat))
2759                 {
2760                     UsageCaps |= WINED3DUSAGE_RENDERTARGET;
2761                 } else {
2762                     TRACE_(d3d_caps)("[FAILED] - No rendertarget support\n");
2763                      return WINED3DERR_NOTAVAILABLE;
2764                  }
2765             }
2766
2767             /* Always report software processing */
2768             if(Usage & WINED3DUSAGE_SOFTWAREPROCESSING)
2769                 UsageCaps |= WINED3DUSAGE_SOFTWAREPROCESSING;
2770
2771             /* Check QUERY_FILTER support */
2772             if(Usage & WINED3DUSAGE_QUERY_FILTER) {
2773                 if (CheckFilterCapability(adapter, CheckFormat))
2774                 {
2775                     UsageCaps |= WINED3DUSAGE_QUERY_FILTER;
2776                 } else {
2777                     TRACE_(d3d_caps)("[FAILED] - No query filter support\n");
2778                     return WINED3DERR_NOTAVAILABLE;
2779                 }
2780             }
2781
2782             /* Check QUERY_LEGACYBUMPMAP support */
2783             if(Usage & WINED3DUSAGE_QUERY_LEGACYBUMPMAP) {
2784                 if (CheckBumpMapCapability(adapter, DeviceType, CheckFormat))
2785                 {
2786                     UsageCaps |= WINED3DUSAGE_QUERY_LEGACYBUMPMAP;
2787                 } else {
2788                     TRACE_(d3d_caps)("[FAILED] - No legacy bumpmap support\n");
2789                     return WINED3DERR_NOTAVAILABLE;
2790                 }
2791             }
2792
2793             /* Check QUERY_POSTPIXELSHADER_BLENDING support */
2794             if(Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING) {
2795                 if (CheckPostPixelShaderBlendingCapability(adapter, CheckFormat))
2796                 {
2797                     UsageCaps |= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
2798                 } else {
2799                     TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
2800                     return WINED3DERR_NOTAVAILABLE;
2801                 }
2802             }
2803
2804             /* Check QUERY_SRGBREAD support */
2805             if(Usage & WINED3DUSAGE_QUERY_SRGBREAD) {
2806                 if (CheckSrgbReadCapability(adapter, CheckFormat))
2807                 {
2808                     UsageCaps |= WINED3DUSAGE_QUERY_SRGBREAD;
2809                 } else {
2810                     TRACE_(d3d_caps)("[FAILED] - No query srgbread support\n");
2811                     return WINED3DERR_NOTAVAILABLE;
2812                 }
2813             }
2814
2815             /* Check QUERY_SRGBWRITE support */
2816             if(Usage & WINED3DUSAGE_QUERY_SRGBWRITE) {
2817                 if (CheckSrgbWriteCapability(adapter, DeviceType, CheckFormat))
2818                 {
2819                     UsageCaps |= WINED3DUSAGE_QUERY_SRGBWRITE;
2820                 } else {
2821                     TRACE_(d3d_caps)("[FAILED] - No query srgbwrite support\n");
2822                     return WINED3DERR_NOTAVAILABLE;
2823                 }
2824             }
2825
2826             /* Check QUERY_VERTEXTEXTURE support */
2827             if(Usage & WINED3DUSAGE_QUERY_VERTEXTEXTURE) {
2828                 if (CheckVertexTextureCapability(adapter, CheckFormat))
2829                 {
2830                     UsageCaps |= WINED3DUSAGE_QUERY_VERTEXTEXTURE;
2831                 } else {
2832                     TRACE_(d3d_caps)("[FAILED] - No query vertextexture support\n");
2833                     return WINED3DERR_NOTAVAILABLE;
2834                 }
2835             }
2836
2837             /* Check QUERY_WRAPANDMIP support */
2838             if(Usage & WINED3DUSAGE_QUERY_WRAPANDMIP) {
2839                 if(CheckWrapAndMipCapability(Adapter, CheckFormat)) {
2840                     UsageCaps |= WINED3DUSAGE_QUERY_WRAPANDMIP;
2841                 } else {
2842                     TRACE_(d3d_caps)("[FAILED] - No wrapping and mipmapping support\n");
2843                     return WINED3DERR_NOTAVAILABLE;
2844                 }
2845             }
2846
2847             if(Usage & WINED3DUSAGE_DEPTHSTENCIL) {
2848                 if (CheckDepthStencilCapability(adapter, AdapterFormat, CheckFormat))
2849                 {
2850                     UsageCaps |= WINED3DUSAGE_DEPTHSTENCIL;
2851                 } else {
2852                     TRACE_(d3d_caps)("[FAILED] - No depth stencil support\n");
2853                     return WINED3DERR_NOTAVAILABLE;
2854                 }
2855             }
2856         } else {
2857             TRACE_(d3d_caps)("[FAILED] - Texture format not supported\n");
2858             return WINED3DERR_NOTAVAILABLE;
2859         }
2860     } else if((RType == WINED3DRTYPE_VOLUME) || (RType == WINED3DRTYPE_VOLUMETEXTURE)) {
2861         /* Volume is to VolumeTexture what Surface is to Texture but its usage caps are not documented.
2862          * Most driver seem to offer (nearly) the same on Volume and VolumeTexture, so do that too.
2863          *
2864          * Volumetexture allows:
2865          *                      - D3DUSAGE_DYNAMIC
2866          *                      - D3DUSAGE_NONSECURE (d3d9ex)
2867          *                      - D3DUSAGE_SOFTWAREPROCESSING
2868          *                      - D3DUSAGE_QUERY_WRAPANDMIP
2869          */
2870
2871         if(SurfaceType != SURFACE_OPENGL) {
2872             TRACE("[FAILED]\n");
2873             return WINED3DERR_NOTAVAILABLE;
2874         }
2875
2876         /* Check volume texture and volume usage caps */
2877         if(GL_SUPPORT(EXT_TEXTURE3D)) {
2878             if (!CheckTextureCapability(adapter, DeviceType, CheckFormat))
2879             {
2880                 TRACE_(d3d_caps)("[FAILED] - Format not supported\n");
2881                 return WINED3DERR_NOTAVAILABLE;
2882             }
2883
2884             /* Always report dynamic locking */
2885             if(Usage & WINED3DUSAGE_DYNAMIC)
2886                 UsageCaps |= WINED3DUSAGE_DYNAMIC;
2887
2888             /* Always report software processing */
2889             if(Usage & WINED3DUSAGE_SOFTWAREPROCESSING)
2890                 UsageCaps |= WINED3DUSAGE_SOFTWAREPROCESSING;
2891
2892             /* Check QUERY_FILTER support */
2893             if(Usage & WINED3DUSAGE_QUERY_FILTER) {
2894                 if (CheckFilterCapability(adapter, CheckFormat))
2895                 {
2896                     UsageCaps |= WINED3DUSAGE_QUERY_FILTER;
2897                 } else {
2898                     TRACE_(d3d_caps)("[FAILED] - No query filter support\n");
2899                     return WINED3DERR_NOTAVAILABLE;
2900                 }
2901             }
2902
2903             /* Check QUERY_POSTPIXELSHADER_BLENDING support */
2904             if(Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING) {
2905                 if (CheckPostPixelShaderBlendingCapability(adapter, CheckFormat))
2906                 {
2907                     UsageCaps |= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
2908                 } else {
2909                     TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
2910                     return WINED3DERR_NOTAVAILABLE;
2911                 }
2912             }
2913
2914             /* Check QUERY_SRGBREAD support */
2915             if(Usage & WINED3DUSAGE_QUERY_SRGBREAD) {
2916                 if (CheckSrgbReadCapability(adapter, CheckFormat))
2917                 {
2918                     UsageCaps |= WINED3DUSAGE_QUERY_SRGBREAD;
2919                 } else {
2920                     TRACE_(d3d_caps)("[FAILED] - No query srgbread support\n");
2921                     return WINED3DERR_NOTAVAILABLE;
2922                 }
2923             }
2924
2925             /* Check QUERY_SRGBWRITE support */
2926             if(Usage & WINED3DUSAGE_QUERY_SRGBWRITE) {
2927                 if (CheckSrgbWriteCapability(adapter, DeviceType, CheckFormat))
2928                 {
2929                     UsageCaps |= WINED3DUSAGE_QUERY_SRGBWRITE;
2930                 } else {
2931                     TRACE_(d3d_caps)("[FAILED] - No query srgbwrite support\n");
2932                     return WINED3DERR_NOTAVAILABLE;
2933                 }
2934             }
2935
2936             /* Check QUERY_VERTEXTEXTURE support */
2937             if(Usage & WINED3DUSAGE_QUERY_VERTEXTEXTURE) {
2938                 if (CheckVertexTextureCapability(adapter, CheckFormat))
2939                 {
2940                     UsageCaps |= WINED3DUSAGE_QUERY_VERTEXTEXTURE;
2941                 } else {
2942                     TRACE_(d3d_caps)("[FAILED] - No query vertextexture support\n");
2943                     return WINED3DERR_NOTAVAILABLE;
2944                 }
2945             }
2946
2947             /* Check QUERY_WRAPANDMIP support */
2948             if(Usage & WINED3DUSAGE_QUERY_WRAPANDMIP) {
2949                 if(CheckWrapAndMipCapability(Adapter, CheckFormat)) {
2950                     UsageCaps |= WINED3DUSAGE_QUERY_WRAPANDMIP;
2951                 } else {
2952                     TRACE_(d3d_caps)("[FAILED] - No wrapping and mipmapping support\n");
2953                     return WINED3DERR_NOTAVAILABLE;
2954                 }
2955             }
2956         } else {
2957             TRACE_(d3d_caps)("[FAILED] - No volume texture support\n");
2958             return WINED3DERR_NOTAVAILABLE;
2959         }
2960
2961         /* Filter formats that need conversion; For one part, this conversion is unimplemented,
2962          * and volume textures are huge, so it would be a big performance hit. Unless we hit an
2963          * app needing one of those formats, don't advertize them to avoid leading apps into
2964          * temptation. The windows drivers don't support most of those formats on volumes anyway,
2965          * except of R32F.
2966          */
2967         switch(CheckFormat) {
2968             case WINED3DFMT_P8:
2969             case WINED3DFMT_A4L4:
2970             case WINED3DFMT_R32_FLOAT:
2971             case WINED3DFMT_R16_FLOAT:
2972             case WINED3DFMT_X8L8V8U8:
2973             case WINED3DFMT_L6V5U5:
2974             case WINED3DFMT_R16G16_UNORM:
2975                 TRACE_(d3d_caps)("[FAILED] - No converted formats on volumes\n");
2976                 return WINED3DERR_NOTAVAILABLE;
2977
2978             case WINED3DFMT_R8G8B8A8_SNORM:
2979             case WINED3DFMT_R16G16_SNORM:
2980             if(!GL_SUPPORT(NV_TEXTURE_SHADER)) {
2981                 TRACE_(d3d_caps)("[FAILED] - No converted formats on volumes\n");
2982                 return WINED3DERR_NOTAVAILABLE;
2983             }
2984             break;
2985
2986             case WINED3DFMT_R8G8_SNORM:
2987             if(!GL_SUPPORT(NV_TEXTURE_SHADER)) {
2988                 TRACE_(d3d_caps)("[FAILED] - No converted formats on volumes\n");
2989                 return WINED3DERR_NOTAVAILABLE;
2990             }
2991             break;
2992
2993             case WINED3DFMT_DXT1:
2994             case WINED3DFMT_DXT2:
2995             case WINED3DFMT_DXT3:
2996             case WINED3DFMT_DXT4:
2997             case WINED3DFMT_DXT5:
2998                 /* The GL_EXT_texture_compression_s3tc spec requires that loading an s3tc
2999                  * compressed texture results in an error. While the D3D refrast does
3000                  * support s3tc volumes, at least the nvidia windows driver does not, so
3001                  * we're free not to support this format.
3002                  */
3003                 TRACE_(d3d_caps)("[FAILED] - DXTn does not support 3D textures\n");
3004                 return WINED3DERR_NOTAVAILABLE;
3005
3006             default:
3007                 /* Do nothing, continue with checking the format below */
3008                 break;
3009         }
3010     } else if((RType == WINED3DRTYPE_INDEXBUFFER) || (RType == WINED3DRTYPE_VERTEXBUFFER)){
3011         /* For instance vertexbuffer/indexbuffer aren't supported yet because no Windows drivers seem to offer it */
3012         TRACE_(d3d_caps)("Unhandled resource type D3DRTYPE_INDEXBUFFER / D3DRTYPE_VERTEXBUFFER\n");
3013         return WINED3DERR_NOTAVAILABLE;
3014     }
3015
3016     /* This format is nothing special and it is supported perfectly.
3017      * However, ati and nvidia driver on windows do not mark this format as
3018      * supported (tested with the dxCapsViewer) and pretending to
3019      * support this format uncovers a bug in Battlefield 1942 (fonts are missing)
3020      * So do the same as Windows drivers and pretend not to support it on dx8 and 9
3021      * Enable it on dx7. It will need additional checking on dx10 when we support it.
3022      */
3023     if(This->dxVersion > 7 && CheckFormat == WINED3DFMT_R8G8B8) {
3024         TRACE_(d3d_caps)("[FAILED]\n");
3025         return WINED3DERR_NOTAVAILABLE;
3026     }
3027
3028     /* When the UsageCaps exactly matches Usage return WINED3D_OK except for the situation in which
3029      * WINED3DUSAGE_AUTOGENMIPMAP isn't around, then WINED3DOK_NOAUTOGEN is returned if all the other
3030      * usage flags match. */
3031     if(UsageCaps == Usage) {
3032         return WINED3D_OK;
3033     } else if((UsageCaps == (Usage & ~WINED3DUSAGE_AUTOGENMIPMAP)) && (Usage & WINED3DUSAGE_AUTOGENMIPMAP)){
3034         return WINED3DOK_NOAUTOGEN;
3035     } else {
3036         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);
3037         return WINED3DERR_NOTAVAILABLE;
3038     }
3039 }
3040
3041 static HRESULT  WINAPI IWineD3DImpl_CheckDeviceFormatConversion(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
3042                                                           WINED3DFORMAT SourceFormat, WINED3DFORMAT TargetFormat) {
3043     IWineD3DImpl *This = (IWineD3DImpl *)iface;
3044
3045     FIXME_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, DevType:(%u,%s), SrcFmt:(%u,%s), TgtFmt:(%u,%s))\n",
3046           This,
3047           Adapter,
3048           DeviceType, debug_d3ddevicetype(DeviceType),
3049           SourceFormat, debug_d3dformat(SourceFormat),
3050           TargetFormat, debug_d3dformat(TargetFormat));
3051     return WINED3D_OK;
3052 }
3053
3054 static const shader_backend_t *select_shader_backend(struct WineD3DAdapter *adapter, WINED3DDEVTYPE DeviceType)
3055 {
3056     const shader_backend_t *ret;
3057     int vs_selected_mode;
3058     int ps_selected_mode;
3059
3060     select_shader_mode(&adapter->gl_info, DeviceType, &ps_selected_mode, &vs_selected_mode);
3061     if (vs_selected_mode == SHADER_GLSL || ps_selected_mode == SHADER_GLSL) {
3062         ret = &glsl_shader_backend;
3063     } else if (vs_selected_mode == SHADER_ARB || ps_selected_mode == SHADER_ARB) {
3064         ret = &arb_program_shader_backend;
3065     } else {
3066         ret = &none_shader_backend;
3067     }
3068     return ret;
3069 }
3070
3071 static const struct fragment_pipeline *select_fragment_implementation(struct WineD3DAdapter *adapter,
3072         WINED3DDEVTYPE DeviceType)
3073 {
3074     const WineD3D_GL_Info *gl_info = &adapter->gl_info;
3075     int vs_selected_mode;
3076     int ps_selected_mode;
3077
3078     select_shader_mode(&adapter->gl_info, DeviceType, &ps_selected_mode, &vs_selected_mode);
3079     if((ps_selected_mode == SHADER_ARB || ps_selected_mode == SHADER_GLSL) && GL_SUPPORT(ARB_FRAGMENT_PROGRAM)) {
3080         return &arbfp_fragment_pipeline;
3081     } else if(ps_selected_mode == SHADER_ATI) {
3082         return &atifs_fragment_pipeline;
3083     } else if(GL_SUPPORT(NV_REGISTER_COMBINERS) && GL_SUPPORT(NV_TEXTURE_SHADER2)) {
3084         return &nvts_fragment_pipeline;
3085     } else if(GL_SUPPORT(NV_REGISTER_COMBINERS)) {
3086         return &nvrc_fragment_pipeline;
3087     } else {
3088         return &ffp_fragment_pipeline;
3089     }
3090 }
3091
3092 static const struct blit_shader *select_blit_implementation(struct WineD3DAdapter *adapter, WINED3DDEVTYPE DeviceType)
3093 {
3094     const WineD3D_GL_Info *gl_info = &adapter->gl_info;
3095     int vs_selected_mode;
3096     int ps_selected_mode;
3097
3098     select_shader_mode(&adapter->gl_info, DeviceType, &ps_selected_mode, &vs_selected_mode);
3099     if((ps_selected_mode == SHADER_ARB || ps_selected_mode == SHADER_GLSL) && GL_SUPPORT(ARB_FRAGMENT_PROGRAM)) {
3100         return &arbfp_blit;
3101     } else {
3102         return &ffp_blit;
3103     }
3104 }
3105
3106 /* Note: d3d8 passes in a pointer to a D3DCAPS8 structure, which is a true
3107       subset of a D3DCAPS9 structure. However, it has to come via a void *
3108       as the d3d8 interface cannot import the d3d9 header                  */
3109 static HRESULT WINAPI IWineD3DImpl_GetDeviceCaps(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType, WINED3DCAPS* pCaps) {
3110
3111     IWineD3DImpl    *This = (IWineD3DImpl *)iface;
3112     struct WineD3DAdapter *adapter = &This->adapters[Adapter];
3113     const WineD3D_GL_Info *gl_info = &adapter->gl_info;
3114     int vs_selected_mode;
3115     int ps_selected_mode;
3116     struct shader_caps shader_caps;
3117     struct fragment_caps fragment_caps;
3118     const shader_backend_t *shader_backend;
3119     const struct fragment_pipeline *frag_pipeline = NULL;
3120     DWORD ckey_caps, blit_caps, fx_caps;
3121
3122     TRACE_(d3d_caps)("(%p)->(Adptr:%d, DevType: %x, pCaps: %p)\n", This, Adapter, DeviceType, pCaps);
3123
3124     if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
3125         return WINED3DERR_INVALIDCALL;
3126     }
3127
3128     select_shader_mode(&adapter->gl_info, DeviceType, &ps_selected_mode, &vs_selected_mode);
3129
3130     /* This function should *not* be modifying GL caps
3131      * TODO: move the functionality where it belongs */
3132     select_shader_max_constants(ps_selected_mode, vs_selected_mode, &adapter->gl_info);
3133
3134     /* ------------------------------------------------
3135        The following fields apply to both d3d8 and d3d9
3136        ------------------------------------------------ */
3137     pCaps->DeviceType              = (DeviceType == WINED3DDEVTYPE_HAL) ? WINED3DDEVTYPE_HAL : WINED3DDEVTYPE_REF;  /* Not quite true, but use h/w supported by opengl I suppose */
3138     pCaps->AdapterOrdinal          = Adapter;
3139
3140     pCaps->Caps                    = 0;
3141     pCaps->Caps2                   = WINED3DCAPS2_CANRENDERWINDOWED |
3142                                      WINED3DCAPS2_FULLSCREENGAMMA |
3143                                      WINED3DCAPS2_DYNAMICTEXTURES;
3144     if(GL_SUPPORT(SGIS_GENERATE_MIPMAP)) {
3145         pCaps->Caps2 |= WINED3DCAPS2_CANAUTOGENMIPMAP;
3146     }
3147
3148     pCaps->Caps3                   = WINED3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD |
3149                                      WINED3DCAPS3_COPY_TO_VIDMEM                   |
3150                                      WINED3DCAPS3_COPY_TO_SYSTEMMEM;
3151
3152     pCaps->PresentationIntervals   = WINED3DPRESENT_INTERVAL_IMMEDIATE  |
3153                                      WINED3DPRESENT_INTERVAL_ONE;
3154
3155     pCaps->CursorCaps              = WINED3DCURSORCAPS_COLOR            |
3156                                      WINED3DCURSORCAPS_LOWRES;
3157
3158     pCaps->DevCaps                 = WINED3DDEVCAPS_FLOATTLVERTEX       |
3159                                      WINED3DDEVCAPS_EXECUTESYSTEMMEMORY |
3160                                      WINED3DDEVCAPS_TLVERTEXSYSTEMMEMORY|
3161                                      WINED3DDEVCAPS_TLVERTEXVIDEOMEMORY |
3162                                      WINED3DDEVCAPS_DRAWPRIMTLVERTEX    |
3163                                      WINED3DDEVCAPS_HWTRANSFORMANDLIGHT |
3164                                      WINED3DDEVCAPS_EXECUTEVIDEOMEMORY  |
3165                                      WINED3DDEVCAPS_PUREDEVICE          |
3166                                      WINED3DDEVCAPS_HWRASTERIZATION     |
3167                                      WINED3DDEVCAPS_TEXTUREVIDEOMEMORY  |
3168                                      WINED3DDEVCAPS_TEXTURESYSTEMMEMORY |
3169                                      WINED3DDEVCAPS_CANRENDERAFTERFLIP  |
3170                                      WINED3DDEVCAPS_DRAWPRIMITIVES2     |
3171                                      WINED3DDEVCAPS_DRAWPRIMITIVES2EX   |
3172                                      WINED3DDEVCAPS_RTPATCHES;
3173
3174     pCaps->PrimitiveMiscCaps       = WINED3DPMISCCAPS_CULLNONE              |
3175                                      WINED3DPMISCCAPS_CULLCCW               |
3176                                      WINED3DPMISCCAPS_CULLCW                |
3177                                      WINED3DPMISCCAPS_COLORWRITEENABLE      |
3178                                      WINED3DPMISCCAPS_CLIPTLVERTS           |
3179                                      WINED3DPMISCCAPS_CLIPPLANESCALEDPOINTS |
3180                                      WINED3DPMISCCAPS_MASKZ                 |
3181                                      WINED3DPMISCCAPS_BLENDOP               |
3182                                      WINED3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING;
3183                                     /* TODO:
3184                                         WINED3DPMISCCAPS_NULLREFERENCE
3185                                         WINED3DPMISCCAPS_INDEPENDENTWRITEMASKS
3186                                         WINED3DPMISCCAPS_FOGANDSPECULARALPHA
3187                                         WINED3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS
3188                                         WINED3DPMISCCAPS_FOGVERTEXCLAMPED */
3189
3190     if(GL_SUPPORT(EXT_BLEND_EQUATION_SEPARATE) && GL_SUPPORT(EXT_BLEND_FUNC_SEPARATE))
3191         pCaps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_SEPARATEALPHABLEND;
3192
3193     pCaps->RasterCaps              = WINED3DPRASTERCAPS_DITHER    |
3194                                      WINED3DPRASTERCAPS_PAT       |
3195                                      WINED3DPRASTERCAPS_WFOG      |
3196                                      WINED3DPRASTERCAPS_ZFOG      |
3197                                      WINED3DPRASTERCAPS_FOGVERTEX |
3198                                      WINED3DPRASTERCAPS_FOGTABLE  |
3199                                      WINED3DPRASTERCAPS_STIPPLE   |
3200                                      WINED3DPRASTERCAPS_SUBPIXEL  |
3201                                      WINED3DPRASTERCAPS_ZTEST     |
3202                                      WINED3DPRASTERCAPS_SCISSORTEST   |
3203                                      WINED3DPRASTERCAPS_SLOPESCALEDEPTHBIAS |
3204                                      WINED3DPRASTERCAPS_DEPTHBIAS;
3205
3206     if (GL_SUPPORT(EXT_TEXTURE_FILTER_ANISOTROPIC)) {
3207         pCaps->RasterCaps |= WINED3DPRASTERCAPS_ANISOTROPY    |
3208                              WINED3DPRASTERCAPS_ZBIAS         |
3209                              WINED3DPRASTERCAPS_MIPMAPLODBIAS;
3210     }
3211     if(GL_SUPPORT(NV_FOG_DISTANCE)) {
3212         pCaps->RasterCaps         |= WINED3DPRASTERCAPS_FOGRANGE;
3213     }
3214                         /* FIXME Add:
3215                            WINED3DPRASTERCAPS_COLORPERSPECTIVE
3216                            WINED3DPRASTERCAPS_STRETCHBLTMULTISAMPLE
3217                            WINED3DPRASTERCAPS_ANTIALIASEDGES
3218                            WINED3DPRASTERCAPS_ZBUFFERLESSHSR
3219                            WINED3DPRASTERCAPS_WBUFFER */
3220
3221     pCaps->ZCmpCaps = WINED3DPCMPCAPS_ALWAYS       |
3222                       WINED3DPCMPCAPS_EQUAL        |
3223                       WINED3DPCMPCAPS_GREATER      |
3224                       WINED3DPCMPCAPS_GREATEREQUAL |
3225                       WINED3DPCMPCAPS_LESS         |
3226                       WINED3DPCMPCAPS_LESSEQUAL    |
3227                       WINED3DPCMPCAPS_NEVER        |
3228                       WINED3DPCMPCAPS_NOTEQUAL;
3229
3230     pCaps->SrcBlendCaps  = WINED3DPBLENDCAPS_BOTHINVSRCALPHA |
3231                            WINED3DPBLENDCAPS_BOTHSRCALPHA    |
3232                            WINED3DPBLENDCAPS_DESTALPHA       |
3233                            WINED3DPBLENDCAPS_DESTCOLOR       |
3234                            WINED3DPBLENDCAPS_INVDESTALPHA    |
3235                            WINED3DPBLENDCAPS_INVDESTCOLOR    |
3236                            WINED3DPBLENDCAPS_INVSRCALPHA     |
3237                            WINED3DPBLENDCAPS_INVSRCCOLOR     |
3238                            WINED3DPBLENDCAPS_ONE             |
3239                            WINED3DPBLENDCAPS_SRCALPHA        |
3240                            WINED3DPBLENDCAPS_SRCALPHASAT     |
3241                            WINED3DPBLENDCAPS_SRCCOLOR        |
3242                            WINED3DPBLENDCAPS_ZERO;
3243
3244     pCaps->DestBlendCaps = WINED3DPBLENDCAPS_DESTALPHA       |
3245                            WINED3DPBLENDCAPS_DESTCOLOR       |
3246                            WINED3DPBLENDCAPS_INVDESTALPHA    |
3247                            WINED3DPBLENDCAPS_INVDESTCOLOR    |
3248                            WINED3DPBLENDCAPS_INVSRCALPHA     |
3249                            WINED3DPBLENDCAPS_INVSRCCOLOR     |
3250                            WINED3DPBLENDCAPS_ONE             |
3251                            WINED3DPBLENDCAPS_SRCALPHA        |
3252                            WINED3DPBLENDCAPS_SRCCOLOR        |
3253                            WINED3DPBLENDCAPS_ZERO;
3254     /* NOTE: WINED3DPBLENDCAPS_SRCALPHASAT is not supported as dest blend factor,
3255      * according to the glBlendFunc manpage
3256      *
3257      * WINED3DPBLENDCAPS_BOTHINVSRCALPHA and WINED3DPBLENDCAPS_BOTHSRCALPHA are
3258      * legacy settings for srcblend only
3259      */
3260
3261     if( GL_SUPPORT(EXT_BLEND_COLOR)) {
3262         pCaps->SrcBlendCaps |= WINED3DPBLENDCAPS_BLENDFACTOR;
3263         pCaps->DestBlendCaps |= WINED3DPBLENDCAPS_BLENDFACTOR;
3264     }
3265
3266
3267     pCaps->AlphaCmpCaps = WINED3DPCMPCAPS_ALWAYS       |
3268                           WINED3DPCMPCAPS_EQUAL        |
3269                           WINED3DPCMPCAPS_GREATER      |
3270                           WINED3DPCMPCAPS_GREATEREQUAL |
3271                           WINED3DPCMPCAPS_LESS         |
3272                           WINED3DPCMPCAPS_LESSEQUAL    |
3273                           WINED3DPCMPCAPS_NEVER        |
3274                           WINED3DPCMPCAPS_NOTEQUAL;
3275
3276     pCaps->ShadeCaps     = WINED3DPSHADECAPS_SPECULARGOURAUDRGB |
3277                            WINED3DPSHADECAPS_COLORGOURAUDRGB    |
3278                            WINED3DPSHADECAPS_ALPHAFLATBLEND     |
3279                            WINED3DPSHADECAPS_ALPHAGOURAUDBLEND  |
3280                            WINED3DPSHADECAPS_COLORFLATRGB       |
3281                            WINED3DPSHADECAPS_FOGFLAT            |
3282                            WINED3DPSHADECAPS_FOGGOURAUD         |
3283                            WINED3DPSHADECAPS_SPECULARFLATRGB;
3284
3285     pCaps->TextureCaps =  WINED3DPTEXTURECAPS_ALPHA              |
3286                           WINED3DPTEXTURECAPS_ALPHAPALETTE       |
3287                           WINED3DPTEXTURECAPS_TRANSPARENCY       |
3288                           WINED3DPTEXTURECAPS_BORDER             |
3289                           WINED3DPTEXTURECAPS_MIPMAP             |
3290                           WINED3DPTEXTURECAPS_PROJECTED          |
3291                           WINED3DPTEXTURECAPS_PERSPECTIVE;
3292
3293     if( !GL_SUPPORT(ARB_TEXTURE_NON_POWER_OF_TWO)) {
3294         pCaps->TextureCaps |= WINED3DPTEXTURECAPS_POW2 |
3295                               WINED3DPTEXTURECAPS_NONPOW2CONDITIONAL;
3296     }
3297
3298     if( GL_SUPPORT(EXT_TEXTURE3D)) {
3299         pCaps->TextureCaps |=  WINED3DPTEXTURECAPS_VOLUMEMAP      |
3300                                WINED3DPTEXTURECAPS_MIPVOLUMEMAP   |
3301                                WINED3DPTEXTURECAPS_VOLUMEMAP_POW2;
3302     }
3303
3304     if (GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
3305         pCaps->TextureCaps |= WINED3DPTEXTURECAPS_CUBEMAP     |
3306                               WINED3DPTEXTURECAPS_MIPCUBEMAP    |
3307                               WINED3DPTEXTURECAPS_CUBEMAP_POW2;
3308
3309     }
3310
3311     pCaps->TextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR       |
3312                                WINED3DPTFILTERCAPS_MAGFPOINT        |
3313                                WINED3DPTFILTERCAPS_MINFLINEAR       |
3314                                WINED3DPTFILTERCAPS_MINFPOINT        |
3315                                WINED3DPTFILTERCAPS_MIPFLINEAR       |
3316                                WINED3DPTFILTERCAPS_MIPFPOINT        |
3317                                WINED3DPTFILTERCAPS_LINEAR           |
3318                                WINED3DPTFILTERCAPS_LINEARMIPLINEAR  |
3319                                WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
3320                                WINED3DPTFILTERCAPS_MIPLINEAR        |
3321                                WINED3DPTFILTERCAPS_MIPNEAREST       |
3322                                WINED3DPTFILTERCAPS_NEAREST;
3323
3324     if (GL_SUPPORT(EXT_TEXTURE_FILTER_ANISOTROPIC)) {
3325         pCaps->TextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC |
3326                                     WINED3DPTFILTERCAPS_MINFANISOTROPIC;
3327     }
3328
3329     if (GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
3330         pCaps->CubeTextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR       |
3331                                        WINED3DPTFILTERCAPS_MAGFPOINT        |
3332                                        WINED3DPTFILTERCAPS_MINFLINEAR       |
3333                                        WINED3DPTFILTERCAPS_MINFPOINT        |
3334                                        WINED3DPTFILTERCAPS_MIPFLINEAR       |
3335                                        WINED3DPTFILTERCAPS_MIPFPOINT        |
3336                                        WINED3DPTFILTERCAPS_LINEAR           |
3337                                        WINED3DPTFILTERCAPS_LINEARMIPLINEAR  |
3338                                        WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
3339                                        WINED3DPTFILTERCAPS_MIPLINEAR        |
3340                                        WINED3DPTFILTERCAPS_MIPNEAREST       |
3341                                        WINED3DPTFILTERCAPS_NEAREST;
3342
3343         if (GL_SUPPORT(EXT_TEXTURE_FILTER_ANISOTROPIC)) {
3344             pCaps->CubeTextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC |
3345                                             WINED3DPTFILTERCAPS_MINFANISOTROPIC;
3346         }
3347     } else
3348         pCaps->CubeTextureFilterCaps = 0;
3349
3350     if (GL_SUPPORT(EXT_TEXTURE3D)) {
3351         pCaps->VolumeTextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR       |
3352                                          WINED3DPTFILTERCAPS_MAGFPOINT        |
3353                                          WINED3DPTFILTERCAPS_MINFLINEAR       |
3354                                          WINED3DPTFILTERCAPS_MINFPOINT        |
3355                                          WINED3DPTFILTERCAPS_MIPFLINEAR       |
3356                                          WINED3DPTFILTERCAPS_MIPFPOINT        |
3357                                          WINED3DPTFILTERCAPS_LINEAR           |
3358                                          WINED3DPTFILTERCAPS_LINEARMIPLINEAR  |
3359                                          WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
3360                                          WINED3DPTFILTERCAPS_MIPLINEAR        |
3361                                          WINED3DPTFILTERCAPS_MIPNEAREST       |
3362                                          WINED3DPTFILTERCAPS_NEAREST;
3363     } else
3364         pCaps->VolumeTextureFilterCaps = 0;
3365
3366     pCaps->TextureAddressCaps =  WINED3DPTADDRESSCAPS_INDEPENDENTUV |
3367                                  WINED3DPTADDRESSCAPS_CLAMP  |
3368                                  WINED3DPTADDRESSCAPS_WRAP;
3369
3370     if (GL_SUPPORT(ARB_TEXTURE_BORDER_CLAMP)) {
3371         pCaps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_BORDER;
3372     }
3373     if (GL_SUPPORT(ARB_TEXTURE_MIRRORED_REPEAT)) {
3374         pCaps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRROR;
3375     }
3376     if (GL_SUPPORT(ATI_TEXTURE_MIRROR_ONCE)) {
3377         pCaps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRRORONCE;
3378     }
3379
3380     if (GL_SUPPORT(EXT_TEXTURE3D)) {
3381         pCaps->VolumeTextureAddressCaps =  WINED3DPTADDRESSCAPS_INDEPENDENTUV |
3382                                            WINED3DPTADDRESSCAPS_CLAMP  |
3383                                            WINED3DPTADDRESSCAPS_WRAP;
3384         if (GL_SUPPORT(ARB_TEXTURE_BORDER_CLAMP)) {
3385             pCaps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_BORDER;
3386         }
3387         if (GL_SUPPORT(ARB_TEXTURE_MIRRORED_REPEAT)) {
3388             pCaps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRROR;
3389         }
3390         if (GL_SUPPORT(ATI_TEXTURE_MIRROR_ONCE)) {
3391             pCaps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRRORONCE;
3392         }
3393     } else
3394         pCaps->VolumeTextureAddressCaps = 0;
3395
3396     pCaps->LineCaps = WINED3DLINECAPS_TEXTURE       |
3397                       WINED3DLINECAPS_ZTEST         |
3398                       WINED3DLINECAPS_BLEND         |
3399                       WINED3DLINECAPS_ALPHACMP      |
3400                       WINED3DLINECAPS_FOG;
3401     /* WINED3DLINECAPS_ANTIALIAS is not supported on Windows, and dx and gl seem to have a different
3402      * idea how generating the smoothing alpha values works; the result is different
3403      */
3404
3405     pCaps->MaxTextureWidth  = GL_LIMITS(texture_size);
3406     pCaps->MaxTextureHeight = GL_LIMITS(texture_size);
3407
3408     if(GL_SUPPORT(EXT_TEXTURE3D))
3409         pCaps->MaxVolumeExtent = GL_LIMITS(texture3d_size);
3410     else
3411         pCaps->MaxVolumeExtent = 0;
3412
3413     pCaps->MaxTextureRepeat = 32768;
3414     pCaps->MaxTextureAspectRatio = GL_LIMITS(texture_size);
3415     pCaps->MaxVertexW = 1.0;
3416
3417     pCaps->GuardBandLeft = 0;
3418     pCaps->GuardBandTop = 0;
3419     pCaps->GuardBandRight = 0;
3420     pCaps->GuardBandBottom = 0;
3421
3422     pCaps->ExtentsAdjust = 0;
3423
3424     pCaps->StencilCaps =  WINED3DSTENCILCAPS_DECRSAT |
3425                           WINED3DSTENCILCAPS_INCRSAT |
3426                           WINED3DSTENCILCAPS_INVERT  |
3427                           WINED3DSTENCILCAPS_KEEP    |
3428                           WINED3DSTENCILCAPS_REPLACE |
3429                           WINED3DSTENCILCAPS_ZERO;
3430     if (GL_SUPPORT(EXT_STENCIL_WRAP)) {
3431         pCaps->StencilCaps |= WINED3DSTENCILCAPS_DECR  |
3432                               WINED3DSTENCILCAPS_INCR;
3433     }
3434     if ( This->dxVersion > 8 &&
3435         ( GL_SUPPORT(EXT_STENCIL_TWO_SIDE) ||
3436             GL_SUPPORT(ATI_SEPARATE_STENCIL) ) ) {
3437         pCaps->StencilCaps |= WINED3DSTENCILCAPS_TWOSIDED;
3438     }
3439
3440     pCaps->FVFCaps = WINED3DFVFCAPS_PSIZE | 0x0008; /* 8 texture coords */
3441
3442     pCaps->MaxUserClipPlanes       = GL_LIMITS(clipplanes);
3443     pCaps->MaxActiveLights         = GL_LIMITS(lights);
3444
3445     pCaps->MaxVertexBlendMatrices      = GL_LIMITS(blends);
3446     pCaps->MaxVertexBlendMatrixIndex   = 0;
3447
3448     pCaps->MaxAnisotropy   = GL_LIMITS(anisotropy);
3449     pCaps->MaxPointSize    = GL_LIMITS(pointsize);
3450
3451
3452     pCaps->VertexProcessingCaps = WINED3DVTXPCAPS_DIRECTIONALLIGHTS |
3453                                   WINED3DVTXPCAPS_MATERIALSOURCE7   |
3454                                   WINED3DVTXPCAPS_POSITIONALLIGHTS  |
3455                                   WINED3DVTXPCAPS_LOCALVIEWER       |
3456                                   WINED3DVTXPCAPS_VERTEXFOG         |
3457                                   WINED3DVTXPCAPS_TEXGEN;
3458                                   /* FIXME: Add 
3459                                      D3DVTXPCAPS_TWEENING, D3DVTXPCAPS_TEXGEN_SPHEREMAP */
3460
3461     pCaps->MaxPrimitiveCount   = 0xFFFFF; /* For now set 2^20-1 which is used by most >=Geforce3/Radeon8500 cards */
3462     pCaps->MaxVertexIndex      = 0xFFFFF;
3463     pCaps->MaxStreams          = MAX_STREAMS;
3464     pCaps->MaxStreamStride     = 1024;
3465
3466     /* d3d9.dll sets D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES here because StretchRects is implemented in d3d9 */
3467     pCaps->DevCaps2                          = WINED3DDEVCAPS2_STREAMOFFSET |
3468                                                WINED3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET;
3469     pCaps->MaxNpatchTessellationLevel        = 0;
3470     pCaps->MasterAdapterOrdinal              = 0;
3471     pCaps->AdapterOrdinalInGroup             = 0;
3472     pCaps->NumberOfAdaptersInGroup           = 1;
3473
3474     pCaps->NumSimultaneousRTs = GL_LIMITS(buffers);
3475
3476     pCaps->StretchRectFilterCaps             = WINED3DPTFILTERCAPS_MINFPOINT  |
3477                                                 WINED3DPTFILTERCAPS_MAGFPOINT  |
3478                                                 WINED3DPTFILTERCAPS_MINFLINEAR |
3479                                                 WINED3DPTFILTERCAPS_MAGFLINEAR;
3480     pCaps->VertexTextureFilterCaps           = 0;
3481
3482     memset(&shader_caps, 0, sizeof(shader_caps));
3483     shader_backend = select_shader_backend(adapter, DeviceType);
3484     shader_backend->shader_get_caps(DeviceType, &adapter->gl_info, &shader_caps);
3485
3486     memset(&fragment_caps, 0, sizeof(fragment_caps));
3487     frag_pipeline = select_fragment_implementation(adapter, DeviceType);
3488     frag_pipeline->get_caps(DeviceType, &adapter->gl_info, &fragment_caps);
3489
3490     /* Add shader misc caps. Only some of them belong to the shader parts of the pipeline */
3491     pCaps->PrimitiveMiscCaps |= fragment_caps.PrimitiveMiscCaps;
3492
3493     /* This takes care for disabling vertex shader or pixel shader caps while leaving the other one enabled.
3494      * Ignore shader model capabilities if disabled in config
3495      */
3496     if(vs_selected_mode == SHADER_NONE) {
3497         TRACE_(d3d_caps)("Vertex shader disabled in config, reporting version 0.0\n");
3498         pCaps->VertexShaderVersion          = WINED3DVS_VERSION(0,0);
3499         pCaps->MaxVertexShaderConst         = 0;
3500     } else {
3501         pCaps->VertexShaderVersion          = shader_caps.VertexShaderVersion;
3502         pCaps->MaxVertexShaderConst         = shader_caps.MaxVertexShaderConst;
3503     }
3504
3505     if(ps_selected_mode == SHADER_NONE) {
3506         TRACE_(d3d_caps)("Pixel shader disabled in config, reporting version 0.0\n");
3507         pCaps->PixelShaderVersion           = WINED3DPS_VERSION(0,0);
3508         pCaps->PixelShader1xMaxValue        = 0.0;
3509     } else {
3510         pCaps->PixelShaderVersion           = shader_caps.PixelShaderVersion;
3511         pCaps->PixelShader1xMaxValue        = shader_caps.PixelShader1xMaxValue;
3512     }
3513
3514     pCaps->TextureOpCaps                    = fragment_caps.TextureOpCaps;
3515     pCaps->MaxTextureBlendStages            = fragment_caps.MaxTextureBlendStages;
3516     pCaps->MaxSimultaneousTextures          = fragment_caps.MaxSimultaneousTextures;
3517
3518     pCaps->VS20Caps                         = shader_caps.VS20Caps;
3519     pCaps->MaxVShaderInstructionsExecuted   = shader_caps.MaxVShaderInstructionsExecuted;
3520     pCaps->MaxVertexShader30InstructionSlots= shader_caps.MaxVertexShader30InstructionSlots;
3521     pCaps->PS20Caps                         = shader_caps.PS20Caps;
3522     pCaps->MaxPShaderInstructionsExecuted   = shader_caps.MaxPShaderInstructionsExecuted;
3523     pCaps->MaxPixelShader30InstructionSlots = shader_caps.MaxPixelShader30InstructionSlots;
3524
3525     /* The following caps are shader specific, but they are things we cannot detect, or which
3526      * are the same among all shader models. So to avoid code duplication set the shader version
3527      * specific, but otherwise constant caps here
3528      */
3529     if(pCaps->VertexShaderVersion == WINED3DVS_VERSION(3,0)) {
3530         /* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering)
3531         use the VS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum VS3.0 value. */
3532         pCaps->VS20Caps.Caps                     = WINED3DVS20CAPS_PREDICATION;
3533         pCaps->VS20Caps.DynamicFlowControlDepth  = WINED3DVS20_MAX_DYNAMICFLOWCONTROLDEPTH; /* VS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
3534         pCaps->VS20Caps.NumTemps                 = max(32, adapter->gl_info.vs_arb_max_temps);
3535         pCaps->VS20Caps.StaticFlowControlDepth   = WINED3DVS20_MAX_STATICFLOWCONTROLDEPTH ; /* level of nesting in loops / if-statements; VS 3.0 requires MAX (4) */
3536
3537         pCaps->MaxVShaderInstructionsExecuted    = 65535; /* VS 3.0 needs at least 65535, some cards even use 2^32-1 */
3538         pCaps->MaxVertexShader30InstructionSlots = max(512, adapter->gl_info.vs_arb_max_instructions);
3539     } else if(pCaps->VertexShaderVersion == WINED3DVS_VERSION(2,0)) {
3540         pCaps->VS20Caps.Caps                     = 0;
3541         pCaps->VS20Caps.DynamicFlowControlDepth  = WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH;
3542         pCaps->VS20Caps.NumTemps                 = max(12, adapter->gl_info.vs_arb_max_temps);
3543         pCaps->VS20Caps.StaticFlowControlDepth   = 1;
3544
3545         pCaps->MaxVShaderInstructionsExecuted    = 65535;
3546         pCaps->MaxVertexShader30InstructionSlots = 0;
3547     } else { /* VS 1.x */
3548         pCaps->VS20Caps.Caps                     = 0;
3549         pCaps->VS20Caps.DynamicFlowControlDepth  = 0;
3550         pCaps->VS20Caps.NumTemps                 = 0;
3551         pCaps->VS20Caps.StaticFlowControlDepth   = 0;
3552
3553         pCaps->MaxVShaderInstructionsExecuted    = 0;
3554         pCaps->MaxVertexShader30InstructionSlots = 0;
3555     }
3556
3557     if(pCaps->PixelShaderVersion == WINED3DPS_VERSION(3,0)) {
3558         /* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering)
3559         use the PS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum PS 3.0 value. */
3560
3561         /* 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 */
3562         pCaps->PS20Caps.Caps                     = WINED3DPS20CAPS_ARBITRARYSWIZZLE     |
3563                 WINED3DPS20CAPS_GRADIENTINSTRUCTIONS |
3564                 WINED3DPS20CAPS_PREDICATION          |
3565                 WINED3DPS20CAPS_NODEPENDENTREADLIMIT |
3566                 WINED3DPS20CAPS_NOTEXINSTRUCTIONLIMIT;
3567         pCaps->PS20Caps.DynamicFlowControlDepth  = WINED3DPS20_MAX_DYNAMICFLOWCONTROLDEPTH; /* PS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
3568         pCaps->PS20Caps.NumTemps                 = max(32, adapter->gl_info.ps_arb_max_temps);
3569         pCaps->PS20Caps.StaticFlowControlDepth   = WINED3DPS20_MAX_STATICFLOWCONTROLDEPTH; /* PS 3.0 requires MAX_STATICFLOWCONTROLDEPTH (4) */
3570         pCaps->PS20Caps.NumInstructionSlots      = WINED3DPS20_MAX_NUMINSTRUCTIONSLOTS; /* PS 3.0 requires MAX_NUMINSTRUCTIONSLOTS (512) */
3571
3572         pCaps->MaxPShaderInstructionsExecuted    = 65535;
3573         pCaps->MaxPixelShader30InstructionSlots  = max(WINED3DMIN30SHADERINSTRUCTIONS, adapter->gl_info.ps_arb_max_instructions);
3574     } else if(pCaps->PixelShaderVersion == WINED3DPS_VERSION(2,0)) {
3575         /* Below we assume PS2.0 specs, not extended 2.0a(GeforceFX)/2.0b(Radeon R3xx) ones */
3576         pCaps->PS20Caps.Caps                     = 0;
3577         pCaps->PS20Caps.DynamicFlowControlDepth  = 0; /* WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH = 0 */
3578         pCaps->PS20Caps.NumTemps                 = max(12, adapter->gl_info.ps_arb_max_temps);
3579         pCaps->PS20Caps.StaticFlowControlDepth   = WINED3DPS20_MIN_STATICFLOWCONTROLDEPTH; /* Minimum: 1 */
3580         pCaps->PS20Caps.NumInstructionSlots      = WINED3DPS20_MIN_NUMINSTRUCTIONSLOTS; /* Minimum number (64 ALU + 32 Texture), a GeforceFX uses 512 */
3581
3582         pCaps->MaxPShaderInstructionsExecuted    = 512; /* Minimum value, a GeforceFX uses 1024 */
3583         pCaps->MaxPixelShader30InstructionSlots  = 0;
3584     } else { /* PS 1.x */
3585         pCaps->PS20Caps.Caps                     = 0;
3586         pCaps->PS20Caps.DynamicFlowControlDepth  = 0;
3587         pCaps->PS20Caps.NumTemps                 = 0;
3588         pCaps->PS20Caps.StaticFlowControlDepth   = 0;
3589         pCaps->PS20Caps.NumInstructionSlots      = 0;
3590
3591         pCaps->MaxPShaderInstructionsExecuted    = 0;
3592         pCaps->MaxPixelShader30InstructionSlots  = 0;
3593     }
3594
3595     if(pCaps->VertexShaderVersion >= WINED3DVS_VERSION(2,0)) {
3596         /* OpenGL supports all the formats below, perhaps not always
3597          * without conversion, but it supports them.
3598          * Further GLSL doesn't seem to have an official unsigned type so
3599          * don't advertise it yet as I'm not sure how we handle it.
3600          * We might need to add some clamping in the shader engine to
3601          * support it.
3602          * TODO: WINED3DDTCAPS_USHORT2N, WINED3DDTCAPS_USHORT4N, WINED3DDTCAPS_UDEC3, WINED3DDTCAPS_DEC3N */
3603         pCaps->DeclTypes = WINED3DDTCAPS_UBYTE4    |
3604                            WINED3DDTCAPS_UBYTE4N   |
3605                            WINED3DDTCAPS_SHORT2N   |
3606                            WINED3DDTCAPS_SHORT4N;
3607         if (GL_SUPPORT(NV_HALF_FLOAT)) {
3608             pCaps->DeclTypes |= WINED3DDTCAPS_FLOAT16_2 |
3609                                 WINED3DDTCAPS_FLOAT16_4;
3610         }
3611     } else
3612         pCaps->DeclTypes                         = 0;
3613
3614     /* Set DirectDraw helper Caps */
3615     ckey_caps =                         WINEDDCKEYCAPS_DESTBLT              |
3616                                         WINEDDCKEYCAPS_SRCBLT;
3617     fx_caps =                           WINEDDFXCAPS_BLTALPHA               |
3618                                         WINEDDFXCAPS_BLTMIRRORLEFTRIGHT     |
3619                                         WINEDDFXCAPS_BLTMIRRORUPDOWN        |
3620                                         WINEDDFXCAPS_BLTROTATION90          |
3621                                         WINEDDFXCAPS_BLTSHRINKX             |
3622                                         WINEDDFXCAPS_BLTSHRINKXN            |
3623                                         WINEDDFXCAPS_BLTSHRINKY             |
3624                                         WINEDDFXCAPS_BLTSHRINKXN            |
3625                                         WINEDDFXCAPS_BLTSTRETCHX            |
3626                                         WINEDDFXCAPS_BLTSTRETCHXN           |
3627                                         WINEDDFXCAPS_BLTSTRETCHY            |
3628                                         WINEDDFXCAPS_BLTSTRETCHYN;
3629     blit_caps =                         WINEDDCAPS_BLT                      |
3630                                         WINEDDCAPS_BLTCOLORFILL             |
3631                                         WINEDDCAPS_BLTDEPTHFILL             |
3632                                         WINEDDCAPS_BLTSTRETCH               |
3633                                         WINEDDCAPS_CANBLTSYSMEM             |
3634                                         WINEDDCAPS_CANCLIP                  |
3635                                         WINEDDCAPS_CANCLIPSTRETCHED         |
3636                                         WINEDDCAPS_COLORKEY                 |
3637                                         WINEDDCAPS_COLORKEYHWASSIST         |
3638                                         WINEDDCAPS_ALIGNBOUNDARYSRC;
3639
3640     /* Fill the ddraw caps structure */
3641     pCaps->DirectDrawCaps.Caps =        WINEDDCAPS_GDI                      |
3642                                         WINEDDCAPS_PALETTE                  |
3643                                         blit_caps;
3644     pCaps->DirectDrawCaps.Caps2 =       WINEDDCAPS2_CERTIFIED                |
3645                                         WINEDDCAPS2_NOPAGELOCKREQUIRED       |
3646                                         WINEDDCAPS2_PRIMARYGAMMA             |
3647                                         WINEDDCAPS2_WIDESURFACES             |
3648                                         WINEDDCAPS2_CANRENDERWINDOWED;
3649     pCaps->DirectDrawCaps.SVBCaps =     blit_caps;
3650     pCaps->DirectDrawCaps.SVBCKeyCaps = ckey_caps;
3651     pCaps->DirectDrawCaps.SVBFXCaps =   fx_caps;
3652     pCaps->DirectDrawCaps.VSBCaps =     blit_caps;
3653     pCaps->DirectDrawCaps.VSBCKeyCaps = ckey_caps;
3654     pCaps->DirectDrawCaps.VSBFXCaps =   fx_caps;
3655     pCaps->DirectDrawCaps.SSBCaps =     blit_caps;
3656     pCaps->DirectDrawCaps.SSBCKeyCaps = ckey_caps;
3657     pCaps->DirectDrawCaps.SSBFXCaps =   fx_caps;
3658
3659     pCaps->DirectDrawCaps.ddsCaps =     WINEDDSCAPS_ALPHA                   |
3660                                         WINEDDSCAPS_BACKBUFFER              |
3661                                         WINEDDSCAPS_FLIP                    |
3662                                         WINEDDSCAPS_FRONTBUFFER             |
3663                                         WINEDDSCAPS_OFFSCREENPLAIN          |
3664                                         WINEDDSCAPS_PALETTE                 |
3665                                         WINEDDSCAPS_PRIMARYSURFACE          |
3666                                         WINEDDSCAPS_SYSTEMMEMORY            |
3667                                         WINEDDSCAPS_VIDEOMEMORY             |
3668                                         WINEDDSCAPS_VISIBLE;
3669     pCaps->DirectDrawCaps.StrideAlign = DDRAW_PITCH_ALIGNMENT;
3670
3671     /* Set D3D caps if OpenGL is available. */
3672     if (adapter->opengl)
3673     {
3674         pCaps->DirectDrawCaps.ddsCaps |=WINEDDSCAPS_3DDEVICE                |
3675                                         WINEDDSCAPS_MIPMAP                  |
3676                                         WINEDDSCAPS_TEXTURE                 |
3677                                         WINEDDSCAPS_ZBUFFER;
3678         pCaps->DirectDrawCaps.Caps |=   WINEDDCAPS_3D;
3679     }
3680
3681     return WINED3D_OK;
3682 }
3683
3684 /* Note due to structure differences between dx8 and dx9 D3DPRESENT_PARAMETERS,
3685    and fields being inserted in the middle, a new structure is used in place    */
3686 static HRESULT WINAPI IWineD3DImpl_CreateDevice(IWineD3D *iface, UINT Adapter,
3687         WINED3DDEVTYPE DeviceType, HWND hFocusWindow, DWORD BehaviourFlags, IUnknown *parent,
3688         IWineD3DDeviceParent *device_parent, IWineD3DDevice **ppReturnedDeviceInterface)
3689 {
3690     IWineD3DDeviceImpl *object  = NULL;
3691     IWineD3DImpl       *This    = (IWineD3DImpl *)iface;
3692     struct WineD3DAdapter *adapter = &This->adapters[Adapter];
3693     WINED3DDISPLAYMODE  mode;
3694     const struct fragment_pipeline *frag_pipeline = NULL;
3695     int i;
3696     struct fragment_caps ffp_caps;
3697     HRESULT hr;
3698
3699     /* Validate the adapter number. If no adapters are available(no GL), ignore the adapter
3700      * number and create a device without a 3D adapter for 2D only operation.
3701      */
3702     if (IWineD3D_GetAdapterCount(iface) && Adapter >= IWineD3D_GetAdapterCount(iface)) {
3703         return WINED3DERR_INVALIDCALL;
3704     }
3705
3706     /* Create a WineD3DDevice object */
3707     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IWineD3DDeviceImpl));
3708     *ppReturnedDeviceInterface = (IWineD3DDevice *)object;
3709     TRACE("Created WineD3DDevice object @ %p\n", object);
3710     if (NULL == object) {
3711       return WINED3DERR_OUTOFVIDEOMEMORY;
3712     }
3713
3714     /* Set up initial COM information */
3715     object->lpVtbl  = &IWineD3DDevice_Vtbl;
3716     object->ref     = 1;
3717     object->wineD3D = iface;
3718     object->adapter = This->adapter_count ? adapter : NULL;
3719     IWineD3D_AddRef(object->wineD3D);
3720     object->parent  = parent;
3721     object->device_parent = device_parent;
3722     list_init(&object->resources);
3723     list_init(&object->shaders);
3724
3725     if(This->dxVersion == 7) {
3726         object->surface_alignment = DDRAW_PITCH_ALIGNMENT;
3727     } else {
3728         object->surface_alignment = D3D8_PITCH_ALIGNMENT;
3729     }
3730     object->posFixup[0] = 1.0; /* This is needed to get the x coord unmodified through a MAD */
3731
3732     /* Set the state up as invalid until the device is fully created */
3733     object->state   = WINED3DERR_DRIVERINTERNALERROR;
3734
3735     TRACE("(%p)->(Adptr:%d, DevType: %x, FocusHwnd: %p, BehFlags: %x, RetDevInt: %p)\n", This, Adapter, DeviceType,
3736           hFocusWindow, BehaviourFlags, ppReturnedDeviceInterface);
3737
3738     /* Save the creation parameters */
3739     object->createParms.AdapterOrdinal = Adapter;
3740     object->createParms.DeviceType     = DeviceType;
3741     object->createParms.hFocusWindow   = hFocusWindow;
3742     object->createParms.BehaviorFlags  = BehaviourFlags;
3743
3744     /* Initialize other useful values */
3745     object->adapterNo                    = Adapter;
3746     object->devType                      = DeviceType;
3747
3748     select_shader_mode(&adapter->gl_info, DeviceType,
3749             &object->ps_selected_mode, &object->vs_selected_mode);
3750     object->shader_backend = select_shader_backend(adapter, DeviceType);
3751
3752     memset(&ffp_caps, 0, sizeof(ffp_caps));
3753     frag_pipeline = select_fragment_implementation(adapter, DeviceType);
3754     object->frag_pipe = frag_pipeline;
3755     frag_pipeline->get_caps(DeviceType, &adapter->gl_info, &ffp_caps);
3756     object->max_ffp_textures = ffp_caps.MaxSimultaneousTextures;
3757     object->max_ffp_texture_stages = ffp_caps.MaxTextureBlendStages;
3758     hr = compile_state_table(object->StateTable, object->multistate_funcs, &adapter->gl_info,
3759                         ffp_vertexstate_template, frag_pipeline, misc_state_template);
3760
3761     if (FAILED(hr)) {
3762         IWineD3D_Release(object->wineD3D);
3763         HeapFree(GetProcessHeap(), 0, object);
3764
3765         return hr;
3766     }
3767
3768     object->blitter = select_blit_implementation(adapter, DeviceType);
3769
3770     /* set the state of the device to valid */
3771     object->state = WINED3D_OK;
3772
3773     /* Get the initial screen setup for ddraw */
3774     IWineD3DImpl_GetAdapterDisplayMode(iface, Adapter, &mode);
3775
3776     object->ddraw_width = mode.Width;
3777     object->ddraw_height = mode.Height;
3778     object->ddraw_format = mode.Format;
3779
3780     for(i = 0; i < PATCHMAP_SIZE; i++) {
3781         list_init(&object->patches[i]);
3782     }
3783
3784     IWineD3DDeviceParent_WineD3DDeviceCreated(device_parent, *ppReturnedDeviceInterface);
3785
3786     return WINED3D_OK;
3787 }
3788
3789 static HRESULT WINAPI IWineD3DImpl_GetParent(IWineD3D *iface, IUnknown **pParent) {
3790     IWineD3DImpl *This = (IWineD3DImpl *)iface;
3791     IUnknown_AddRef(This->parent);
3792     *pParent = This->parent;
3793     return WINED3D_OK;
3794 }
3795
3796 ULONG WINAPI D3DCB_DefaultDestroySurface(IWineD3DSurface *pSurface) {
3797     IUnknown* surfaceParent;
3798     TRACE("(%p) call back\n", pSurface);
3799
3800     /* Now, release the parent, which will take care of cleaning up the surface for us */
3801     IWineD3DSurface_GetParent(pSurface, &surfaceParent);
3802     IUnknown_Release(surfaceParent);
3803     return IUnknown_Release(surfaceParent);
3804 }
3805
3806 ULONG WINAPI D3DCB_DefaultDestroyVolume(IWineD3DVolume *pVolume) {
3807     IUnknown* volumeParent;
3808     TRACE("(%p) call back\n", pVolume);
3809
3810     /* Now, release the parent, which will take care of cleaning up the volume for us */
3811     IWineD3DVolume_GetParent(pVolume, &volumeParent);
3812     IUnknown_Release(volumeParent);
3813     return IUnknown_Release(volumeParent);
3814 }
3815
3816 static BOOL implementation_is_apple(const WineD3D_GL_Info *gl_info)
3817 {
3818     /* MacOS has various specialities in the extensions it advertises. Some have to be loaded from
3819      * the opengl 1.2+ core, while other extensions are advertised, but software emulated. So try to
3820      * detect the Apple OpenGL implementation to apply some extension fixups afterwards.
3821      *
3822      * Detecting this isn't really easy. The vendor string doesn't mention Apple. Compile-time checks
3823      * aren't sufficient either because a Linux binary may display on a macos X server via remote X11.
3824      * So try to detect the GL implementation by looking at certain Apple extensions. Some extensions
3825      * like client storage might be supported on other implementations too, but GL_APPLE_flush_render
3826      * is specific to the Mac OS X window management, and GL_APPLE_ycbcr_422 is QuickTime specific. So
3827      * the chance that other implementations support them is rather small since Win32 QuickTime uses
3828      * DirectDraw, not OpenGL.
3829      */
3830     if(gl_info->supported[APPLE_FENCE] &&
3831        gl_info->supported[APPLE_CLIENT_STORAGE] &&
3832        gl_info->supported[APPLE_FLUSH_RENDER] &&
3833        gl_info->supported[APPLE_YCBCR_422]) {
3834         TRACE_(d3d_caps)("GL_APPLE_fence, GL_APPLE_client_storage, GL_APPLE_flush_render and GL_ycbcr_422 are supported\n");
3835         TRACE_(d3d_caps)("Activating MacOS fixups\n");
3836         return TRUE;
3837     } else {
3838         TRACE_(d3d_caps)("Apple extensions are not supported\n");
3839         TRACE_(d3d_caps)("Not activating MacOS fixups\n");
3840         return FALSE;
3841     }
3842 }
3843
3844 static void test_pbo_functionality(WineD3D_GL_Info *gl_info) {
3845     /* Some OpenGL implementations, namely Apple's Geforce 8 driver, advertises PBOs,
3846      * but glTexSubImage from a PBO fails miserably, with the first line repeated over
3847      * all the texture. This function detects this bug by its symptom and disables PBOs
3848      * if the test fails.
3849      *
3850      * The test uploads a 4x4 texture via the PBO in the "native" format GL_BGRA,
3851      * GL_UNSIGNED_INT_8_8_8_8_REV. This format triggers the bug, and it is what we use
3852      * for D3DFMT_A8R8G8B8. Then the texture is read back without any PBO and the data
3853      * read back is compared to the original. If they are equal PBOs are assumed to work,
3854      * otherwise the PBO extension is disabled.
3855      */
3856     GLuint texture, pbo;
3857     static const unsigned int pattern[] = {
3858         0x00000000, 0x000000ff, 0x0000ff00, 0x40ff0000,
3859         0x80ffffff, 0x40ffff00, 0x00ff00ff, 0x0000ffff,
3860         0x00ffff00, 0x00ff00ff, 0x0000ffff, 0x000000ff,
3861         0x80ff00ff, 0x0000ffff, 0x00ff00ff, 0x40ff00ff
3862     };
3863     unsigned int check[sizeof(pattern) / sizeof(pattern[0])];
3864
3865     if(!gl_info->supported[ARB_PIXEL_BUFFER_OBJECT]) {
3866         /* No PBO -> No point in testing them */
3867         return;
3868     }
3869
3870     while(glGetError());
3871     glGenTextures(1, &texture);
3872     glBindTexture(GL_TEXTURE_2D, texture);
3873     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 4, 4, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, 0);
3874     checkGLcall("Specifying the PBO test texture\n");
3875
3876     GL_EXTCALL(glGenBuffersARB(1, &pbo));
3877     GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pbo));
3878     GL_EXTCALL(glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, sizeof(pattern), pattern, GL_STREAM_DRAW_ARB));
3879     checkGLcall("Specifying the PBO test pbo\n");
3880
3881     glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL);
3882     checkGLcall("Loading the PBO test texture\n");
3883
3884     GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
3885     glFinish(); /* just to be sure */
3886
3887     memset(check, 0, sizeof(check));
3888     glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, check);
3889     checkGLcall("Reading back the PBO test texture\n");
3890
3891     glDeleteTextures(1, &texture);
3892     GL_EXTCALL(glDeleteBuffersARB(1, &pbo));
3893     checkGLcall("PBO test cleanup\n");
3894
3895     if(memcmp(check, pattern, sizeof(check)) != 0) {
3896         WARN_(d3d_caps)("PBO test failed, read back data doesn't match original\n");
3897         WARN_(d3d_caps)("Disabling PBOs. This may result in slower performance\n");
3898         gl_info->supported[ARB_PIXEL_BUFFER_OBJECT] = FALSE;
3899     } else {
3900         TRACE_(d3d_caps)("PBO test successful\n");
3901     }
3902 }
3903
3904 /* Certain applications(Steam) complain if we report an outdated driver version. In general,
3905  * reporting a driver version is moot because we are not the Windows driver, and we have different
3906  * bugs, features, etc.
3907  *
3908  * If a card is not found in this table, the gl driver version is reported
3909  */
3910 struct driver_version_information {
3911     WORD vendor;                        /* reported PCI card vendor ID  */
3912     WORD card;                          /* reported PCI card device ID  */
3913     WORD hipart_hi, hipart_lo;          /* driver hiword to report      */
3914     WORD lopart_hi, lopart_lo;          /* driver loword to report      */
3915 };
3916
3917 static const struct driver_version_information driver_version_table[] = {
3918     /* Nvidia drivers. Geforce6 and newer cards are supported by the current driver (177.x)*/
3919     /* GeforceFX support is up to 173.x, Geforce2MX/3/4 up to 96.x, TNT/Geforce1/2 up to 71.x */
3920     /* Note that version numbers >100 lets say 123.45 use >= x.y.11.2345 and not x.y.10.12345 */
3921     {VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCEFX_5200,     7,  15, 11, 7341   },
3922     {VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCEFX_5600,     7,  15, 11, 7341   },
3923     {VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCEFX_5800,     7,  15, 11, 7341   },
3924     {VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_6200,       7,  15, 11, 7341   },
3925     {VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_6600GT,     7,  15, 11, 7341   },
3926     {VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_6800,       7,  15, 11, 7341   },
3927     {VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_7400,       7,  15, 11, 7341   },
3928     {VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_7300,       7,  15, 11, 7341   },
3929     {VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_7600,       7,  15, 11, 7341   },
3930     {VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_7800GT,     7,  15, 11, 7341   },
3931     {VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_8300GS,     7,  15, 11, 7341   },
3932     {VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_8600GT,     7,  15, 11, 7341   },
3933     {VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_8600MGT,    7,  15, 11, 7341   },
3934     {VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_8800GTS,    7,  15, 11, 7341   },
3935     {VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_9600GT,     7,  15, 11, 7341    },
3936     {VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_9800GT,     7,  15, 11, 7341    },
3937     {VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_GTX280,     7,  15, 11, 7341    },
3938
3939     /* ATI cards. The driver versions are somewhat similar, but not quite the same. Let's hardcode */
3940     {VENDOR_ATI,        CARD_ATI_RADEON_9500,           6,  14, 10, 6764    },
3941     {VENDOR_ATI,        CARD_ATI_RADEON_X700,           6,  14, 10, 6764    },
3942     {VENDOR_ATI,        CARD_ATI_RADEON_X1600,          6,  14, 10, 6764    },
3943     {VENDOR_ATI,        CARD_ATI_RADEON_HD2300,         6,  14, 10, 6764    },
3944     {VENDOR_ATI,        CARD_ATI_RADEON_HD2600,         6,  14, 10, 6764    },
3945     {VENDOR_ATI,        CARD_ATI_RADEON_HD2900,         6,  14, 10, 6764    },
3946
3947     /* TODO: Add information about legacy nvidia and ATI hardware, Intel and other cards */
3948 };
3949
3950 static void fixup_extensions(WineD3D_GL_Info *gl_info) {
3951     unsigned int i;
3952     BOOL apple = implementation_is_apple(gl_info);
3953
3954     if(apple) {
3955         /* MacOS advertises more GLSL vertex shader uniforms than supported by the hardware, and if more are
3956          * used it falls back to software. While the compiler can detect if the shader uses all declared
3957          * uniforms, the optimization fails if the shader uses relative addressing. So any GLSL shader
3958          * using relative addressing falls back to software.
3959          *
3960          * ARB vp gives the correct amount of uniforms, so use it instead of GLSL
3961          */
3962         if(gl_info->vs_glsl_constantsF <= gl_info->vs_arb_constantsF) {
3963             FIXME("GLSL doesn't advertise more vertex shader uniforms than ARB. Driver fixup outdated?\n");
3964         } else {
3965             TRACE("Driver claims %u GLSL vs uniforms, replacing with %u ARB vp uniforms\n",
3966                   gl_info->vs_glsl_constantsF, gl_info->vs_arb_constantsF);
3967             gl_info->vs_glsl_constantsF = gl_info->vs_arb_constantsF;
3968         }
3969
3970         /* The Intel GPUs on MacOS set the .w register of texcoords to 0.0 by default, which causes problems
3971          * with fixed function fragment processing. Ideally this flag should be detected with a test shader
3972          * and OpenGL feedback mode, but some GL implementations (MacOS ATI at least, probably all MacOS ones)
3973          * do not like vertex shaders in feedback mode and return an error, even though it should be valid
3974          * according to the spec.
3975          *
3976          * We don't want to enable this on all cards, as it adds an extra instruction per texcoord used. This
3977          * makes the shader slower and eats instruction slots which should be available to the d3d app.
3978          *
3979          * ATI Radeon HD 2xxx cards on MacOS have the issue. Instead of checking for the buggy cards, blacklist
3980          * all radeon cards on Macs and whitelist the good ones. That way we're prepared for the future. If
3981          * this workaround is activated on cards that do not need it, it won't break things, just affect
3982          * performance negatively.
3983          */
3984         if(gl_info->gl_vendor == VENDOR_INTEL ||
3985            (gl_info->gl_vendor == VENDOR_ATI && gl_info->gl_card != CARD_ATI_RADEON_X1600)) {
3986             TRACE("Enabling vertex texture coord fixes in vertex shaders\n");
3987             gl_info->set_texcoord_w = TRUE;
3988         }
3989     }
3990
3991     /* MacOS advertises GL_ARB_texture_non_power_of_two on ATI r500 and earlier cards, although
3992      * these cards only support GL_ARB_texture_rectangle(D3DPTEXTURECAPS_NONPOW2CONDITIONAL).
3993      * If real NP2 textures are used, the driver falls back to software. We could just remove the
3994      * extension and use GL_ARB_texture_rectangle instead, but texture_rectangle is inconventient
3995      * due to the non-normalized texture coordinates. Thus set an internal extension flag,
3996      * GL_WINE_normalized_texrect, which signals the code that it can use non power of two textures
3997      * as per GL_ARB_texture_non_power_of_two, but has to stick to the texture_rectangle limits.
3998      *
3999      * fglrx doesn't advertise GL_ARB_texture_non_power_of_two, but it advertises opengl 2.0 which
4000      * has this extension promoted to core. The extension loading code sets this extension supported
4001      * due to that, so this code works on fglrx as well.
4002      */
4003     if(gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] && gl_info->gl_vendor == VENDOR_ATI) {
4004         if(gl_info->gl_card == CARD_ATI_RADEON_X700 || gl_info->gl_card == CARD_ATI_RADEON_X1600 ||
4005             gl_info->gl_card == CARD_ATI_RADEON_9500 || gl_info->gl_card == CARD_ATI_RADEON_8500  ||
4006             gl_info->gl_card == CARD_ATI_RADEON_7200 || gl_info->gl_card == CARD_ATI_RAGE_128PRO) {
4007             TRACE("GL_ARB_texture_non_power_of_two advertised on R500 or earlier card, removing\n");
4008             gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] = FALSE;
4009             gl_info->supported[WINE_NORMALIZED_TEXRECT] = TRUE;
4010         }
4011     }
4012
4013     /*  The nVidia GeForceFX series reports OpenGL 2.0 capabilities with the latest drivers versions, but
4014      *  doesn't explicitly advertise the ARB_tex_npot extension in the GL extension string.
4015      *  This usually means that ARB_tex_npot is supported in hardware as long as the application is staying
4016      *  within the limits enforced by the ARB_texture_rectangle extension. This however is not true for the
4017      *  FX series, which instantly falls back to a slower software path as soon as ARB_tex_npot is used.
4018      *  We therefore completely remove ARB_tex_npot from the list of supported extensions.
4019      *
4020      *  Note that wine_normalized_texrect can't be used in this case because internally it uses ARB_tex_npot,
4021      *  triggering the software fallback. There is not much we can do here apart from disabling the
4022      *  software-emulated extension and reenable ARB_tex_rect (which was previously disabled
4023      *  in IWineD3DImpl_FillGLCaps).
4024      *  This fixup removes performance problems on both the FX 5900 and FX 5700 (e.g. for framebuffer
4025      *  post-processing effects in the game "Max Payne 2").
4026      *  The behaviour can be verified through a simple test app attached in bugreport #14724.
4027      */
4028     if(gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] && gl_info->gl_vendor == VENDOR_NVIDIA) {
4029         if(gl_info->gl_card == CARD_NVIDIA_GEFORCEFX_5800 || gl_info->gl_card == CARD_NVIDIA_GEFORCEFX_5600) {
4030             TRACE("GL_ARB_texture_non_power_of_two advertised through OpenGL 2.0 on NV FX card, removing\n");
4031             gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] = FALSE;
4032             gl_info->supported[ARB_TEXTURE_RECTANGLE] = TRUE;
4033         }
4034     }
4035
4036     /* Find out if PBOs work as they are supposed to */
4037     test_pbo_functionality(gl_info);
4038
4039     /* Fixup the driver version */
4040     for(i = 0; i < (sizeof(driver_version_table) / sizeof(driver_version_table[0])); i++) {
4041         if(gl_info->gl_vendor == driver_version_table[i].vendor &&
4042            gl_info->gl_card   == driver_version_table[i].card) {
4043             TRACE_(d3d_caps)("Found card 0x%04x, 0x%04x in driver version DB\n", gl_info->gl_vendor, gl_info->gl_card);
4044
4045             gl_info->driver_version        = MAKEDWORD_VERSION(driver_version_table[i].lopart_hi,
4046                                                                driver_version_table[i].lopart_lo);
4047             gl_info->driver_version_hipart = MAKEDWORD_VERSION(driver_version_table[i].hipart_hi,
4048                                                                driver_version_table[i].hipart_lo);
4049             break;
4050         }
4051     }
4052 }
4053
4054 static void WINE_GLAPI invalid_func(const void *data)
4055 {
4056     ERR("Invalid vertex attribute function called\n");
4057     DebugBreak();
4058 }
4059
4060 static void WINE_GLAPI invalid_texcoord_func(GLenum unit, const void *data)
4061 {
4062     ERR("Invalid texcoord function called\n");
4063     DebugBreak();
4064 }
4065
4066 /* Helper functions for providing vertex data to opengl. The arrays are initialized based on
4067  * the extension detection and are used in drawStridedSlow
4068  */
4069 static void WINE_GLAPI position_d3dcolor(const void *data)
4070 {
4071     DWORD pos = *((const DWORD *)data);
4072
4073     FIXME("Add a test for fixed function position from d3dcolor type\n");
4074     glVertex4s(D3DCOLOR_B_R(pos),
4075                D3DCOLOR_B_G(pos),
4076                D3DCOLOR_B_B(pos),
4077                D3DCOLOR_B_A(pos));
4078 }
4079
4080 static void WINE_GLAPI position_float4(const void *data)
4081 {
4082     const GLfloat *pos = data;
4083
4084     if (pos[3] < eps && pos[3] > -eps)
4085         glVertex3fv(pos);
4086     else {
4087         float w = 1.0 / pos[3];
4088
4089         glVertex4f(pos[0] * w, pos[1] * w, pos[2] * w, w);
4090     }
4091 }
4092
4093 static void WINE_GLAPI diffuse_d3dcolor(const void *data)
4094 {
4095     DWORD diffuseColor = *((const DWORD *)data);
4096
4097     glColor4ub(D3DCOLOR_B_R(diffuseColor),
4098                D3DCOLOR_B_G(diffuseColor),
4099                D3DCOLOR_B_B(diffuseColor),
4100                D3DCOLOR_B_A(diffuseColor));
4101 }
4102
4103 static void WINE_GLAPI specular_d3dcolor(const void *data)
4104 {
4105     DWORD specularColor = *((const DWORD *)data);
4106     GLbyte d[] = {D3DCOLOR_B_R(specularColor),
4107             D3DCOLOR_B_G(specularColor),
4108             D3DCOLOR_B_B(specularColor)};
4109
4110     specular_func_3ubv(d);
4111 }
4112
4113 static void WINE_GLAPI warn_no_specular_func(const void *data)
4114 {
4115     WARN("GL_EXT_secondary_color not supported\n");
4116 }
4117
4118 static void fillGLAttribFuncs(const WineD3D_GL_Info *gl_info)
4119 {
4120     position_funcs[WINED3DDECLTYPE_FLOAT1]      = invalid_func;
4121     position_funcs[WINED3DDECLTYPE_FLOAT2]      = invalid_func;
4122     position_funcs[WINED3DDECLTYPE_FLOAT3]      = (glAttribFunc)glVertex3fv;
4123     position_funcs[WINED3DDECLTYPE_FLOAT4]      = position_float4;
4124     position_funcs[WINED3DDECLTYPE_D3DCOLOR]    = position_d3dcolor;
4125     position_funcs[WINED3DDECLTYPE_UBYTE4]      = invalid_func;
4126     position_funcs[WINED3DDECLTYPE_SHORT2]      = invalid_func;
4127     position_funcs[WINED3DDECLTYPE_SHORT4]      = (glAttribFunc)glVertex2sv;
4128     position_funcs[WINED3DDECLTYPE_UBYTE4N]     = invalid_func;
4129     position_funcs[WINED3DDECLTYPE_SHORT2N]     = invalid_func;
4130     position_funcs[WINED3DDECLTYPE_SHORT4N]     = invalid_func;
4131     position_funcs[WINED3DDECLTYPE_USHORT2N]    = invalid_func;
4132     position_funcs[WINED3DDECLTYPE_USHORT4N]    = invalid_func;
4133     position_funcs[WINED3DDECLTYPE_UDEC3]       = invalid_func;
4134     position_funcs[WINED3DDECLTYPE_DEC3N]       = invalid_func;
4135     position_funcs[WINED3DDECLTYPE_FLOAT16_2]   = invalid_func;
4136     position_funcs[WINED3DDECLTYPE_FLOAT16_4]   = invalid_func;
4137
4138     diffuse_funcs[WINED3DDECLTYPE_FLOAT1]       = invalid_func;
4139     diffuse_funcs[WINED3DDECLTYPE_FLOAT2]       = invalid_func;
4140     diffuse_funcs[WINED3DDECLTYPE_FLOAT3]       = (glAttribFunc)glColor3fv;
4141     diffuse_funcs[WINED3DDECLTYPE_FLOAT4]       = (glAttribFunc)glColor4fv;
4142     diffuse_funcs[WINED3DDECLTYPE_D3DCOLOR]     = diffuse_d3dcolor;
4143     diffuse_funcs[WINED3DDECLTYPE_UBYTE4]       = invalid_func;
4144     diffuse_funcs[WINED3DDECLTYPE_SHORT2]       = invalid_func;
4145     diffuse_funcs[WINED3DDECLTYPE_SHORT4]       = invalid_func;
4146     diffuse_funcs[WINED3DDECLTYPE_UBYTE4N]      = (glAttribFunc)glColor4ubv;
4147     diffuse_funcs[WINED3DDECLTYPE_SHORT2N]      = invalid_func;
4148     diffuse_funcs[WINED3DDECLTYPE_SHORT4N]      = (glAttribFunc)glColor4sv;
4149     diffuse_funcs[WINED3DDECLTYPE_USHORT2N]     = invalid_func;
4150     diffuse_funcs[WINED3DDECLTYPE_USHORT4N]     = (glAttribFunc)glColor4usv;
4151     diffuse_funcs[WINED3DDECLTYPE_UDEC3]        = invalid_func;
4152     diffuse_funcs[WINED3DDECLTYPE_DEC3N]        = invalid_func;
4153     diffuse_funcs[WINED3DDECLTYPE_FLOAT16_2]    = invalid_func;
4154     diffuse_funcs[WINED3DDECLTYPE_FLOAT16_4]    = invalid_func;
4155
4156     /* No 4 component entry points here */
4157     specular_funcs[WINED3DDECLTYPE_FLOAT1]      = invalid_func;
4158     specular_funcs[WINED3DDECLTYPE_FLOAT2]      = invalid_func;
4159     if(GL_SUPPORT(EXT_SECONDARY_COLOR)) {
4160         specular_funcs[WINED3DDECLTYPE_FLOAT3]      = (glAttribFunc)GL_EXTCALL(glSecondaryColor3fvEXT);
4161     } else {
4162         specular_funcs[WINED3DDECLTYPE_FLOAT3]      = warn_no_specular_func;
4163     }
4164     specular_funcs[WINED3DDECLTYPE_FLOAT4]      = invalid_func;
4165     if(GL_SUPPORT(EXT_SECONDARY_COLOR)) {
4166         specular_func_3ubv = (glAttribFunc)GL_EXTCALL(glSecondaryColor3ubvEXT);
4167         specular_funcs[WINED3DDECLTYPE_D3DCOLOR]    = specular_d3dcolor;
4168     } else {
4169         specular_funcs[WINED3DDECLTYPE_D3DCOLOR]      = warn_no_specular_func;
4170     }
4171     specular_funcs[WINED3DDECLTYPE_UBYTE4]      = invalid_func;
4172     specular_funcs[WINED3DDECLTYPE_SHORT2]      = invalid_func;
4173     specular_funcs[WINED3DDECLTYPE_SHORT4]      = invalid_func;
4174     specular_funcs[WINED3DDECLTYPE_UBYTE4N]     = invalid_func;
4175     specular_funcs[WINED3DDECLTYPE_SHORT2N]     = invalid_func;
4176     specular_funcs[WINED3DDECLTYPE_SHORT4N]     = invalid_func;
4177     specular_funcs[WINED3DDECLTYPE_USHORT2N]    = invalid_func;
4178     specular_funcs[WINED3DDECLTYPE_USHORT4N]    = invalid_func;
4179     specular_funcs[WINED3DDECLTYPE_UDEC3]       = invalid_func;
4180     specular_funcs[WINED3DDECLTYPE_DEC3N]       = invalid_func;
4181     specular_funcs[WINED3DDECLTYPE_FLOAT16_2]   = invalid_func;
4182     specular_funcs[WINED3DDECLTYPE_FLOAT16_4]   = invalid_func;
4183
4184     /* Only 3 component entry points here. Test how others behave. Float4 normals are used
4185      * by one of our tests, trying to pass it to the pixel shader, which fails on Windows.
4186      */
4187     normal_funcs[WINED3DDECLTYPE_FLOAT1]         = invalid_func;
4188     normal_funcs[WINED3DDECLTYPE_FLOAT2]         = invalid_func;
4189     normal_funcs[WINED3DDECLTYPE_FLOAT3]         = (glAttribFunc)glNormal3fv;
4190     normal_funcs[WINED3DDECLTYPE_FLOAT4]         = (glAttribFunc)glNormal3fv; /* Just ignore the 4th value */
4191     normal_funcs[WINED3DDECLTYPE_D3DCOLOR]       = invalid_func;
4192     normal_funcs[WINED3DDECLTYPE_UBYTE4]         = invalid_func;
4193     normal_funcs[WINED3DDECLTYPE_SHORT2]         = invalid_func;
4194     normal_funcs[WINED3DDECLTYPE_SHORT4]         = invalid_func;
4195     normal_funcs[WINED3DDECLTYPE_UBYTE4N]        = invalid_func;
4196     normal_funcs[WINED3DDECLTYPE_SHORT2N]        = invalid_func;
4197     normal_funcs[WINED3DDECLTYPE_SHORT4N]        = invalid_func;
4198     normal_funcs[WINED3DDECLTYPE_USHORT2N]       = invalid_func;
4199     normal_funcs[WINED3DDECLTYPE_USHORT4N]       = invalid_func;
4200     normal_funcs[WINED3DDECLTYPE_UDEC3]          = invalid_func;
4201     normal_funcs[WINED3DDECLTYPE_DEC3N]          = invalid_func;
4202     normal_funcs[WINED3DDECLTYPE_FLOAT16_2]      = invalid_func;
4203     normal_funcs[WINED3DDECLTYPE_FLOAT16_4]      = invalid_func;
4204
4205     multi_texcoord_funcs[WINED3DDECLTYPE_FLOAT1]    = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord1fvARB);
4206     multi_texcoord_funcs[WINED3DDECLTYPE_FLOAT2]    = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord2fvARB);
4207     multi_texcoord_funcs[WINED3DDECLTYPE_FLOAT3]    = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord3fvARB);
4208     multi_texcoord_funcs[WINED3DDECLTYPE_FLOAT4]    = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord4fvARB);
4209     multi_texcoord_funcs[WINED3DDECLTYPE_D3DCOLOR]  = invalid_texcoord_func;
4210     multi_texcoord_funcs[WINED3DDECLTYPE_UBYTE4]    = invalid_texcoord_func;
4211     multi_texcoord_funcs[WINED3DDECLTYPE_SHORT2]    = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord2svARB);
4212     multi_texcoord_funcs[WINED3DDECLTYPE_SHORT4]    = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord4svARB);
4213     multi_texcoord_funcs[WINED3DDECLTYPE_UBYTE4N]   = invalid_texcoord_func;
4214     multi_texcoord_funcs[WINED3DDECLTYPE_SHORT2N]   = invalid_texcoord_func;
4215     multi_texcoord_funcs[WINED3DDECLTYPE_SHORT4N]   = invalid_texcoord_func;
4216     multi_texcoord_funcs[WINED3DDECLTYPE_USHORT2N]  = invalid_texcoord_func;
4217     multi_texcoord_funcs[WINED3DDECLTYPE_USHORT4N]  = invalid_texcoord_func;
4218     multi_texcoord_funcs[WINED3DDECLTYPE_UDEC3]     = invalid_texcoord_func;
4219     multi_texcoord_funcs[WINED3DDECLTYPE_DEC3N]     = invalid_texcoord_func;
4220     if (GL_SUPPORT(NV_HALF_FLOAT))
4221     {
4222         multi_texcoord_funcs[WINED3DDECLTYPE_FLOAT16_2] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord2hvNV);
4223         multi_texcoord_funcs[WINED3DDECLTYPE_FLOAT16_4] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord4hvNV);
4224     } else {
4225         multi_texcoord_funcs[WINED3DDECLTYPE_FLOAT16_2] = invalid_texcoord_func;
4226         multi_texcoord_funcs[WINED3DDECLTYPE_FLOAT16_4] = invalid_texcoord_func;
4227     }
4228 }
4229
4230 BOOL InitAdapters(IWineD3DImpl *This)
4231 {
4232     static HMODULE mod_gl;
4233     BOOL ret;
4234     int ps_selected_mode, vs_selected_mode;
4235
4236     /* No need to hold any lock. The calling library makes sure only one thread calls
4237      * wined3d simultaneously
4238      */
4239
4240     TRACE("Initializing adapters\n");
4241
4242     if(!mod_gl) {
4243 #ifdef USE_WIN32_OPENGL
4244 #define USE_GL_FUNC(pfn) pfn = (void*)GetProcAddress(mod_gl, #pfn);
4245         mod_gl = LoadLibraryA("opengl32.dll");
4246         if(!mod_gl) {
4247             ERR("Can't load opengl32.dll!\n");
4248             goto nogl_adapter;
4249         }
4250 #else
4251 #define USE_GL_FUNC(pfn) pfn = (void*)pwglGetProcAddress(#pfn);
4252         /* To bypass the opengl32 thunks load wglGetProcAddress from gdi32 (glXGetProcAddress wrapper) instead of opengl32's */
4253         mod_gl = GetModuleHandleA("gdi32.dll");
4254 #endif
4255     }
4256
4257 /* Load WGL core functions from opengl32.dll */
4258 #define USE_WGL_FUNC(pfn) p##pfn = (void*)GetProcAddress(mod_gl, #pfn);
4259     WGL_FUNCS_GEN;
4260 #undef USE_WGL_FUNC
4261
4262     if(!pwglGetProcAddress) {
4263         ERR("Unable to load wglGetProcAddress!\n");
4264         goto nogl_adapter;
4265     }
4266
4267 /* Dynamically load all GL core functions */
4268     GL_FUNCS_GEN;
4269 #undef USE_GL_FUNC
4270
4271     /* Load glFinish and glFlush from opengl32.dll even if we're not using WIN32 opengl
4272      * otherwise because we have to use winex11.drv's override
4273      */
4274 #ifdef USE_WIN32_OPENGL
4275     glFinish = (void*)GetProcAddress(mod_gl, "glFinish");
4276     glFlush = (void*)GetProcAddress(mod_gl, "glFlush");
4277 #else
4278     glFinish = (void*)pwglGetProcAddress("wglFinish");
4279     glFlush = (void*)pwglGetProcAddress("wglFlush");
4280 #endif
4281
4282     glEnableWINE = glEnable;
4283     glDisableWINE = glDisable;
4284
4285     /* For now only one default adapter */
4286     {
4287         struct WineD3DAdapter *adapter = &This->adapters[0];
4288         const WineD3D_GL_Info *gl_info = &adapter->gl_info;
4289         int iPixelFormat;
4290         int attribs[10];
4291         int values[10];
4292         int nAttribs = 0;
4293         int res;
4294         int i;
4295         WineD3D_PixelFormat *cfgs;
4296         int attribute;
4297         DISPLAY_DEVICEW DisplayDevice;
4298         HDC hdc;
4299
4300         TRACE("Initializing default adapter\n");
4301         adapter->num = 0;
4302         adapter->monitorPoint.x = -1;
4303         adapter->monitorPoint.y = -1;
4304
4305         if (!WineD3D_CreateFakeGLContext()) {
4306             ERR("Failed to get a gl context for default adapter\n");
4307             WineD3D_ReleaseFakeGLContext();
4308             goto nogl_adapter;
4309         }
4310
4311         ret = IWineD3DImpl_FillGLCaps(&adapter->gl_info);
4312         if(!ret) {
4313             ERR("Failed to initialize gl caps for default adapter\n");
4314             WineD3D_ReleaseFakeGLContext();
4315             goto nogl_adapter;
4316         }
4317         ret = initPixelFormats(&adapter->gl_info);
4318         if(!ret) {
4319             ERR("Failed to init gl formats\n");
4320             WineD3D_ReleaseFakeGLContext();
4321             goto nogl_adapter;
4322         }
4323
4324         hdc = pwglGetCurrentDC();
4325         if(!hdc) {
4326             ERR("Failed to get gl HDC\n");
4327             WineD3D_ReleaseFakeGLContext();
4328             goto nogl_adapter;
4329         }
4330
4331         adapter->driver = "Display";
4332         adapter->description = "Direct3D HAL";
4333
4334         /* Use the VideoRamSize registry setting when set */
4335         if(wined3d_settings.emulated_textureram)
4336             adapter->TextureRam = wined3d_settings.emulated_textureram;
4337         else
4338             adapter->TextureRam = adapter->gl_info.vidmem;
4339         adapter->UsedTextureRam = 0;
4340         TRACE("Emulating %dMB of texture ram\n", adapter->TextureRam/(1024*1024));
4341
4342         /* Initialize the Adapter's DeviceName which is required for ChangeDisplaySettings and friends */
4343         DisplayDevice.cb = sizeof(DisplayDevice);
4344         EnumDisplayDevicesW(NULL, 0 /* Adapter 0 = iDevNum 0 */, &DisplayDevice, 0);
4345         TRACE("DeviceName: %s\n", debugstr_w(DisplayDevice.DeviceName));
4346         strcpyW(adapter->DeviceName, DisplayDevice.DeviceName);
4347
4348         attribute = WGL_NUMBER_PIXEL_FORMATS_ARB;
4349         GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc, 0, 0, 1, &attribute, &adapter->nCfgs));
4350
4351         adapter->cfgs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, adapter->nCfgs *sizeof(WineD3D_PixelFormat));
4352         cfgs = adapter->cfgs;
4353         attribs[nAttribs++] = WGL_RED_BITS_ARB;
4354         attribs[nAttribs++] = WGL_GREEN_BITS_ARB;
4355         attribs[nAttribs++] = WGL_BLUE_BITS_ARB;
4356         attribs[nAttribs++] = WGL_ALPHA_BITS_ARB;
4357         attribs[nAttribs++] = WGL_DEPTH_BITS_ARB;
4358         attribs[nAttribs++] = WGL_STENCIL_BITS_ARB;
4359         attribs[nAttribs++] = WGL_DRAW_TO_WINDOW_ARB;
4360         attribs[nAttribs++] = WGL_PIXEL_TYPE_ARB;
4361         attribs[nAttribs++] = WGL_DOUBLE_BUFFER_ARB;
4362         attribs[nAttribs++] = WGL_AUX_BUFFERS_ARB;
4363
4364         for (iPixelFormat=1; iPixelFormat <= adapter->nCfgs; ++iPixelFormat)
4365         {
4366             res = GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc, iPixelFormat, 0, nAttribs, attribs, values));
4367
4368             if(!res)
4369                 continue;
4370
4371             /* Cache the pixel format */
4372             cfgs->iPixelFormat = iPixelFormat;
4373             cfgs->redSize = values[0];
4374             cfgs->greenSize = values[1];
4375             cfgs->blueSize = values[2];
4376             cfgs->alphaSize = values[3];
4377             cfgs->depthSize = values[4];
4378             cfgs->stencilSize = values[5];
4379             cfgs->windowDrawable = values[6];
4380             cfgs->iPixelType = values[7];
4381             cfgs->doubleBuffer = values[8];
4382             cfgs->auxBuffers = values[9];
4383
4384             cfgs->pbufferDrawable = FALSE;
4385             /* Check for pbuffer support when it is around as wglGetPixelFormatAttribiv fails for unknown attributes. */
4386             if(GL_SUPPORT(WGL_ARB_PBUFFER)) {
4387                 int attrib = WGL_DRAW_TO_PBUFFER_ARB;
4388                 int value;
4389                 if(GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc, iPixelFormat, 0, 1, &attrib, &value)))
4390                     cfgs->pbufferDrawable = value;
4391             }
4392
4393             cfgs->numSamples = 0;
4394             /* Check multisample support */
4395             if(GL_SUPPORT(ARB_MULTISAMPLE)) {
4396                 int attrib[2] = {WGL_SAMPLE_BUFFERS_ARB, WGL_SAMPLES_ARB};
4397                 int value[2];
4398                 if(GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc, iPixelFormat, 0, 2, attrib, value))) {
4399                     /* value[0] = WGL_SAMPLE_BUFFERS_ARB which tells whether multisampling is supported.
4400                      * value[1] = number of multi sample buffers*/
4401                     if(value[0])
4402                         cfgs->numSamples = value[1];
4403                 }
4404             }
4405
4406             TRACE("iPixelFormat=%d, iPixelType=%#x, doubleBuffer=%d, RGBA=%d/%d/%d/%d, depth=%d, stencil=%d, windowDrawable=%d, pbufferDrawable=%d\n", cfgs->iPixelFormat, cfgs->iPixelType, cfgs->doubleBuffer, cfgs->redSize, cfgs->greenSize, cfgs->blueSize, cfgs->alphaSize, cfgs->depthSize, cfgs->stencilSize, cfgs->windowDrawable, cfgs->pbufferDrawable);
4407             cfgs++;
4408         }
4409
4410         /* D16, D24X8 and D24S8 are common depth / depth+stencil formats. All drivers support them though this doesn't
4411          * mean that the format is offered in hardware. For instance Geforce8 cards don't have offer D16 in hardware
4412          * but just fake it using D24(X8?) which is fine. D3D also allows that.
4413          * Some display drivers (i915 on Linux) only report mixed depth+stencil formats like D24S8. MSDN clearly mentions
4414          * that only on lockable formats (e.g. D16_locked) the bit order is guaranteed and that on other formats the
4415          * driver is allowed to consume more bits EXCEPT for stencil bits.
4416          *
4417          * Mark an adapter with this broken stencil behavior.
4418          */
4419         adapter->brokenStencil = TRUE;
4420         for (i = 0, cfgs = adapter->cfgs; i < adapter->nCfgs; ++i)
4421         {
4422             /* Nearly all drivers offer depth formats without stencil, only on i915 this if-statement won't be entered. */
4423             if(cfgs[i].depthSize && !cfgs[i].stencilSize) {
4424                 adapter->brokenStencil = FALSE;
4425                 break;
4426             }
4427         }
4428
4429         fixup_extensions(&adapter->gl_info);
4430         add_gl_compat_wrappers(&adapter->gl_info);
4431
4432         WineD3D_ReleaseFakeGLContext();
4433
4434         select_shader_mode(&adapter->gl_info, WINED3DDEVTYPE_HAL, &ps_selected_mode, &vs_selected_mode);
4435         select_shader_max_constants(ps_selected_mode, vs_selected_mode, &adapter->gl_info);
4436         fillGLAttribFuncs(&adapter->gl_info);
4437         init_type_lookup(&adapter->gl_info);
4438         adapter->opengl = TRUE;
4439     }
4440     This->adapter_count = 1;
4441     TRACE("%u adapters successfully initialized\n", This->adapter_count);
4442
4443     return TRUE;
4444
4445 nogl_adapter:
4446     /* Initialize an adapter for ddraw-only memory counting */
4447     memset(This->adapters, 0, sizeof(This->adapters));
4448     This->adapters[0].num = 0;
4449     This->adapters[0].opengl = FALSE;
4450     This->adapters[0].monitorPoint.x = -1;
4451     This->adapters[0].monitorPoint.y = -1;
4452
4453     This->adapters[0].driver = "Display";
4454     This->adapters[0].description = "WineD3D DirectDraw Emulation";
4455     if(wined3d_settings.emulated_textureram) {
4456         This->adapters[0].TextureRam = wined3d_settings.emulated_textureram;
4457     } else {
4458         This->adapters[0].TextureRam = 8 * 1024 * 1024; /* This is plenty for a DDraw-only card */
4459     }
4460
4461     This->adapter_count = 1;
4462     return FALSE;
4463 }
4464
4465 /**********************************************************
4466  * IWineD3D VTbl follows
4467  **********************************************************/
4468
4469 const IWineD3DVtbl IWineD3D_Vtbl =
4470 {
4471     /* IUnknown */
4472     IWineD3DImpl_QueryInterface,
4473     IWineD3DImpl_AddRef,
4474     IWineD3DImpl_Release,
4475     /* IWineD3D */
4476     IWineD3DImpl_GetParent,
4477     IWineD3DImpl_GetAdapterCount,
4478     IWineD3DImpl_RegisterSoftwareDevice,
4479     IWineD3DImpl_GetAdapterMonitor,
4480     IWineD3DImpl_GetAdapterModeCount,
4481     IWineD3DImpl_EnumAdapterModes,
4482     IWineD3DImpl_GetAdapterDisplayMode,
4483     IWineD3DImpl_GetAdapterIdentifier,
4484     IWineD3DImpl_CheckDeviceMultiSampleType,
4485     IWineD3DImpl_CheckDepthStencilMatch,
4486     IWineD3DImpl_CheckDeviceType,
4487     IWineD3DImpl_CheckDeviceFormat,
4488     IWineD3DImpl_CheckDeviceFormatConversion,
4489     IWineD3DImpl_GetDeviceCaps,
4490     IWineD3DImpl_CreateDevice
4491 };