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