git.oblomov.eu Git - wine/blob - dlls/wined3d/directx.c

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