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