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 up to Catalyst 9.3 (Linux) and 10.2 (XP/Vista/Win7)
1001      * - Radeon 7xxx (R100) - 9250 (RV250) supported up to Catalyst 6.11 (XP)
1002      * - Rage 128 supported up to 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, "AMD")
1377             || strstr(gl_renderer, "R100")
1378             || strstr(gl_renderer, "R200")
1379             || strstr(gl_renderer, "R300")
1380             || strstr(gl_renderer, "R600")
1381             || strstr(gl_renderer, "R700"))
1382         return HW_VENDOR_ATI;
1383
1384     if (strstr(gl_vendor_string, "Intel(R)")
1385             /* Intel switched from Intel(R) to Intel® recently, so just match Intel. */
1386             || strstr(gl_renderer, "Intel")
1387             || strstr(gl_vendor_string, "Intel Inc."))
1388         return HW_VENDOR_INTEL;
1389
1390     if (strstr(gl_vendor_string, "Mesa")
1391             || strstr(gl_vendor_string, "Tungsten Graphics, Inc")
1392             || strstr(gl_vendor_string, "VMware, Inc."))
1393         return HW_VENDOR_SOFTWARE;
1394
1395     FIXME_(d3d_caps)("Received unrecognized GL_VENDOR %s. Returning HW_VENDOR_NVIDIA.\n", debugstr_a(gl_vendor_string));
1396
1397     return HW_VENDOR_NVIDIA;
1398 }
1399
1400
1401
1402 static enum wined3d_pci_device select_card_nvidia_binary(const struct wined3d_gl_info *gl_info,
1403         const char *gl_renderer)
1404 {
1405     if (WINE_D3D10_CAPABLE(gl_info))
1406     {
1407         /* Geforce 400 - highend */
1408         if (strstr(gl_renderer, "GTX 480"))
1409         {
1410             return CARD_NVIDIA_GEFORCE_GTX480;
1411         }
1412
1413         /* Geforce 400 - midend high */
1414         if (strstr(gl_renderer, "GTX 470"))
1415         {
1416             return CARD_NVIDIA_GEFORCE_GTX470;
1417         }
1418
1419         /* Geforce 400 - midend */
1420         if (strstr(gl_renderer, "GTX 465"))
1421         {
1422             return CARD_NVIDIA_GEFORCE_GTX465;
1423         }
1424
1425         /* Geforce 400 - midend */
1426         if (strstr(gl_renderer, "GTX 460"))
1427         {
1428             return CARD_NVIDIA_GEFORCE_GTX460;
1429         }
1430
1431         /* Geforce 300 highend mobile */
1432         if (strstr(gl_renderer, "GTS 350M")
1433                 || strstr(gl_renderer, "GTS 360M"))
1434         {
1435             return CARD_NVIDIA_GEFORCE_GTS350M;
1436         }
1437
1438         /* Geforce 300 midend mobile (Geforce GT 325M/330M use the same core) */
1439         if (strstr(gl_renderer, "GT 325M")
1440                 || strstr(gl_renderer, "GT 330M"))
1441         {
1442             return CARD_NVIDIA_GEFORCE_GT325M;
1443         }
1444
1445         /* Geforce 200 - highend */
1446         if (strstr(gl_renderer, "GTX 280")
1447                 || strstr(gl_renderer, "GTX 285")
1448                 || strstr(gl_renderer, "GTX 295"))
1449         {
1450             return CARD_NVIDIA_GEFORCE_GTX280;
1451         }
1452
1453         /* Geforce 200 - midend high */
1454         if (strstr(gl_renderer, "GTX 275"))
1455         {
1456             return CARD_NVIDIA_GEFORCE_GTX275;
1457         }
1458
1459         /* Geforce 200 - midend */
1460         if (strstr(gl_renderer, "GTX 260"))
1461         {
1462             return CARD_NVIDIA_GEFORCE_GTX260;
1463         }
1464         /* Geforce 200 - midend */
1465         if (strstr(gl_renderer, "GT 240"))
1466         {
1467            return CARD_NVIDIA_GEFORCE_GT240;
1468         }
1469
1470         /* Geforce 200 lowend */
1471         if (strstr(gl_renderer, "GT 220"))
1472         {
1473            return CARD_NVIDIA_GEFORCE_GT220;
1474         }
1475         /* Geforce 200 lowend (Geforce 305/310 use the same core) */
1476         if (strstr(gl_renderer, "Geforce 210")
1477                 || strstr(gl_renderer, "G 210")
1478                 || strstr(gl_renderer, "Geforce 305")
1479                 || strstr(gl_renderer, "Geforce 310"))
1480         {
1481            return CARD_NVIDIA_GEFORCE_210;
1482         }
1483
1484         /* Geforce9 - highend / Geforce 200 - midend (GTS 150/250 are based on the same core) */
1485         if (strstr(gl_renderer, "9800")
1486                 || strstr(gl_renderer, "GTS 150")
1487                 || strstr(gl_renderer, "GTS 250"))
1488         {
1489             return CARD_NVIDIA_GEFORCE_9800GT;
1490         }
1491
1492         /* Geforce9 - midend (GT 140 uses the same core as the 9600GT) */
1493         if (strstr(gl_renderer, "9600")
1494                 || strstr(gl_renderer, "GT 140"))
1495         {
1496             return CARD_NVIDIA_GEFORCE_9600GT;
1497         }
1498
1499         /* Geforce9 - midend low / Geforce 200 - low */
1500         if (strstr(gl_renderer, "9500")
1501                 || strstr(gl_renderer, "GT 120")
1502                 || strstr(gl_renderer, "GT 130"))
1503         {
1504             return CARD_NVIDIA_GEFORCE_9500GT;
1505         }
1506
1507         /* Geforce9 - lowend */
1508         if (strstr(gl_renderer, "9400"))
1509         {
1510             return CARD_NVIDIA_GEFORCE_9400GT;
1511         }
1512
1513         /* Geforce9 - lowend low */
1514         if (strstr(gl_renderer, "9100")
1515                 || strstr(gl_renderer, "9200")
1516                 || strstr(gl_renderer, "9300")
1517                 || strstr(gl_renderer, "G 100"))
1518         {
1519             return CARD_NVIDIA_GEFORCE_9200;
1520         }
1521
1522         /* Geforce8 - highend high*/
1523         if (strstr(gl_renderer, "8800 GTX"))
1524         {
1525             return CARD_NVIDIA_GEFORCE_8800GTX;
1526         }
1527
1528         /* Geforce8 - highend */
1529         if (strstr(gl_renderer, "8800"))
1530         {
1531             return CARD_NVIDIA_GEFORCE_8800GTS;
1532         }
1533
1534         /* Geforce8 - midend mobile */
1535         if (strstr(gl_renderer, "8600 M"))
1536         {
1537             return CARD_NVIDIA_GEFORCE_8600MGT;
1538         }
1539
1540         /* Geforce8 - midend */
1541         if (strstr(gl_renderer, "8600")
1542                 || strstr(gl_renderer, "8700"))
1543         {
1544             return CARD_NVIDIA_GEFORCE_8600GT;
1545         }
1546
1547         /* Geforce8 - mid-lowend */
1548         if (strstr(gl_renderer, "8400")
1549                 || strstr(gl_renderer, "8500"))
1550         {
1551             return CARD_NVIDIA_GEFORCE_8400GS;
1552         }
1553
1554         /* Geforce8 - lowend */
1555         if (strstr(gl_renderer, "8100")
1556                 || strstr(gl_renderer, "8200")
1557                 || strstr(gl_renderer, "8300"))
1558         {
1559             return CARD_NVIDIA_GEFORCE_8300GS;
1560         }
1561
1562         /* Geforce8-compatible fall back if the GPU is not in the list yet */
1563         return CARD_NVIDIA_GEFORCE_8300GS;
1564     }
1565
1566     /* Both the GeforceFX, 6xxx and 7xxx series support D3D9. The last two types have more
1567      * shader capabilities, so we use the shader capabilities to distinguish between FX and 6xxx/7xxx.
1568      */
1569     if (WINE_D3D9_CAPABLE(gl_info) && gl_info->supported[NV_VERTEX_PROGRAM3])
1570     {
1571         /* Geforce7 - highend */
1572         if (strstr(gl_renderer, "7800")
1573                 || strstr(gl_renderer, "7900")
1574                 || strstr(gl_renderer, "7950")
1575                 || strstr(gl_renderer, "Quadro FX 4")
1576                 || strstr(gl_renderer, "Quadro FX 5"))
1577         {
1578             return CARD_NVIDIA_GEFORCE_7800GT;
1579         }
1580
1581         /* Geforce7 midend */
1582         if (strstr(gl_renderer, "7600")
1583                 || strstr(gl_renderer, "7700"))
1584         {
1585             return CARD_NVIDIA_GEFORCE_7600;
1586         }
1587
1588         /* Geforce7 lower medium */
1589         if (strstr(gl_renderer, "7400"))
1590         {
1591             return CARD_NVIDIA_GEFORCE_7400;
1592         }
1593
1594         /* Geforce7 lowend */
1595         if (strstr(gl_renderer, "7300"))
1596         {
1597             return CARD_NVIDIA_GEFORCE_7300;
1598         }
1599
1600         /* Geforce6 highend */
1601         if (strstr(gl_renderer, "6800"))
1602         {
1603             return CARD_NVIDIA_GEFORCE_6800;
1604         }
1605
1606         /* Geforce6 - midend */
1607         if (strstr(gl_renderer, "6600")
1608                 || strstr(gl_renderer, "6610")
1609                 || strstr(gl_renderer, "6700"))
1610         {
1611             return CARD_NVIDIA_GEFORCE_6600GT;
1612         }
1613
1614         /* Geforce6/7 lowend */
1615         return CARD_NVIDIA_GEFORCE_6200; /* Geforce 6100/6150/6200/7300/7400/7500 */
1616     }
1617
1618     if (WINE_D3D9_CAPABLE(gl_info))
1619     {
1620         /* GeforceFX - highend */
1621         if (strstr(gl_renderer, "5800")
1622                 || strstr(gl_renderer, "5900")
1623                 || strstr(gl_renderer, "5950")
1624                 || strstr(gl_renderer, "Quadro FX"))
1625         {
1626             return CARD_NVIDIA_GEFORCEFX_5800;
1627         }
1628
1629         /* GeforceFX - midend */
1630         if (strstr(gl_renderer, "5600")
1631                 || strstr(gl_renderer, "5650")
1632                 || strstr(gl_renderer, "5700")
1633                 || strstr(gl_renderer, "5750"))
1634         {
1635             return CARD_NVIDIA_GEFORCEFX_5600;
1636         }
1637
1638         /* GeforceFX - lowend */
1639         return CARD_NVIDIA_GEFORCEFX_5200; /* GeforceFX 5100/5200/5250/5300/5500 */
1640     }
1641
1642     if (WINE_D3D8_CAPABLE(gl_info))
1643     {
1644         if (strstr(gl_renderer, "GeForce4 Ti") || strstr(gl_renderer, "Quadro4"))
1645         {
1646             return CARD_NVIDIA_GEFORCE4_TI4200; /* Geforce4 Ti4200/Ti4400/Ti4600/Ti4800, Quadro4 */
1647         }
1648
1649         return CARD_NVIDIA_GEFORCE3; /* Geforce3 standard/Ti200/Ti500, Quadro DCC */
1650     }
1651
1652     if (WINE_D3D7_CAPABLE(gl_info))
1653     {
1654         if (strstr(gl_renderer, "GeForce4 MX"))
1655         {
1656             return CARD_NVIDIA_GEFORCE4_MX; /* MX420/MX440/MX460/MX4000 */
1657         }
1658
1659         if (strstr(gl_renderer, "GeForce2 MX") || strstr(gl_renderer, "Quadro2 MXR"))
1660         {
1661             return CARD_NVIDIA_GEFORCE2_MX; /* Geforce2 standard/MX100/MX200/MX400, Quadro2 MXR */
1662         }
1663
1664         if (strstr(gl_renderer, "GeForce2") || strstr(gl_renderer, "Quadro2"))
1665         {
1666             return CARD_NVIDIA_GEFORCE2; /* Geforce2 GTS/Pro/Ti/Ultra, Quadro2 */
1667         }
1668
1669         return CARD_NVIDIA_GEFORCE; /* Geforce 256/DDR, Quadro */
1670     }
1671
1672     if (strstr(gl_renderer, "TNT2"))
1673     {
1674         return CARD_NVIDIA_RIVA_TNT2; /* Riva TNT2 standard/M64/Pro/Ultra */
1675     }
1676
1677     return CARD_NVIDIA_RIVA_TNT; /* Riva TNT, Vanta */
1678 }
1679
1680 static enum wined3d_pci_device select_card_ati_binary(const struct wined3d_gl_info *gl_info,
1681         const char *gl_renderer)
1682 {
1683     /* See http://developer.amd.com/drivers/pc_vendor_id/Pages/default.aspx
1684      *
1685      * Beware: renderer string do not match exact card model,
1686      * eg HD 4800 is returned for multiple cards, even for RV790 based ones. */
1687     if (WINE_D3D10_CAPABLE(gl_info))
1688     {
1689         /* Radeon EG CYPRESS XT / PRO HD5800 - highend */
1690         if (strstr(gl_renderer, "HD 5800")          /* Radeon EG CYPRESS HD58xx generic renderer string */
1691                 || strstr(gl_renderer, "HD 5850")   /* Radeon EG CYPRESS XT */
1692                 || strstr(gl_renderer, "HD 5870"))  /* Radeon EG CYPRESS PRO */
1693         {
1694             return CARD_ATI_RADEON_HD5800;
1695         }
1696
1697         /* Radeon EG JUNIPER XT / LE HD5700 - midend */
1698         if (strstr(gl_renderer, "HD 5700")          /* Radeon EG JUNIPER HD57xx generic renderer string */
1699                 || strstr(gl_renderer, "HD 5750")   /* Radeon EG JUNIPER LE */
1700                 || strstr(gl_renderer, "HD 5770"))  /* Radeon EG JUNIPER XT */
1701         {
1702             return CARD_ATI_RADEON_HD5700;
1703         }
1704
1705         /* Radeon R7xx HD4800 - highend */
1706         if (strstr(gl_renderer, "HD 4800")          /* Radeon RV7xx HD48xx generic renderer string */
1707                 || strstr(gl_renderer, "HD 4830")   /* Radeon RV770 */
1708                 || strstr(gl_renderer, "HD 4850")   /* Radeon RV770 */
1709                 || strstr(gl_renderer, "HD 4870")   /* Radeon RV770 */
1710                 || strstr(gl_renderer, "HD 4890"))  /* Radeon RV790 */
1711         {
1712             return CARD_ATI_RADEON_HD4800;
1713         }
1714
1715         /* Radeon R740 HD4700 - midend */
1716         if (strstr(gl_renderer, "HD 4700")          /* Radeon RV770 */
1717                 || strstr(gl_renderer, "HD 4770"))  /* Radeon RV740 */
1718         {
1719             return CARD_ATI_RADEON_HD4700;
1720         }
1721
1722         /* Radeon R730 HD4600 - midend */
1723         if (strstr(gl_renderer, "HD 4600")          /* Radeon RV730 */
1724                 || strstr(gl_renderer, "HD 4650")   /* Radeon RV730 */
1725                 || strstr(gl_renderer, "HD 4670"))  /* Radeon RV730 */
1726         {
1727             return CARD_ATI_RADEON_HD4600;
1728         }
1729
1730         /* Radeon R710 HD4500/HD4350 - lowend */
1731         if (strstr(gl_renderer, "HD 4350")          /* Radeon RV710 */
1732                 || strstr(gl_renderer, "HD 4550"))  /* Radeon RV710 */
1733         {
1734             return CARD_ATI_RADEON_HD4350;
1735         }
1736
1737         /* Radeon R6xx HD2900/HD3800 - highend */
1738         if (strstr(gl_renderer, "HD 2900")
1739                 || strstr(gl_renderer, "HD 3870")
1740                 || strstr(gl_renderer, "HD 3850"))
1741         {
1742             return CARD_ATI_RADEON_HD2900;
1743         }
1744
1745         /* Radeon R6xx HD2600/HD3600 - midend; HD3830 is China-only midend */
1746         if (strstr(gl_renderer, "HD 2600")
1747                 || strstr(gl_renderer, "HD 3830")
1748                 || strstr(gl_renderer, "HD 3690")
1749                 || strstr(gl_renderer, "HD 3650"))
1750         {
1751             return CARD_ATI_RADEON_HD2600;
1752         }
1753
1754         /* Radeon R6xx HD2350/HD2400/HD3400 - lowend
1755          * Note HD2300=DX9, HD2350=DX10 */
1756         if (strstr(gl_renderer, "HD 2350")
1757                 || strstr(gl_renderer, "HD 2400")
1758                 || strstr(gl_renderer, "HD 3470")
1759                 || strstr(gl_renderer, "HD 3450")
1760                 || strstr(gl_renderer, "HD 3430")
1761                 || strstr(gl_renderer, "HD 3400"))
1762         {
1763             return CARD_ATI_RADEON_HD2350;
1764         }
1765
1766         /* Radeon R6xx/R7xx integrated */
1767         if (strstr(gl_renderer, "HD 3100")
1768                 || strstr(gl_renderer, "HD 3200")
1769                 || strstr(gl_renderer, "HD 3300"))
1770         {
1771             return CARD_ATI_RADEON_HD3200;
1772         }
1773
1774         /* Default for when no GPU has been found */
1775         return CARD_ATI_RADEON_HD3200;
1776     }
1777
1778     if (WINE_D3D8_CAPABLE(gl_info))
1779     {
1780         /* Radeon R5xx */
1781         if (strstr(gl_renderer, "X1600")
1782                 || strstr(gl_renderer, "X1650")
1783                 || strstr(gl_renderer, "X1800")
1784                 || strstr(gl_renderer, "X1900")
1785                 || strstr(gl_renderer, "X1950"))
1786         {
1787             return CARD_ATI_RADEON_X1600;
1788         }
1789
1790         /* Radeon R4xx + X1300/X1400/X1450/X1550/X2300/X2500/HD2300 (lowend R5xx)
1791          * Note X2300/X2500/HD2300 are R5xx GPUs with a 2xxx naming but they are still DX9-only */
1792         if (strstr(gl_renderer, "X700")
1793                 || strstr(gl_renderer, "X800")
1794                 || strstr(gl_renderer, "X850")
1795                 || strstr(gl_renderer, "X1300")
1796                 || strstr(gl_renderer, "X1400")
1797                 || strstr(gl_renderer, "X1450")
1798                 || strstr(gl_renderer, "X1550")
1799                 || strstr(gl_renderer, "X2300")
1800                 || strstr(gl_renderer, "X2500")
1801                 || strstr(gl_renderer, "HD 2300")
1802                 )
1803         {
1804             return CARD_ATI_RADEON_X700;
1805         }
1806
1807         /* Radeon Xpress Series - onboard, DX9b, Shader 2.0, 300-400MHz */
1808         if (strstr(gl_renderer, "Radeon Xpress"))
1809         {
1810             return CARD_ATI_RADEON_XPRESS_200M;
1811         }
1812
1813         /* Radeon R3xx */
1814         return CARD_ATI_RADEON_9500; /* Radeon 9500/9550/9600/9700/9800/X300/X550/X600 */
1815     }
1816
1817     if (WINE_D3D8_CAPABLE(gl_info))
1818     {
1819         return CARD_ATI_RADEON_8500; /* Radeon 8500/9000/9100/9200/9300 */
1820     }
1821
1822     if (WINE_D3D7_CAPABLE(gl_info))
1823     {
1824         return CARD_ATI_RADEON_7200; /* Radeon 7000/7100/7200/7500 */
1825     }
1826
1827     return CARD_ATI_RAGE_128PRO;
1828 }
1829
1830 static enum wined3d_pci_device select_card_intel(const struct wined3d_gl_info *gl_info,
1831         const char *gl_renderer)
1832 {
1833     if (strstr(gl_renderer, "X3100") || strstr(gl_renderer, "965GM"))
1834     {
1835         /* MacOS calls the card GMA X3100, otherwise known as GM965/GL960 */
1836         return CARD_INTEL_X3100;
1837     }
1838
1839     if (strstr(gl_renderer, "GMA 950") || strstr(gl_renderer, "945GM"))
1840     {
1841         /* MacOS calls the card GMA 950, but everywhere else the PCI ID is named 945GM */
1842         return CARD_INTEL_I945GM;
1843     }
1844
1845     if (strstr(gl_renderer, "915GM")) return CARD_INTEL_I915GM;
1846     if (strstr(gl_renderer, "915G")) return CARD_INTEL_I915G;
1847     if (strstr(gl_renderer, "865G")) return CARD_INTEL_I865G;
1848     if (strstr(gl_renderer, "855G")) return CARD_INTEL_I855G;
1849     if (strstr(gl_renderer, "830G")) return CARD_INTEL_I830G;
1850     return CARD_INTEL_I915G;
1851
1852 }
1853
1854 static enum wined3d_pci_device select_card_ati_mesa(const struct wined3d_gl_info *gl_info,
1855         const char *gl_renderer)
1856 {
1857     /* See http://developer.amd.com/drivers/pc_vendor_id/Pages/default.aspx
1858      *
1859      * Beware: renderer string do not match exact card model,
1860      * eg HD 4800 is returned for multiple cards, even for RV790 based ones. */
1861     if (strstr(gl_renderer, "Gallium"))
1862     {
1863         /* Radeon R7xx HD4800 - highend */
1864         if (strstr(gl_renderer, "R700")          /* Radeon R7xx HD48xx generic renderer string */
1865                 || strstr(gl_renderer, "RV770")  /* Radeon RV770 */
1866                 || strstr(gl_renderer, "RV790"))  /* Radeon RV790 */
1867         {
1868             return CARD_ATI_RADEON_HD4800;
1869         }
1870
1871         /* Radeon R740 HD4700 - midend */
1872         if (strstr(gl_renderer, "RV740"))          /* Radeon RV740 */
1873         {
1874             return CARD_ATI_RADEON_HD4700;
1875         }
1876
1877         /* Radeon R730 HD4600 - midend */
1878         if (strstr(gl_renderer, "RV730"))        /* Radeon RV730 */
1879         {
1880             return CARD_ATI_RADEON_HD4600;
1881         }
1882
1883         /* Radeon R710 HD4500/HD4350 - lowend */
1884         if (strstr(gl_renderer, "RV710"))          /* Radeon RV710 */
1885         {
1886             return CARD_ATI_RADEON_HD4350;
1887         }
1888
1889         /* Radeon R6xx HD2900/HD3800 - highend */
1890         if (strstr(gl_renderer, "R600")
1891                 || strstr(gl_renderer, "RV670")
1892                 || strstr(gl_renderer, "R680"))
1893         {
1894             return CARD_ATI_RADEON_HD2900;
1895         }
1896
1897         /* Radeon R6xx HD2600/HD3600 - midend; HD3830 is China-only midend */
1898         if (strstr(gl_renderer, "RV630")
1899                 || strstr(gl_renderer, "RV635"))
1900         {
1901             return CARD_ATI_RADEON_HD2600;
1902         }
1903
1904         /* Radeon R6xx HD2350/HD2400/HD3400 - lowend */
1905         if (strstr(gl_renderer, "RV610")
1906                 || strstr(gl_renderer, "RV620"))
1907         {
1908             return CARD_ATI_RADEON_HD2350;
1909         }
1910
1911         /* Radeon R6xx/R7xx integrated */
1912         if (strstr(gl_renderer, "RS780")
1913                 || strstr(gl_renderer, "RS880"))
1914         {
1915             return CARD_ATI_RADEON_HD3200;
1916         }
1917
1918         /* Radeon R5xx */
1919         if (strstr(gl_renderer, "RV530")
1920                 || strstr(gl_renderer, "RV535")
1921                 || strstr(gl_renderer, "RV560")
1922                 || strstr(gl_renderer, "R520")
1923                 || strstr(gl_renderer, "RV570")
1924                 || strstr(gl_renderer, "R580"))
1925         {
1926             return CARD_ATI_RADEON_X1600;
1927         }
1928
1929         /* Radeon R4xx + X1300/X1400/X1450/X1550/X2300 (lowend R5xx) */
1930         if (strstr(gl_renderer, "R410")
1931                 || strstr(gl_renderer, "R420")
1932                 || strstr(gl_renderer, "R423")
1933                 || strstr(gl_renderer, "R430")
1934                 || strstr(gl_renderer, "R480")
1935                 || strstr(gl_renderer, "R481")
1936                 || strstr(gl_renderer, "RV410")
1937                 || strstr(gl_renderer, "RV515")
1938                 || strstr(gl_renderer, "RV516"))
1939         {
1940             return CARD_ATI_RADEON_X700;
1941         }
1942
1943         /* Radeon Xpress Series - onboard, DX9b, Shader 2.0, 300-400MHz */
1944         if (strstr(gl_renderer, "RS400")
1945                 || strstr(gl_renderer, "RS480")
1946                 || strstr(gl_renderer, "RS482")
1947                 || strstr(gl_renderer, "RS485")
1948                 || strstr(gl_renderer, "RS600")
1949                 || strstr(gl_renderer, "RS690")
1950                 || strstr(gl_renderer, "RS740"))
1951         {
1952             return CARD_ATI_RADEON_XPRESS_200M;
1953         }
1954
1955         /* Radeon R3xx */
1956         if (strstr(gl_renderer, "R300")
1957                 || strstr(gl_renderer, "RV350")
1958                 || strstr(gl_renderer, "RV351")
1959                 || strstr(gl_renderer, "RV360")
1960                 || strstr(gl_renderer, "RV370")
1961                 || strstr(gl_renderer, "R350")
1962                 || strstr(gl_renderer, "R360"))
1963         {
1964             return CARD_ATI_RADEON_9500; /* Radeon 9500/9550/9600/9700/9800/X300/X550/X600 */
1965         }
1966     }
1967
1968     if (WINE_D3D9_CAPABLE(gl_info))
1969     {
1970         /* Radeon R7xx HD4800 - highend */
1971         if (strstr(gl_renderer, "(R700")          /* Radeon R7xx HD48xx generic renderer string */
1972                 || strstr(gl_renderer, "(RV770")  /* Radeon RV770 */
1973                 || strstr(gl_renderer, "(RV790"))  /* Radeon RV790 */
1974         {
1975             return CARD_ATI_RADEON_HD4800;
1976         }
1977
1978         /* Radeon R740 HD4700 - midend */
1979         if (strstr(gl_renderer, "(RV740"))          /* Radeon RV740 */
1980         {
1981             return CARD_ATI_RADEON_HD4700;
1982         }
1983
1984         /* Radeon R730 HD4600 - midend */
1985         if (strstr(gl_renderer, "(RV730"))        /* Radeon RV730 */
1986         {
1987             return CARD_ATI_RADEON_HD4600;
1988         }
1989
1990         /* Radeon R710 HD4500/HD4350 - lowend */
1991         if (strstr(gl_renderer, "(RV710"))          /* Radeon RV710 */
1992         {
1993             return CARD_ATI_RADEON_HD4350;
1994         }
1995
1996         /* Radeon R6xx HD2900/HD3800 - highend */
1997         if (strstr(gl_renderer, "(R600")
1998                 || strstr(gl_renderer, "(RV670")
1999                 || strstr(gl_renderer, "(R680"))
2000         {
2001             return CARD_ATI_RADEON_HD2900;
2002         }
2003
2004         /* Radeon R6xx HD2600/HD3600 - midend; HD3830 is China-only midend */
2005         if (strstr(gl_renderer, "(RV630")
2006                 || strstr(gl_renderer, "(RV635"))
2007         {
2008             return CARD_ATI_RADEON_HD2600;
2009         }
2010
2011         /* Radeon R6xx HD2300/HD2400/HD3400 - lowend */
2012         if (strstr(gl_renderer, "(RV610")
2013                 || strstr(gl_renderer, "(RV620"))
2014         {
2015             return CARD_ATI_RADEON_HD2350;
2016         }
2017
2018         /* Radeon R6xx/R7xx integrated */
2019         if (strstr(gl_renderer, "(RS780")
2020                 || strstr(gl_renderer, "(RS880"))
2021         {
2022             return CARD_ATI_RADEON_HD3200;
2023         }
2024     }
2025
2026     if (WINE_D3D8_CAPABLE(gl_info))
2027     {
2028         return CARD_ATI_RADEON_8500; /* Radeon 8500/9000/9100/9200/9300 */
2029     }
2030
2031     if (WINE_D3D7_CAPABLE(gl_info))
2032     {
2033         return CARD_ATI_RADEON_7200; /* Radeon 7000/7100/7200/7500 */
2034     }
2035
2036     return CARD_ATI_RAGE_128PRO;
2037 }
2038
2039 static enum wined3d_pci_device select_card_nvidia_mesa(const struct wined3d_gl_info *gl_info,
2040         const char *gl_renderer)
2041 {
2042     FIXME_(d3d_caps)("Card selection not handled for Mesa Nouveau driver\n");
2043     if (WINE_D3D9_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCEFX_5600;
2044     if (WINE_D3D8_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCE3;
2045     if (WINE_D3D7_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCE;
2046     if (WINE_D3D6_CAPABLE(gl_info)) return CARD_NVIDIA_RIVA_TNT;
2047     return CARD_NVIDIA_RIVA_128;
2048 }
2049
2050
2051 struct vendor_card_selection
2052 {
2053     enum wined3d_gl_vendor gl_vendor;
2054     enum wined3d_pci_vendor card_vendor;
2055     const char *description;        /* Description of the card selector i.e. Apple OS/X Intel */
2056     enum wined3d_pci_device (*select_card)(const struct wined3d_gl_info *gl_info, const char *gl_renderer);
2057 };
2058
2059 static const struct vendor_card_selection vendor_card_select_table[] =
2060 {
2061     {GL_VENDOR_NVIDIA, HW_VENDOR_NVIDIA,  "Nvidia binary driver",     select_card_nvidia_binary},
2062     {GL_VENDOR_APPLE,  HW_VENDOR_NVIDIA,  "Apple OSX NVidia binary driver",   select_card_nvidia_binary},
2063     {GL_VENDOR_APPLE,  HW_VENDOR_ATI,     "Apple OSX AMD/ATI binary driver",  select_card_ati_binary},
2064     {GL_VENDOR_APPLE,  HW_VENDOR_INTEL,   "Apple OSX Intel binary driver",    select_card_intel},
2065     {GL_VENDOR_FGLRX,  HW_VENDOR_ATI,     "AMD/ATI binary driver",    select_card_ati_binary},
2066     {GL_VENDOR_MESA,   HW_VENDOR_ATI,     "Mesa AMD/ATI driver",      select_card_ati_mesa},
2067     {GL_VENDOR_MESA,   HW_VENDOR_NVIDIA,  "Mesa Nouveau driver",      select_card_nvidia_mesa},
2068     {GL_VENDOR_MESA,   HW_VENDOR_INTEL,   "Mesa Intel driver",        select_card_intel},
2069     {GL_VENDOR_INTEL,  HW_VENDOR_INTEL,   "Mesa Intel driver",        select_card_intel}
2070 };
2071
2072
2073 static enum wined3d_pci_device wined3d_guess_card(const struct wined3d_gl_info *gl_info, const char *gl_renderer,
2074         enum wined3d_gl_vendor *gl_vendor, enum wined3d_pci_vendor *card_vendor)
2075 {
2076     /* Above is a list of Nvidia and ATI GPUs. Both vendors have dozens of
2077      * different GPUs with roughly the same features. In most cases GPUs from a
2078      * certain family differ in clockspeeds, the amount of video memory and the
2079      * number of shader pipelines.
2080      *
2081      * A Direct3D device object contains the PCI id (vendor + device) of the
2082      * videocard which is used for rendering. Various applications use this
2083      * information to get a rough estimation of the features of the card and
2084      * some might use it for enabling 3d effects only on certain types of
2085      * videocards. In some cases games might even use it to work around bugs
2086      * which happen on certain videocards/driver combinations. The problem is
2087      * that OpenGL only exposes a rendering string containing the name of the
2088      * videocard and not the PCI id.
2089      *
2090      * Various games depend on the PCI id, so somehow we need to provide one.
2091      * A simple option is to parse the renderer string and translate this to
2092      * the right PCI id. This is a lot of work because there are more than 200
2093      * GPUs just for Nvidia. Various cards share the same renderer string, so
2094      * the amount of code might be 'small' but there are quite a number of
2095      * exceptions which would make this a pain to maintain. Another way would
2096      * be to query the PCI id from the operating system (assuming this is the
2097      * videocard which is used for rendering which is not always the case).
2098      * This would work but it is not very portable. Second it would not work
2099      * well in, let's say, a remote X situation in which the amount of 3d
2100      * features which can be used is limited.
2101      *
2102      * As said most games only use the PCI id to get an indication of the
2103      * capabilities of the card. It doesn't really matter if the given id is
2104      * the correct one if we return the id of a card with similar 3d features.
2105      *
2106      * The code below checks the OpenGL capabilities of a videocard and matches
2107      * that to a certain level of Direct3D functionality. Once a card passes
2108      * the Direct3D9 check, we know that the card (in case of Nvidia) is at
2109      * least a GeforceFX. To give a better estimate we do a basic check on the
2110      * renderer string but if that won't pass we return a default card. This
2111      * way is better than maintaining a full card database as even without a
2112      * full database we can return a card with similar features. Second the
2113      * size of the database can be made quite small because when you know what
2114      * type of 3d functionality a card has, you know to which GPU family the
2115      * GPU must belong. Because of this you only have to check a small part of
2116      * the renderer string to distinguishes between different models from that
2117      * family.
2118      *
2119      * The code also selects a default amount of video memory which we will
2120      * use for an estimation of the amount of free texture memory. In case of
2121      * real D3D the amount of texture memory includes video memory and system
2122      * memory (to be specific AGP memory or in case of PCIE TurboCache /
2123      * HyperMemory). We don't know how much system memory can be addressed by
2124      * the system but we can make a reasonable estimation about the amount of
2125      * video memory. If the value is slightly wrong it doesn't matter as we
2126      * didn't include AGP-like memory which makes the amount of addressable
2127      * memory higher and second OpenGL isn't that critical it moves to system
2128      * memory behind our backs if really needed. Note that the amount of video
2129      * memory can be overruled using a registry setting. */
2130
2131     int i;
2132
2133     for (i = 0; i < (sizeof(vendor_card_select_table) / sizeof(*vendor_card_select_table)); ++i)
2134     {
2135         if ((vendor_card_select_table[i].gl_vendor != *gl_vendor)
2136             || (vendor_card_select_table[i].card_vendor != *card_vendor))
2137                 continue;
2138         TRACE_(d3d_caps)("Applying card_selector \"%s\".\n", vendor_card_select_table[i].description);
2139         return vendor_card_select_table[i].select_card(gl_info, gl_renderer);
2140     }
2141
2142     FIXME_(d3d_caps)("No card selector available for GL vendor %d and card vendor %04x.\n",
2143                      *gl_vendor, *card_vendor);
2144
2145     /* Default to generic Nvidia hardware based on the supported OpenGL extensions. The choice
2146      * for Nvidia was because the hardware and drivers they make are of good quality. This makes
2147      * them a good generic choice. */
2148     *card_vendor = HW_VENDOR_NVIDIA;
2149     if (WINE_D3D9_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCEFX_5600;
2150     if (WINE_D3D8_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCE3;
2151     if (WINE_D3D7_CAPABLE(gl_info)) return CARD_NVIDIA_GEFORCE;
2152     if (WINE_D3D6_CAPABLE(gl_info)) return CARD_NVIDIA_RIVA_TNT;
2153     return CARD_NVIDIA_RIVA_128;
2154 }
2155
2156 static const struct fragment_pipeline *select_fragment_implementation(struct wined3d_adapter *adapter)
2157 {
2158     const struct wined3d_gl_info *gl_info = &adapter->gl_info;
2159     int vs_selected_mode, ps_selected_mode;
2160
2161     select_shader_mode(gl_info, &ps_selected_mode, &vs_selected_mode);
2162     if ((ps_selected_mode == SHADER_ARB || ps_selected_mode == SHADER_GLSL)
2163             && gl_info->supported[ARB_FRAGMENT_PROGRAM]) return &arbfp_fragment_pipeline;
2164     else if (ps_selected_mode == SHADER_ATI) return &atifs_fragment_pipeline;
2165     else if (gl_info->supported[NV_REGISTER_COMBINERS]
2166             && gl_info->supported[NV_TEXTURE_SHADER2]) return &nvts_fragment_pipeline;
2167     else if (gl_info->supported[NV_REGISTER_COMBINERS]) return &nvrc_fragment_pipeline;
2168     else return &ffp_fragment_pipeline;
2169 }
2170
2171 static const shader_backend_t *select_shader_backend(struct wined3d_adapter *adapter)
2172 {
2173     int vs_selected_mode, ps_selected_mode;
2174
2175     select_shader_mode(&adapter->gl_info, &ps_selected_mode, &vs_selected_mode);
2176     if (vs_selected_mode == SHADER_GLSL || ps_selected_mode == SHADER_GLSL) return &glsl_shader_backend;
2177     if (vs_selected_mode == SHADER_ARB || ps_selected_mode == SHADER_ARB) return &arb_program_shader_backend;
2178     return &none_shader_backend;
2179 }
2180
2181 static const struct blit_shader *select_blit_implementation(struct wined3d_adapter *adapter)
2182 {
2183     const struct wined3d_gl_info *gl_info = &adapter->gl_info;
2184     int vs_selected_mode, ps_selected_mode;
2185
2186     select_shader_mode(gl_info, &ps_selected_mode, &vs_selected_mode);
2187     if ((ps_selected_mode == SHADER_ARB || ps_selected_mode == SHADER_GLSL)
2188             && gl_info->supported[ARB_FRAGMENT_PROGRAM]) return &arbfp_blit;
2189     else return &ffp_blit;
2190 }
2191
2192 static void load_gl_funcs(struct wined3d_gl_info *gl_info, DWORD gl_version)
2193 {
2194     DWORD ver;
2195
2196 #define USE_GL_FUNC(type, pfn, ext, replace) \
2197     if (gl_info->supported[ext]) gl_info->pfn = (type)pwglGetProcAddress(#pfn); \
2198     else if ((ver = ver_for_ext(ext)) && ver <= gl_version) gl_info->pfn = (type)pwglGetProcAddress(#replace); \
2199     else gl_info->pfn = NULL;
2200
2201     GL_EXT_FUNCS_GEN;
2202 #undef USE_GL_FUNC
2203
2204 #define USE_GL_FUNC(type, pfn, ext, replace) gl_info->pfn = (type)pwglGetProcAddress(#pfn);
2205     WGL_EXT_FUNCS_GEN;
2206 #undef USE_GL_FUNC
2207 }
2208
2209 /* Context activation is done by the caller. */
2210 static BOOL IWineD3DImpl_FillGLCaps(struct wined3d_adapter *adapter)
2211 {
2212     struct wined3d_driver_info *driver_info = &adapter->driver_info;
2213     struct wined3d_gl_info *gl_info = &adapter->gl_info;
2214     const char *GL_Extensions    = NULL;
2215     const char *WGL_Extensions   = NULL;
2216     const char *gl_vendor_str, *gl_renderer_str, *gl_version_str;
2217     struct fragment_caps fragment_caps;
2218     enum wined3d_gl_vendor gl_vendor;
2219     enum wined3d_pci_vendor card_vendor;
2220     enum wined3d_pci_device device;
2221     GLint       gl_max;
2222     GLfloat     gl_floatv[2];
2223     unsigned    i;
2224     HDC         hdc;
2225     DWORD gl_version;
2226     size_t len;
2227
2228     TRACE_(d3d_caps)("(%p)\n", gl_info);
2229
2230     ENTER_GL();
2231
2232     gl_renderer_str = (const char *)glGetString(GL_RENDERER);
2233     TRACE_(d3d_caps)("GL_RENDERER: %s.\n", debugstr_a(gl_renderer_str));
2234     if (!gl_renderer_str)
2235     {
2236         LEAVE_GL();
2237         ERR_(d3d_caps)("Received a NULL GL_RENDERER.\n");
2238         return FALSE;
2239     }
2240
2241     gl_vendor_str = (const char *)glGetString(GL_VENDOR);
2242     TRACE_(d3d_caps)("GL_VENDOR: %s.\n", debugstr_a(gl_vendor_str));
2243     if (!gl_vendor_str)
2244     {
2245         LEAVE_GL();
2246         ERR_(d3d_caps)("Received a NULL GL_VENDOR.\n");
2247         return FALSE;
2248     }
2249
2250     /* Parse the GL_VERSION field into major and minor information */
2251     gl_version_str = (const char *)glGetString(GL_VERSION);
2252     TRACE_(d3d_caps)("GL_VERSION: %s.\n", debugstr_a(gl_version_str));
2253     if (!gl_version_str)
2254     {
2255         LEAVE_GL();
2256         ERR_(d3d_caps)("Received a NULL GL_VERSION.\n");
2257         return FALSE;
2258     }
2259     gl_version = wined3d_parse_gl_version(gl_version_str);
2260
2261     /*
2262      * Initialize openGL extension related variables
2263      *  with Default values
2264      */
2265     memset(gl_info->supported, 0, sizeof(gl_info->supported));
2266     gl_info->limits.blends = 1;
2267     gl_info->limits.buffers = 1;
2268     gl_info->limits.textures = 1;
2269     gl_info->limits.fragment_samplers = 1;
2270     gl_info->limits.vertex_samplers = 0;
2271     gl_info->limits.combined_samplers = gl_info->limits.fragment_samplers + gl_info->limits.vertex_samplers;
2272     gl_info->limits.sampler_stages = 1;
2273     gl_info->limits.glsl_vs_float_constants = 0;
2274     gl_info->limits.glsl_ps_float_constants = 0;
2275     gl_info->limits.arb_vs_float_constants = 0;
2276     gl_info->limits.arb_vs_native_constants = 0;
2277     gl_info->limits.arb_vs_instructions = 0;
2278     gl_info->limits.arb_vs_temps = 0;
2279     gl_info->limits.arb_ps_float_constants = 0;
2280     gl_info->limits.arb_ps_local_constants = 0;
2281     gl_info->limits.arb_ps_instructions = 0;
2282     gl_info->limits.arb_ps_temps = 0;
2283
2284     /* Retrieve opengl defaults */
2285     glGetIntegerv(GL_MAX_CLIP_PLANES, &gl_max);
2286     gl_info->limits.clipplanes = min(WINED3DMAXUSERCLIPPLANES, gl_max);
2287     TRACE_(d3d_caps)("ClipPlanes support - num Planes=%d\n", gl_max);
2288
2289     glGetIntegerv(GL_MAX_LIGHTS, &gl_max);
2290     gl_info->limits.lights = gl_max;
2291     TRACE_(d3d_caps)("Lights support - max lights=%d\n", gl_max);
2292
2293     glGetIntegerv(GL_MAX_TEXTURE_SIZE, &gl_max);
2294     gl_info->limits.texture_size = gl_max;
2295     TRACE_(d3d_caps)("Maximum texture size support - max texture size=%d\n", gl_max);
2296
2297     glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, gl_floatv);
2298     gl_info->limits.pointsize_min = gl_floatv[0];
2299     gl_info->limits.pointsize_max = gl_floatv[1];
2300     TRACE_(d3d_caps)("Maximum point size support - max point size=%f\n", gl_floatv[1]);
2301
2302     /* Parse the gl supported features, in theory enabling parts of our code appropriately. */
2303     GL_Extensions = (const char *)glGetString(GL_EXTENSIONS);
2304     if (!GL_Extensions)
2305     {
2306         LEAVE_GL();
2307         ERR_(d3d_caps)("Received a NULL GL_EXTENSIONS.\n");
2308         return FALSE;
2309     }
2310
2311     LEAVE_GL();
2312
2313     TRACE_(d3d_caps)("GL_Extensions reported:\n");
2314
2315     gl_info->supported[WINED3D_GL_EXT_NONE] = TRUE;
2316
2317     while (*GL_Extensions)
2318     {
2319         const char *start;
2320
2321         while (isspace(*GL_Extensions)) ++GL_Extensions;
2322         start = GL_Extensions;
2323         while (!isspace(*GL_Extensions) && *GL_Extensions) ++GL_Extensions;
2324
2325         len = GL_Extensions - start;
2326         if (!len) continue;
2327
2328         TRACE_(d3d_caps)("- %s\n", debugstr_an(start, len));
2329
2330         for (i = 0; i < (sizeof(EXTENSION_MAP) / sizeof(*EXTENSION_MAP)); ++i)
2331         {
2332             if (len == strlen(EXTENSION_MAP[i].extension_string)
2333                     && !memcmp(start, EXTENSION_MAP[i].extension_string, len))
2334             {
2335                 TRACE_(d3d_caps)(" FOUND: %s support.\n", EXTENSION_MAP[i].extension_string);
2336                 gl_info->supported[EXTENSION_MAP[i].extension] = TRUE;
2337                 break;
2338             }
2339         }
2340     }
2341
2342     /* Now work out what GL support this card really has */
2343     load_gl_funcs( gl_info, gl_version );
2344
2345     ENTER_GL();
2346
2347     /* Now mark all the extensions supported which are included in the opengl core version. Do this *after*
2348      * loading the functions, otherwise the code above will load the extension entry points instead of the
2349      * core functions, which may not work. */
2350     for (i = 0; i < (sizeof(EXTENSION_MAP) / sizeof(*EXTENSION_MAP)); ++i)
2351     {
2352         if (!gl_info->supported[EXTENSION_MAP[i].extension]
2353                 && EXTENSION_MAP[i].version <= gl_version && EXTENSION_MAP[i].version)
2354         {
2355             TRACE_(d3d_caps)(" GL CORE: %s support.\n", EXTENSION_MAP[i].extension_string);
2356             gl_info->supported[EXTENSION_MAP[i].extension] = TRUE;
2357         }
2358     }
2359
2360     if (gl_version >= MAKEDWORD_VERSION(2, 0)) gl_info->supported[WINED3D_GL_VERSION_2_0] = TRUE;
2361
2362     if (gl_info->supported[APPLE_FENCE])
2363     {
2364         /* GL_NV_fence and GL_APPLE_fence provide the same functionality basically.
2365          * The apple extension interacts with some other apple exts. Disable the NV
2366          * extension if the apple one is support to prevent confusion in other parts
2367          * of the code. */
2368         gl_info->supported[NV_FENCE] = FALSE;
2369     }
2370     if (gl_info->supported[APPLE_FLOAT_PIXELS])
2371     {
2372         /* GL_APPLE_float_pixels == GL_ARB_texture_float + GL_ARB_half_float_pixel
2373          *
2374          * The enums are the same:
2375          * GL_RGBA16F_ARB     = GL_RGBA_FLOAT16_APPLE = 0x881A
2376          * GL_RGB16F_ARB      = GL_RGB_FLOAT16_APPLE  = 0x881B
2377          * GL_RGBA32F_ARB     = GL_RGBA_FLOAT32_APPLE = 0x8814
2378          * GL_RGB32F_ARB      = GL_RGB_FLOAT32_APPLE  = 0x8815
2379          * GL_HALF_FLOAT_ARB  = GL_HALF_APPLE         = 0x140B
2380          */
2381         if (!gl_info->supported[ARB_TEXTURE_FLOAT])
2382         {
2383             TRACE_(d3d_caps)(" IMPLIED: GL_ARB_texture_float support(from GL_APPLE_float_pixels.\n");
2384             gl_info->supported[ARB_TEXTURE_FLOAT] = TRUE;
2385         }
2386         if (!gl_info->supported[ARB_HALF_FLOAT_PIXEL])
2387         {
2388             TRACE_(d3d_caps)(" IMPLIED: GL_ARB_half_float_pixel support(from GL_APPLE_float_pixels.\n");
2389             gl_info->supported[ARB_HALF_FLOAT_PIXEL] = TRUE;
2390         }
2391     }
2392     if (gl_info->supported[ARB_MAP_BUFFER_RANGE])
2393     {
2394         /* GL_ARB_map_buffer_range and GL_APPLE_flush_buffer_range provide the same
2395          * functionality. Prefer the ARB extension */
2396         gl_info->supported[APPLE_FLUSH_BUFFER_RANGE] = FALSE;
2397     }
2398     if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
2399     {
2400         TRACE_(d3d_caps)(" IMPLIED: NVIDIA (NV) Texture Gen Reflection support.\n");
2401         gl_info->supported[NV_TEXGEN_REFLECTION] = TRUE;
2402     }
2403     if (!gl_info->supported[ARB_DEPTH_CLAMP] && gl_info->supported[NV_DEPTH_CLAMP])
2404     {
2405         TRACE_(d3d_caps)(" IMPLIED: ARB_depth_clamp support (by NV_depth_clamp).\n");
2406         gl_info->supported[ARB_DEPTH_CLAMP] = TRUE;
2407     }
2408     if (!gl_info->supported[ARB_VERTEX_ARRAY_BGRA] && gl_info->supported[EXT_VERTEX_ARRAY_BGRA])
2409     {
2410         TRACE_(d3d_caps)(" IMPLIED: ARB_vertex_array_bgra support (by EXT_vertex_array_bgra).\n");
2411         gl_info->supported[ARB_VERTEX_ARRAY_BGRA] = TRUE;
2412     }
2413     if (!gl_info->supported[ARB_TEXTURE_COMPRESSION_RGTC] && gl_info->supported[EXT_TEXTURE_COMPRESSION_RGTC])
2414     {
2415         TRACE_(d3d_caps)(" IMPLIED: ARB_texture_compression_rgtc support (by EXT_texture_compression_rgtc).\n");
2416         gl_info->supported[ARB_TEXTURE_COMPRESSION_RGTC] = TRUE;
2417     }
2418     if (gl_info->supported[NV_TEXTURE_SHADER2])
2419     {
2420         if (gl_info->supported[NV_REGISTER_COMBINERS])
2421         {
2422             /* Also disable ATI_FRAGMENT_SHADER if register combiners and texture_shader2
2423              * are supported. The nv extensions provide the same functionality as the
2424              * ATI one, and a bit more(signed pixelformats). */
2425             gl_info->supported[ATI_FRAGMENT_SHADER] = FALSE;
2426         }
2427     }
2428
2429     if (gl_info->supported[NV_REGISTER_COMBINERS])
2430     {
2431         glGetIntegerv(GL_MAX_GENERAL_COMBINERS_NV, &gl_max);
2432         gl_info->limits.general_combiners = gl_max;
2433         TRACE_(d3d_caps)("Max general combiners: %d.\n", gl_max);
2434     }
2435     if (gl_info->supported[ARB_DRAW_BUFFERS])
2436     {
2437         glGetIntegerv(GL_MAX_DRAW_BUFFERS_ARB, &gl_max);
2438         gl_info->limits.buffers = gl_max;
2439         TRACE_(d3d_caps)("Max draw buffers: %u.\n", gl_max);
2440     }
2441     if (gl_info->supported[ARB_MULTITEXTURE])
2442     {
2443         glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &gl_max);
2444         gl_info->limits.textures = min(MAX_TEXTURES, gl_max);
2445         TRACE_(d3d_caps)("Max textures: %d.\n", gl_info->limits.textures);
2446
2447         if (gl_info->supported[ARB_FRAGMENT_PROGRAM])
2448         {
2449             GLint tmp;
2450             glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS_ARB, &tmp);
2451             gl_info->limits.fragment_samplers = min(MAX_FRAGMENT_SAMPLERS, tmp);
2452         }
2453         else
2454         {
2455             gl_info->limits.fragment_samplers = max(gl_info->limits.fragment_samplers, gl_max);
2456         }
2457         TRACE_(d3d_caps)("Max fragment samplers: %d.\n", gl_info->limits.fragment_samplers);
2458
2459         if (gl_info->supported[ARB_VERTEX_SHADER])
2460         {
2461             GLint tmp;
2462             glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB, &tmp);
2463             gl_info->limits.vertex_samplers = tmp;
2464             glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB, &tmp);
2465             gl_info->limits.combined_samplers = tmp;
2466
2467             /* Loading GLSL sampler uniforms is much simpler if we can assume that the sampler setup
2468              * is known at shader link time. In a vertex shader + pixel shader combination this isn't
2469              * an issue because then the sampler setup only depends on the two shaders. If a pixel
2470              * shader is used with fixed function vertex processing we're fine too because fixed function
2471              * vertex processing doesn't use any samplers. If fixed function fragment processing is
2472              * used we have to make sure that all vertex sampler setups are valid together with all
2473              * possible fixed function fragment processing setups. This is true if vsamplers + MAX_TEXTURES
2474              * <= max_samplers. This is true on all d3d9 cards that support vtf(gf 6 and gf7 cards).
2475              * dx9 radeon cards do not support vertex texture fetch. DX10 cards have 128 samplers, and
2476              * dx9 is limited to 8 fixed function texture stages and 4 vertex samplers. DX10 does not have
2477              * a fixed function pipeline anymore.
2478              *
2479              * So this is just a check to check that our assumption holds true. If not, write a warning
2480              * and reduce the number of vertex samplers or probably disable vertex texture fetch. */
2481             if (gl_info->limits.vertex_samplers && gl_info->limits.combined_samplers < 12
2482                     && MAX_TEXTURES + gl_info->limits.vertex_samplers > gl_info->limits.combined_samplers)
2483             {
2484                 FIXME("OpenGL implementation supports %u vertex samplers and %u total samplers.\n",
2485                         gl_info->limits.vertex_samplers, gl_info->limits.combined_samplers);
2486                 FIXME("Expected vertex samplers + MAX_TEXTURES(=8) > combined_samplers.\n");
2487                 if (gl_info->limits.combined_samplers > MAX_TEXTURES)
2488                     gl_info->limits.vertex_samplers = gl_info->limits.combined_samplers - MAX_TEXTURES;
2489                 else
2490                     gl_info->limits.vertex_samplers = 0;
2491             }
2492         }
2493         else
2494         {
2495             gl_info->limits.combined_samplers = gl_info->limits.fragment_samplers;
2496         }
2497         TRACE_(d3d_caps)("Max vertex samplers: %u.\n", gl_info->limits.vertex_samplers);
2498         TRACE_(d3d_caps)("Max combined samplers: %u.\n", gl_info->limits.combined_samplers);
2499     }
2500     if (gl_info->supported[ARB_VERTEX_BLEND])
2501     {
2502         glGetIntegerv(GL_MAX_VERTEX_UNITS_ARB, &gl_max);
2503         gl_info->limits.blends = gl_max;
2504         TRACE_(d3d_caps)("Max blends: %u.\n", gl_info->limits.blends);
2505     }
2506     if (gl_info->supported[EXT_TEXTURE3D])
2507     {
2508         glGetIntegerv(GL_MAX_3D_TEXTURE_SIZE_EXT, &gl_max);
2509         gl_info->limits.texture3d_size = gl_max;
2510         TRACE_(d3d_caps)("Max texture3D size: %d.\n", gl_info->limits.texture3d_size);
2511     }
2512     if (gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC])
2513     {
2514         glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &gl_max);
2515         gl_info->limits.anisotropy = gl_max;
2516         TRACE_(d3d_caps)("Max anisotropy: %d.\n", gl_info->limits.anisotropy);
2517     }
2518     if (gl_info->supported[ARB_FRAGMENT_PROGRAM])
2519     {
2520         GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max));
2521         gl_info->limits.arb_ps_float_constants = gl_max;
2522         TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM float constants: %d.\n", gl_info->limits.arb_ps_float_constants);
2523         GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB, &gl_max));
2524         gl_info->limits.arb_ps_native_constants = gl_max;
2525         TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM native float constants: %d.\n",
2526                 gl_info->limits.arb_ps_native_constants);
2527         GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, &gl_max));
2528         gl_info->limits.arb_ps_temps = gl_max;
2529         TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM native temporaries: %d.\n", gl_info->limits.arb_ps_temps);
2530         GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, &gl_max));
2531         gl_info->limits.arb_ps_instructions = gl_max;
2532         TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM native instructions: %d.\n", gl_info->limits.arb_ps_instructions);
2533         GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB, &gl_max));
2534         gl_info->limits.arb_ps_local_constants = gl_max;
2535         TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM local parameters: %d.\n", gl_info->limits.arb_ps_instructions);
2536     }
2537     if (gl_info->supported[ARB_VERTEX_PROGRAM])
2538     {
2539         GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max));
2540         gl_info->limits.arb_vs_float_constants = gl_max;
2541         TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM float constants: %d.\n", gl_info->limits.arb_vs_float_constants);
2542         GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB, &gl_max));
2543         gl_info->limits.arb_vs_native_constants = gl_max;
2544         TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM native float constants: %d.\n",
2545                 gl_info->limits.arb_vs_native_constants);
2546         GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, &gl_max));
2547         gl_info->limits.arb_vs_temps = gl_max;
2548         TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM native temporaries: %d.\n", gl_info->limits.arb_vs_temps);
2549         GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, &gl_max));
2550         gl_info->limits.arb_vs_instructions = gl_max;
2551         TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM native instructions: %d.\n", gl_info->limits.arb_vs_instructions);
2552
2553         if (test_arb_vs_offset_limit(gl_info)) gl_info->quirks |= WINED3D_QUIRK_ARB_VS_OFFSET_LIMIT;
2554     }
2555     if (gl_info->supported[ARB_VERTEX_SHADER])
2556     {
2557         glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB, &gl_max);
2558         gl_info->limits.glsl_vs_float_constants = gl_max / 4;
2559         TRACE_(d3d_caps)("Max ARB_VERTEX_SHADER float constants: %u.\n", gl_info->limits.glsl_vs_float_constants);
2560     }
2561     if (gl_info->supported[ARB_FRAGMENT_SHADER])
2562     {
2563         glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB, &gl_max);
2564         gl_info->limits.glsl_ps_float_constants = gl_max / 4;
2565         TRACE_(d3d_caps)("Max ARB_FRAGMENT_SHADER float constants: %u.\n", gl_info->limits.glsl_ps_float_constants);
2566         glGetIntegerv(GL_MAX_VARYING_FLOATS_ARB, &gl_max);
2567         gl_info->limits.glsl_varyings = gl_max;
2568         TRACE_(d3d_caps)("Max GLSL varyings: %u (%u 4 component varyings).\n", gl_max, gl_max / 4);
2569     }
2570     if (gl_info->supported[ARB_SHADING_LANGUAGE_100])
2571     {
2572         const char *str = (const char *)glGetString(GL_SHADING_LANGUAGE_VERSION_ARB);
2573         unsigned int major, minor;
2574
2575         TRACE_(d3d_caps)("GLSL version string: %s.\n", debugstr_a(str));
2576
2577         /* The format of the GLSL version string is "major.minor[.release] [vendor info]". */
2578         sscanf(str, "%u.%u", &major, &minor);
2579         gl_info->glsl_version = MAKEDWORD_VERSION(major, minor);
2580     }
2581     if (gl_info->supported[NV_LIGHT_MAX_EXPONENT])
2582     {
2583         glGetFloatv(GL_MAX_SHININESS_NV, &gl_info->limits.shininess);
2584     }
2585     else
2586     {
2587         gl_info->limits.shininess = 128.0f;
2588     }
2589     if (gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO])
2590     {
2591         /* If we have full NP2 texture support, disable
2592          * GL_ARB_texture_rectangle because we will never use it.
2593          * This saves a few redundant glDisable calls. */
2594         gl_info->supported[ARB_TEXTURE_RECTANGLE] = FALSE;
2595     }
2596     if (gl_info->supported[ATI_FRAGMENT_SHADER])
2597     {
2598         /* Disable NV_register_combiners and fragment shader if this is supported.
2599          * generally the NV extensions are preferred over the ATI ones, and this
2600          * extension is disabled if register_combiners and texture_shader2 are both
2601          * supported. So we reach this place only if we have incomplete NV dxlevel 8
2602          * fragment processing support. */
2603         gl_info->supported[NV_REGISTER_COMBINERS] = FALSE;
2604         gl_info->supported[NV_REGISTER_COMBINERS2] = FALSE;
2605         gl_info->supported[NV_TEXTURE_SHADER] = FALSE;
2606         gl_info->supported[NV_TEXTURE_SHADER2] = FALSE;
2607     }
2608     if (gl_info->supported[NV_HALF_FLOAT])
2609     {
2610         /* GL_ARB_half_float_vertex is a subset of GL_NV_half_float. */
2611         gl_info->supported[ARB_HALF_FLOAT_VERTEX] = TRUE;
2612     }
2613     if (gl_info->supported[ARB_POINT_SPRITE])
2614     {
2615         gl_info->limits.point_sprite_units = gl_info->limits.textures;
2616     }
2617     else
2618     {
2619         gl_info->limits.point_sprite_units = 0;
2620     }
2621     checkGLcall("extension detection");
2622
2623     LEAVE_GL();
2624
2625     adapter->fragment_pipe = select_fragment_implementation(adapter);
2626     adapter->shader_backend = select_shader_backend(adapter);
2627     adapter->blitter = select_blit_implementation(adapter);
2628
2629     adapter->fragment_pipe->get_caps(gl_info, &fragment_caps);
2630     gl_info->limits.texture_stages = fragment_caps.MaxTextureBlendStages;
2631     TRACE_(d3d_caps)("Max texture stages: %u.\n", gl_info->limits.texture_stages);
2632
2633     /* In some cases the number of texture stages can be larger than the number
2634      * of samplers. The GF4 for example can use only 2 samplers (no fragment
2635      * shaders), but 8 texture stages (register combiners). */
2636     gl_info->limits.sampler_stages = max(gl_info->limits.fragment_samplers, gl_info->limits.texture_stages);
2637
2638     if (gl_info->supported[ARB_FRAMEBUFFER_OBJECT])
2639     {
2640         gl_info->fbo_ops.glIsRenderbuffer = gl_info->glIsRenderbuffer;
2641         gl_info->fbo_ops.glBindRenderbuffer = gl_info->glBindRenderbuffer;
2642         gl_info->fbo_ops.glDeleteRenderbuffers = gl_info->glDeleteRenderbuffers;
2643         gl_info->fbo_ops.glGenRenderbuffers = gl_info->glGenRenderbuffers;
2644         gl_info->fbo_ops.glRenderbufferStorage = gl_info->glRenderbufferStorage;
2645         gl_info->fbo_ops.glRenderbufferStorageMultisample = gl_info->glRenderbufferStorageMultisample;
2646         gl_info->fbo_ops.glGetRenderbufferParameteriv = gl_info->glGetRenderbufferParameteriv;
2647         gl_info->fbo_ops.glIsFramebuffer = gl_info->glIsFramebuffer;
2648         gl_info->fbo_ops.glBindFramebuffer = gl_info->glBindFramebuffer;
2649         gl_info->fbo_ops.glDeleteFramebuffers = gl_info->glDeleteFramebuffers;
2650         gl_info->fbo_ops.glGenFramebuffers = gl_info->glGenFramebuffers;
2651         gl_info->fbo_ops.glCheckFramebufferStatus = gl_info->glCheckFramebufferStatus;
2652         gl_info->fbo_ops.glFramebufferTexture1D = gl_info->glFramebufferTexture1D;
2653         gl_info->fbo_ops.glFramebufferTexture2D = gl_info->glFramebufferTexture2D;
2654         gl_info->fbo_ops.glFramebufferTexture3D = gl_info->glFramebufferTexture3D;
2655         gl_info->fbo_ops.glFramebufferRenderbuffer = gl_info->glFramebufferRenderbuffer;
2656         gl_info->fbo_ops.glGetFramebufferAttachmentParameteriv = gl_info->glGetFramebufferAttachmentParameteriv;
2657         gl_info->fbo_ops.glBlitFramebuffer = gl_info->glBlitFramebuffer;
2658         gl_info->fbo_ops.glGenerateMipmap = gl_info->glGenerateMipmap;
2659     }
2660     else
2661     {
2662         if (gl_info->supported[EXT_FRAMEBUFFER_OBJECT])
2663         {
2664             gl_info->fbo_ops.glIsRenderbuffer = gl_info->glIsRenderbufferEXT;
2665             gl_info->fbo_ops.glBindRenderbuffer = gl_info->glBindRenderbufferEXT;
2666             gl_info->fbo_ops.glDeleteRenderbuffers = gl_info->glDeleteRenderbuffersEXT;
2667             gl_info->fbo_ops.glGenRenderbuffers = gl_info->glGenRenderbuffersEXT;
2668             gl_info->fbo_ops.glRenderbufferStorage = gl_info->glRenderbufferStorageEXT;
2669             gl_info->fbo_ops.glGetRenderbufferParameteriv = gl_info->glGetRenderbufferParameterivEXT;
2670             gl_info->fbo_ops.glIsFramebuffer = gl_info->glIsFramebufferEXT;
2671             gl_info->fbo_ops.glBindFramebuffer = gl_info->glBindFramebufferEXT;
2672             gl_info->fbo_ops.glDeleteFramebuffers = gl_info->glDeleteFramebuffersEXT;
2673             gl_info->fbo_ops.glGenFramebuffers = gl_info->glGenFramebuffersEXT;
2674             gl_info->fbo_ops.glCheckFramebufferStatus = gl_info->glCheckFramebufferStatusEXT;
2675             gl_info->fbo_ops.glFramebufferTexture1D = gl_info->glFramebufferTexture1DEXT;
2676             gl_info->fbo_ops.glFramebufferTexture2D = gl_info->glFramebufferTexture2DEXT;
2677             gl_info->fbo_ops.glFramebufferTexture3D = gl_info->glFramebufferTexture3DEXT;
2678             gl_info->fbo_ops.glFramebufferRenderbuffer = gl_info->glFramebufferRenderbufferEXT;
2679             gl_info->fbo_ops.glGetFramebufferAttachmentParameteriv = gl_info->glGetFramebufferAttachmentParameterivEXT;
2680             gl_info->fbo_ops.glGenerateMipmap = gl_info->glGenerateMipmapEXT;
2681         }
2682         else if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
2683         {
2684             WARN_(d3d_caps)("Framebuffer objects not supported, falling back to backbuffer offscreen rendering mode.\n");
2685             wined3d_settings.offscreen_rendering_mode = ORM_BACKBUFFER;
2686         }
2687         if (gl_info->supported[EXT_FRAMEBUFFER_BLIT])
2688         {
2689             gl_info->fbo_ops.glBlitFramebuffer = gl_info->glBlitFramebufferEXT;
2690         }
2691         if (gl_info->supported[EXT_FRAMEBUFFER_MULTISAMPLE])
2692         {
2693             gl_info->fbo_ops.glRenderbufferStorageMultisample = gl_info->glRenderbufferStorageMultisampleEXT;
2694         }
2695     }
2696
2697     /* MRTs are currently only supported when FBOs are used. */
2698     if (wined3d_settings.offscreen_rendering_mode != ORM_FBO)
2699     {
2700         gl_info->limits.buffers = 1;
2701     }
2702
2703     gl_vendor = wined3d_guess_gl_vendor(gl_info, gl_vendor_str, gl_renderer_str);
2704     card_vendor = wined3d_guess_card_vendor(gl_vendor_str, gl_renderer_str);
2705     TRACE_(d3d_caps)("found GL_VENDOR (%s)->(0x%04x/0x%04x)\n", debugstr_a(gl_vendor_str), gl_vendor, card_vendor);
2706
2707     device = wined3d_guess_card(gl_info, gl_renderer_str, &gl_vendor, &card_vendor);
2708     TRACE_(d3d_caps)("FOUND (fake) card: 0x%x (vendor id), 0x%x (device id)\n", card_vendor, device);
2709
2710     gl_info->wrap_lookup[WINED3DTADDRESS_WRAP - WINED3DTADDRESS_WRAP] = GL_REPEAT;
2711     gl_info->wrap_lookup[WINED3DTADDRESS_MIRROR - WINED3DTADDRESS_WRAP] =
2712             gl_info->supported[ARB_TEXTURE_MIRRORED_REPEAT] ? GL_MIRRORED_REPEAT_ARB : GL_REPEAT;
2713     gl_info->wrap_lookup[WINED3DTADDRESS_CLAMP - WINED3DTADDRESS_WRAP] = GL_CLAMP_TO_EDGE;
2714     gl_info->wrap_lookup[WINED3DTADDRESS_BORDER - WINED3DTADDRESS_WRAP] =
2715             gl_info->supported[ARB_TEXTURE_BORDER_CLAMP] ? GL_CLAMP_TO_BORDER_ARB : GL_REPEAT;
2716     gl_info->wrap_lookup[WINED3DTADDRESS_MIRRORONCE - WINED3DTADDRESS_WRAP] =
2717             gl_info->supported[ATI_TEXTURE_MIRROR_ONCE] ? GL_MIRROR_CLAMP_TO_EDGE_ATI : GL_REPEAT;
2718
2719     /* Make sure there's an active HDC else the WGL extensions will fail */
2720     hdc = pwglGetCurrentDC();
2721     if (hdc) {
2722         /* Not all GL drivers might offer WGL extensions e.g. VirtualBox */
2723         if(GL_EXTCALL(wglGetExtensionsStringARB))
2724             WGL_Extensions = GL_EXTCALL(wglGetExtensionsStringARB(hdc));
2725
2726         if (!WGL_Extensions)
2727         {
2728             ERR("   WGL_Extensions returns NULL\n");
2729         }
2730         else
2731         {
2732             TRACE_(d3d_caps)("WGL_Extensions reported:\n");
2733             while (*WGL_Extensions)
2734             {
2735                 const char *Start;
2736                 char ThisExtn[256];
2737
2738                 while (isspace(*WGL_Extensions)) WGL_Extensions++;
2739                 Start = WGL_Extensions;
2740                 while (!isspace(*WGL_Extensions) && *WGL_Extensions) ++WGL_Extensions;
2741
2742                 len = WGL_Extensions - Start;
2743                 if (!len || len >= sizeof(ThisExtn))
2744                     continue;
2745
2746                 memcpy(ThisExtn, Start, len);
2747                 ThisExtn[len] = '\0';
2748                 TRACE_(d3d_caps)("- %s\n", debugstr_a(ThisExtn));
2749
2750                 if (!strcmp(ThisExtn, "WGL_ARB_pixel_format")) {
2751                     gl_info->supported[WGL_ARB_PIXEL_FORMAT] = TRUE;
2752                     TRACE_(d3d_caps)("FOUND: WGL_ARB_pixel_format support\n");
2753                 }
2754                 if (!strcmp(ThisExtn, "WGL_WINE_pixel_format_passthrough")) {
2755                     gl_info->supported[WGL_WINE_PIXEL_FORMAT_PASSTHROUGH] = TRUE;
2756                     TRACE_(d3d_caps)("FOUND: WGL_WINE_pixel_format_passthrough support\n");
2757                 }
2758             }
2759         }
2760     }
2761
2762     fixup_extensions(gl_info, gl_renderer_str, gl_vendor, card_vendor, device);
2763     init_driver_info(driver_info, card_vendor, device);
2764     add_gl_compat_wrappers(gl_info);
2765
2766     return TRUE;
2767 }
2768
2769 /**********************************************************
2770  * IWineD3D implementation follows
2771  **********************************************************/
2772
2773 static UINT     WINAPI IWineD3DImpl_GetAdapterCount (IWineD3D *iface) {
2774     IWineD3DImpl *This = (IWineD3DImpl *)iface;
2775
2776     TRACE_(d3d_caps)("(%p): Reporting %u adapters\n", This, This->adapter_count);
2777
2778     return This->adapter_count;
2779 }
2780
2781 static HRESULT WINAPI IWineD3DImpl_RegisterSoftwareDevice(IWineD3D *iface, void *init_function)
2782 {
2783     FIXME("iface %p, init_function %p stub!\n", iface, init_function);
2784
2785     return WINED3D_OK;
2786 }
2787
2788 static HMONITOR WINAPI IWineD3DImpl_GetAdapterMonitor(IWineD3D *iface, UINT Adapter) {
2789     IWineD3DImpl *This = (IWineD3DImpl *)iface;
2790
2791     TRACE_(d3d_caps)("(%p)->(%d)\n", This, Adapter);
2792
2793     if (Adapter >= IWineD3DImpl_GetAdapterCount(iface)) {
2794         return NULL;
2795     }
2796
2797     return MonitorFromPoint(This->adapters[Adapter].monitorPoint, MONITOR_DEFAULTTOPRIMARY);
2798 }
2799
2800 /* FIXME: GetAdapterModeCount and EnumAdapterModes currently only returns modes
2801      of the same bpp but different resolutions                                  */
2802
2803 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */
2804 static UINT WINAPI IWineD3DImpl_GetAdapterModeCount(IWineD3D *iface, UINT Adapter, enum wined3d_format_id format_id)
2805 {
2806     IWineD3DImpl *This = (IWineD3DImpl *)iface;
2807
2808     TRACE_(d3d_caps)("iface %p, adapter %u, format_id: %s.\n", iface, Adapter, debug_d3dformat(format_id));
2809
2810     if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
2811         return 0;
2812     }
2813
2814     /* TODO: Store modes per adapter and read it from the adapter structure */
2815     if (Adapter == 0)
2816     {
2817         const struct wined3d_format *format = wined3d_get_format(&This->adapters[Adapter].gl_info, format_id);
2818         UINT format_bits = format->byte_count * CHAR_BIT;
2819         unsigned int i = 0;
2820         unsigned int j = 0;
2821         DEVMODEW mode;
2822
2823         memset(&mode, 0, sizeof(mode));
2824         mode.dmSize = sizeof(mode);
2825
2826         while (EnumDisplaySettingsExW(NULL, j, &mode, 0))
2827         {
2828             ++j;
2829
2830             if (format_id == WINED3DFMT_UNKNOWN)
2831             {
2832                 /* This is for D3D8, do not enumerate P8 here */
2833                 if (mode.dmBitsPerPel == 32 || mode.dmBitsPerPel == 16) ++i;
2834             }
2835             else if (mode.dmBitsPerPel == format_bits)
2836             {
2837                 ++i;
2838             }
2839         }
2840
2841         TRACE_(d3d_caps)("(%p}->(Adapter: %d) => %d (out of %d)\n", This, Adapter, i, j);
2842         return i;
2843     } else {
2844         FIXME_(d3d_caps)("Adapter not primary display\n");
2845     }
2846     return 0;
2847 }
2848
2849 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */
2850 static HRESULT WINAPI IWineD3DImpl_EnumAdapterModes(IWineD3D *iface, UINT Adapter,
2851         enum wined3d_format_id format_id, UINT Mode, WINED3DDISPLAYMODE *pMode)
2852 {
2853     IWineD3DImpl *This = (IWineD3DImpl *)iface;
2854
2855     TRACE_(d3d_caps)("iface %p, adapter_idx %u, format %s, mode_idx %u, mode %p.\n",
2856             iface, Adapter, debug_d3dformat(format_id), Mode, pMode);
2857
2858     /* Validate the parameters as much as possible */
2859     if (!pMode || Adapter >= IWineD3DImpl_GetAdapterCount(iface)
2860             || Mode >= IWineD3DImpl_GetAdapterModeCount(iface, Adapter, format_id))
2861     {
2862         return WINED3DERR_INVALIDCALL;
2863     }
2864
2865     /* TODO: Store modes per adapter and read it from the adapter structure */
2866     if (Adapter == 0)
2867     {
2868         const struct wined3d_format *format = wined3d_get_format(&This->adapters[Adapter].gl_info, format_id);
2869         UINT format_bits = format->byte_count * CHAR_BIT;
2870         DEVMODEW DevModeW;
2871         int ModeIdx = 0;
2872         UINT i = 0;
2873         int j = 0;
2874
2875         ZeroMemory(&DevModeW, sizeof(DevModeW));
2876         DevModeW.dmSize = sizeof(DevModeW);
2877
2878         /* If we are filtering to a specific format (D3D9), then need to skip
2879            all unrelated modes, but if mode is irrelevant (D3D8), then we can
2880            just count through the ones with valid bit depths */
2881         while ((i<=Mode) && EnumDisplaySettingsExW(NULL, j++, &DevModeW, 0))
2882         {
2883             if (format_id == WINED3DFMT_UNKNOWN)
2884             {
2885                 /* This is for D3D8, do not enumerate P8 here */
2886                 if (DevModeW.dmBitsPerPel == 32 || DevModeW.dmBitsPerPel == 16) ++i;
2887             }
2888             else if (DevModeW.dmBitsPerPel == format_bits)
2889             {
2890                 ++i;
2891             }
2892         }
2893
2894         if (!i)
2895         {
2896             TRACE_(d3d_caps)("No modes found for format (%x - %s)\n", format_id, debug_d3dformat(format_id));
2897             return WINED3DERR_INVALIDCALL;
2898         }
2899         ModeIdx = j - 1;
2900
2901         /* Now get the display mode via the calculated index */
2902         if (EnumDisplaySettingsExW(NULL, ModeIdx, &DevModeW, 0)) {
2903             pMode->Width        = DevModeW.dmPelsWidth;
2904             pMode->Height       = DevModeW.dmPelsHeight;
2905             pMode->RefreshRate  = DEFAULT_REFRESH_RATE;
2906             if (DevModeW.dmFields & DM_DISPLAYFREQUENCY)
2907                 pMode->RefreshRate = DevModeW.dmDisplayFrequency;
2908
2909             if (format_id == WINED3DFMT_UNKNOWN)
2910                 pMode->Format = pixelformat_for_depth(DevModeW.dmBitsPerPel);
2911             else
2912                 pMode->Format = format_id;
2913         }
2914         else
2915         {
2916             TRACE_(d3d_caps)("Requested mode out of range %d\n", Mode);
2917             return WINED3DERR_INVALIDCALL;
2918         }
2919
2920         TRACE_(d3d_caps)("W %d H %d rr %d fmt (%x - %s) bpp %u\n", pMode->Width, pMode->Height,
2921                 pMode->RefreshRate, pMode->Format, debug_d3dformat(pMode->Format),
2922                 DevModeW.dmBitsPerPel);
2923
2924     }
2925     else
2926     {
2927         FIXME_(d3d_caps)("Adapter not primary display\n");
2928     }
2929
2930     return WINED3D_OK;
2931 }
2932
2933 static HRESULT WINAPI IWineD3DImpl_GetAdapterDisplayMode(IWineD3D *iface, UINT Adapter, WINED3DDISPLAYMODE *pMode)
2934 {
2935     TRACE("iface %p, adapter_idx %u, display_mode %p.\n", iface, Adapter, pMode);
2936
2937     if (!pMode || Adapter >= IWineD3D_GetAdapterCount(iface))
2938         return WINED3DERR_INVALIDCALL;
2939
2940     if (Adapter == 0) { /* Display */
2941         int bpp = 0;
2942         DEVMODEW DevModeW;
2943
2944         ZeroMemory(&DevModeW, sizeof(DevModeW));
2945         DevModeW.dmSize = sizeof(DevModeW);
2946
2947         EnumDisplaySettingsExW(NULL, ENUM_CURRENT_SETTINGS, &DevModeW, 0);
2948         pMode->Width        = DevModeW.dmPelsWidth;
2949         pMode->Height       = DevModeW.dmPelsHeight;
2950         bpp                 = DevModeW.dmBitsPerPel;
2951         pMode->RefreshRate  = DEFAULT_REFRESH_RATE;
2952         if (DevModeW.dmFields&DM_DISPLAYFREQUENCY)
2953         {
2954             pMode->RefreshRate = DevModeW.dmDisplayFrequency;
2955         }
2956
2957         pMode->Format = pixelformat_for_depth(bpp);
2958     } else {
2959         FIXME_(d3d_caps)("Adapter not primary display\n");
2960     }
2961
2962     TRACE_(d3d_caps)("returning w:%d, h:%d, ref:%d, fmt:%s\n", pMode->Width,
2963           pMode->Height, pMode->RefreshRate, debug_d3dformat(pMode->Format));
2964     return WINED3D_OK;
2965 }
2966
2967 /* NOTE: due to structure differences between dx8 and dx9 D3DADAPTER_IDENTIFIER,
2968    and fields being inserted in the middle, a new structure is used in place    */
2969 static HRESULT WINAPI IWineD3DImpl_GetAdapterIdentifier(IWineD3D *iface, UINT Adapter, DWORD Flags,
2970                                                    WINED3DADAPTER_IDENTIFIER* pIdentifier) {
2971     IWineD3DImpl *This = (IWineD3DImpl *)iface;
2972     struct wined3d_adapter *adapter;
2973     size_t len;
2974
2975     TRACE_(d3d_caps)("(%p}->(Adapter: %d, Flags: %x, pId=%p)\n", This, Adapter, Flags, pIdentifier);
2976
2977     if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
2978         return WINED3DERR_INVALIDCALL;
2979     }
2980
2981     adapter = &This->adapters[Adapter];
2982
2983     /* Return the information requested */
2984     TRACE_(d3d_caps)("device/Vendor Name and Version detection using FillGLCaps\n");
2985
2986     if (pIdentifier->driver_size)
2987     {
2988         const char *name = adapter->driver_info.name;
2989         len = min(strlen(name), pIdentifier->driver_size - 1);
2990         memcpy(pIdentifier->driver, name, len);
2991         pIdentifier->driver[len] = '\0';
2992     }
2993
2994     if (pIdentifier->description_size)
2995     {
2996         const char *description = adapter->driver_info.description;
2997         len = min(strlen(description), pIdentifier->description_size - 1);
2998         memcpy(pIdentifier->description, description, len);
2999         pIdentifier->description[len] = '\0';
3000     }
3001
3002     /* Note that d3d8 doesn't supply a device name. */
3003     if (pIdentifier->device_name_size)
3004     {
3005         static const char *device_name = "\\\\.\\DISPLAY1"; /* FIXME: May depend on desktop? */
3006
3007         len = strlen(device_name);
3008         if (len >= pIdentifier->device_name_size)
3009         {
3010             ERR("Device name size too small.\n");
3011             return WINED3DERR_INVALIDCALL;
3012         }
3013
3014         memcpy(pIdentifier->device_name, device_name, len);
3015         pIdentifier->device_name[len] = '\0';
3016     }
3017
3018     pIdentifier->driver_version.u.HighPart = adapter->driver_info.version_high;
3019     pIdentifier->driver_version.u.LowPart = adapter->driver_info.version_low;
3020     pIdentifier->vendor_id = adapter->driver_info.vendor;
3021     pIdentifier->device_id = adapter->driver_info.device;
3022     pIdentifier->subsystem_id = 0;
3023     pIdentifier->revision = 0;
3024     memcpy(&pIdentifier->device_identifier, &IID_D3DDEVICE_D3DUID, sizeof(pIdentifier->device_identifier));
3025     pIdentifier->whql_level = (Flags & WINED3DENUM_NO_WHQL_LEVEL) ? 0 : 1;
3026     memcpy(&pIdentifier->adapter_luid, &adapter->luid, sizeof(pIdentifier->adapter_luid));
3027     pIdentifier->video_memory = adapter->TextureRam;
3028
3029     return WINED3D_OK;
3030 }
3031
3032 static BOOL IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(const struct wined3d_gl_info *gl_info,
3033         const WineD3D_PixelFormat *cfg, const struct wined3d_format *format)
3034 {
3035     short redSize, greenSize, blueSize, alphaSize, colorBits;
3036
3037     if(!cfg)
3038         return FALSE;
3039
3040     /* Float formats need FBOs. If FBOs are used this function isn't called */
3041     if (format->Flags & WINED3DFMT_FLAG_FLOAT) return FALSE;
3042
3043     if(cfg->iPixelType == WGL_TYPE_RGBA_ARB) { /* Integer RGBA formats */
3044         if (!getColorBits(format, &redSize, &greenSize, &blueSize, &alphaSize, &colorBits))
3045         {
3046             ERR("Unable to check compatibility for format %s.\n", debug_d3dformat(format->id));
3047             return FALSE;
3048         }
3049
3050         if(cfg->redSize < redSize)
3051             return FALSE;
3052
3053         if(cfg->greenSize < greenSize)
3054             return FALSE;
3055
3056         if(cfg->blueSize < blueSize)
3057             return FALSE;
3058
3059         if(cfg->alphaSize < alphaSize)
3060             return FALSE;
3061
3062         return TRUE;
3063     }
3064
3065     /* Probably a RGBA_float or color index mode */
3066     return FALSE;
3067 }
3068
3069 static BOOL IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(const struct wined3d_gl_info *gl_info,
3070         const WineD3D_PixelFormat *cfg, const struct wined3d_format *format)
3071 {
3072     short depthSize, stencilSize;
3073     BOOL lockable = FALSE;
3074
3075     if(!cfg)
3076         return FALSE;
3077
3078     if (!getDepthStencilBits(format, &depthSize, &stencilSize))
3079     {
3080         ERR("Unable to check compatibility for format %s.\n", debug_d3dformat(format->id));
3081         return FALSE;
3082     }
3083
3084     /* Float formats need FBOs. If FBOs are used this function isn't called */
3085     if (format->Flags & WINED3DFMT_FLAG_FLOAT) return FALSE;
3086
3087     if ((format->id == WINED3DFMT_D16_LOCKABLE) || (format->id == WINED3DFMT_D32_FLOAT))
3088         lockable = TRUE;
3089
3090     /* On some modern cards like the Geforce8/9 GLX doesn't offer some dephthstencil formats which D3D9 reports.
3091      * We can safely report 'compatible' formats (e.g. D24 can be used for D16) as long as we aren't dealing with
3092      * a lockable format. This also helps D3D <= 7 as they expect D16 which isn't offered without this on Geforce8 cards. */
3093     if(!(cfg->depthSize == depthSize || (!lockable && cfg->depthSize > depthSize)))
3094         return FALSE;
3095
3096     /* Some cards like Intel i915 ones only offer D24S8 but lots of games also need a format without stencil, so
3097      * allow more stencil bits than requested. */
3098     if(cfg->stencilSize < stencilSize)
3099         return FALSE;
3100
3101     return TRUE;
3102 }
3103
3104 static HRESULT WINAPI IWineD3DImpl_CheckDepthStencilMatch(IWineD3D *iface,
3105         UINT Adapter, WINED3DDEVTYPE DeviceType, enum wined3d_format_id AdapterFormat,
3106         enum wined3d_format_id RenderTargetFormat, enum wined3d_format_id DepthStencilFormat)
3107 {
3108     IWineD3DImpl *This = (IWineD3DImpl *)iface;
3109     int nCfgs;
3110     const WineD3D_PixelFormat *cfgs;
3111     const struct wined3d_adapter *adapter;
3112     const struct wined3d_format *rt_format;
3113     const struct wined3d_format *ds_format;
3114     int it;
3115
3116     WARN_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, DevType:(%x,%s), AdptFmt:(%x,%s), RendrTgtFmt:(%x,%s), DepthStencilFmt:(%x,%s))\n",
3117            This, Adapter,
3118            DeviceType, debug_d3ddevicetype(DeviceType),
3119            AdapterFormat, debug_d3dformat(AdapterFormat),
3120            RenderTargetFormat, debug_d3dformat(RenderTargetFormat),
3121            DepthStencilFormat, debug_d3dformat(DepthStencilFormat));
3122
3123     if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
3124         TRACE("(%p) Failed: Atapter (%u) higher than supported adapters (%u) returning WINED3DERR_INVALIDCALL\n", This, Adapter, IWineD3D_GetAdapterCount(iface));
3125         return WINED3DERR_INVALIDCALL;
3126     }
3127
3128     adapter = &This->adapters[Adapter];
3129     rt_format = wined3d_get_format(&adapter->gl_info, RenderTargetFormat);
3130     ds_format = wined3d_get_format(&adapter->gl_info, DepthStencilFormat);
3131     if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
3132     {
3133         if ((rt_format->Flags & WINED3DFMT_FLAG_RENDERTARGET)
3134                 && (ds_format->Flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL)))
3135         {
3136             TRACE_(d3d_caps)("(%p) : Formats matched\n", This);
3137             return WINED3D_OK;
3138         }
3139     }
3140     else
3141     {
3142         cfgs = adapter->cfgs;
3143         nCfgs = adapter->nCfgs;
3144         for (it = 0; it < nCfgs; ++it)
3145         {
3146             if (IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&adapter->gl_info, &cfgs[it], rt_format))
3147             {
3148                 if (IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&adapter->gl_info, &cfgs[it], ds_format))
3149                 {
3150                     TRACE_(d3d_caps)("(%p) : Formats matched\n", This);
3151                     return WINED3D_OK;
3152                 }
3153             }
3154         }
3155     }
3156     WARN_(d3d_caps)("unsupported format pair: %s and %s\n", debug_d3dformat(RenderTargetFormat), debug_d3dformat(DepthStencilFormat));
3157
3158     return WINED3DERR_NOTAVAILABLE;
3159 }
3160
3161 static HRESULT WINAPI IWineD3DImpl_CheckDeviceMultiSampleType(IWineD3D *iface, UINT Adapter,
3162         WINED3DDEVTYPE DeviceType, enum wined3d_format_id SurfaceFormat, BOOL Windowed,
3163         WINED3DMULTISAMPLE_TYPE MultiSampleType, DWORD *pQualityLevels)
3164 {
3165     IWineD3DImpl *This = (IWineD3DImpl *)iface;
3166     const struct wined3d_adapter *adapter;
3167     const struct wined3d_format *format;
3168
3169     TRACE_(d3d_caps)("(%p)-> (Adptr:%d, DevType:(%x,%s), SurfFmt:(%x,%s), Win?%d, MultiSamp:%x, pQual:%p)\n",
3170           This,
3171           Adapter,
3172           DeviceType, debug_d3ddevicetype(DeviceType),
3173           SurfaceFormat, debug_d3dformat(SurfaceFormat),
3174           Windowed,
3175           MultiSampleType,
3176           pQualityLevels);
3177
3178     if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
3179         return WINED3DERR_INVALIDCALL;
3180     }
3181
3182     /* TODO: handle Windowed, add more quality levels */
3183
3184     if (WINED3DMULTISAMPLE_NONE == MultiSampleType) {
3185         if(pQualityLevels) *pQualityLevels = 1;
3186         return WINED3D_OK;
3187     }
3188
3189     /* By default multisampling is disabled right now as it causes issues
3190      * on some Nvidia driver versions and it doesn't work well in combination
3191      * with FBOs yet. */
3192     if(!wined3d_settings.allow_multisampling)
3193         return WINED3DERR_NOTAVAILABLE;
3194
3195     adapter = &This->adapters[Adapter];
3196     format = wined3d_get_format(&adapter->gl_info, SurfaceFormat);
3197     if (!format) return WINED3DERR_INVALIDCALL;
3198
3199     if (format->Flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL))
3200     {
3201         int i, nCfgs;
3202         const WineD3D_PixelFormat *cfgs;
3203
3204         cfgs = adapter->cfgs;
3205         nCfgs = adapter->nCfgs;
3206         for(i=0; i<nCfgs; i++) {
3207             if(cfgs[i].numSamples != MultiSampleType)
3208                 continue;
3209
3210             if (!IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&adapter->gl_info, &cfgs[i], format))
3211                 continue;
3212
3213             TRACE("Found iPixelFormat=%d to support MultiSampleType=%d for format %s\n", cfgs[i].iPixelFormat, MultiSampleType, debug_d3dformat(SurfaceFormat));
3214
3215             if(pQualityLevels)
3216                 *pQualityLevels = 1; /* Guess at a value! */
3217             return WINED3D_OK;
3218         }
3219     }
3220     else if (format->Flags & WINED3DFMT_FLAG_RENDERTARGET)
3221     {
3222         short redSize, greenSize, blueSize, alphaSize, colorBits;
3223         int i, nCfgs;
3224         const WineD3D_PixelFormat *cfgs;
3225
3226         if (!getColorBits(format, &redSize, &greenSize, &blueSize, &alphaSize, &colorBits))
3227         {
3228             ERR("Unable to color bits for format %#x, can't check multisampling capability!\n", SurfaceFormat);
3229             return WINED3DERR_NOTAVAILABLE;
3230         }
3231
3232         cfgs = adapter->cfgs;
3233         nCfgs = adapter->nCfgs;
3234         for(i=0; i<nCfgs; i++) {
3235             if(cfgs[i].numSamples != MultiSampleType)
3236                 continue;
3237             if(cfgs[i].redSize != redSize)
3238                 continue;
3239             if(cfgs[i].greenSize != greenSize)
3240                 continue;
3241             if(cfgs[i].blueSize != blueSize)
3242                 continue;
3243             /* Not all drivers report alpha-less formats since they use 32-bit anyway, so accept alpha even if we didn't ask for it. */
3244             if(alphaSize && cfgs[i].alphaSize != alphaSize)
3245                 continue;
3246             if (cfgs[i].colorSize != (format->byte_count << 3))
3247                 continue;
3248
3249             TRACE("Found iPixelFormat=%d to support MultiSampleType=%d for format %s\n", cfgs[i].iPixelFormat, MultiSampleType, debug_d3dformat(SurfaceFormat));
3250
3251             if(pQualityLevels)
3252                 *pQualityLevels = 1; /* Guess at a value! */
3253             return WINED3D_OK;
3254         }
3255     }
3256     return WINED3DERR_NOTAVAILABLE;
3257 }
3258
3259 /* Check if we support bumpmapping for a format */
3260 static BOOL CheckBumpMapCapability(struct wined3d_adapter *adapter, const struct wined3d_format *format)
3261 {
3262     /* Ask the fixed function pipeline implementation if it can deal
3263      * with the conversion. If we've got a GL extension giving native
3264      * support this will be an identity conversion. */
3265     return (format->Flags & WINED3DFMT_FLAG_BUMPMAP)
3266             && adapter->fragment_pipe->color_fixup_supported(format->color_fixup);
3267 }
3268
3269 /* Check if the given DisplayFormat + DepthStencilFormat combination is valid for the Adapter */
3270 static BOOL CheckDepthStencilCapability(struct wined3d_adapter *adapter,
3271         const struct wined3d_format *display_format, const struct wined3d_format *ds_format)
3272 {
3273     int it=0;
3274
3275     /* Only allow depth/stencil formats */
3276     if (!(ds_format->depth_size || ds_format->stencil_size)) return FALSE;
3277
3278     if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
3279     {
3280         /* With FBOs WGL limitations do not apply, but the format needs to be FBO attachable */
3281         if (ds_format->Flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL)) return TRUE;
3282     }
3283     else
3284     {
3285         /* Walk through all WGL pixel formats to find a match */
3286         for (it = 0; it < adapter->nCfgs; ++it)
3287         {
3288             WineD3D_PixelFormat *cfg = &adapter->cfgs[it];
3289             if (IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&adapter->gl_info, cfg, display_format))
3290             {
3291                 if (IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&adapter->gl_info, cfg, ds_format))
3292                 {
3293                     return TRUE;
3294                 }
3295             }
3296         }
3297     }
3298
3299     return FALSE;
3300 }
3301
3302 static BOOL CheckFilterCapability(struct wined3d_adapter *adapter, const struct wined3d_format *format)
3303 {
3304     /* The flags entry of a format contains the filtering capability */
3305     if (format->Flags & WINED3DFMT_FLAG_FILTERING) return TRUE;
3306
3307     return FALSE;
3308 }
3309
3310 /* Check the render target capabilities of a format */
3311 static BOOL CheckRenderTargetCapability(struct wined3d_adapter *adapter,
3312         const struct wined3d_format *adapter_format, const struct wined3d_format *check_format)
3313 {
3314     /* Filter out non-RT formats */
3315     if (!(check_format->Flags & WINED3DFMT_FLAG_RENDERTARGET)) return FALSE;
3316     if (wined3d_settings.offscreen_rendering_mode == ORM_BACKBUFFER)
3317     {
3318         WineD3D_PixelFormat *cfgs = adapter->cfgs;
3319         int it;
3320         short AdapterRed, AdapterGreen, AdapterBlue, AdapterAlpha, AdapterTotalSize;
3321         short CheckRed, CheckGreen, CheckBlue, CheckAlpha, CheckTotalSize;
3322
3323         getColorBits(adapter_format, &AdapterRed, &AdapterGreen, &AdapterBlue, &AdapterAlpha, &AdapterTotalSize);
3324         getColorBits(check_format, &CheckRed, &CheckGreen, &CheckBlue, &CheckAlpha, &CheckTotalSize);
3325
3326         /* In backbuffer mode the front and backbuffer share the same WGL pixelformat.
3327          * The format must match in RGB, alpha is allowed to be different. (Only the backbuffer can have alpha) */
3328         if(!((AdapterRed == CheckRed) && (AdapterGreen == CheckGreen) && (AdapterBlue == CheckBlue))) {
3329             TRACE_(d3d_caps)("[FAILED]\n");
3330             return FALSE;
3331         }
3332
3333         /* Check if there is a WGL pixel format matching the requirements, the format should also be window
3334          * drawable (not offscreen; e.g. Nvidia offers R5G6B5 for pbuffers even when X is running at 24bit) */
3335         for (it = 0; it < adapter->nCfgs; ++it)
3336         {
3337             if (cfgs[it].windowDrawable && IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&adapter->gl_info,
3338                     &cfgs[it], check_format))
3339             {
3340                 TRACE_(d3d_caps)("Pixel format %d is compatible with format %s.\n",
3341                         cfgs[it].iPixelFormat, debug_d3dformat(check_format->id));
3342                 return TRUE;
3343             }
3344         }
3345     }
3346     else if(wined3d_settings.offscreen_rendering_mode == ORM_FBO)
3347     {
3348         /* For now return TRUE for FBOs until we have some proper checks.
3349          * Note that this function will only be called when the format is around for texturing. */
3350         return TRUE;
3351     }
3352     return FALSE;
3353 }
3354
3355 static BOOL CheckSrgbReadCapability(struct wined3d_adapter *adapter, const struct wined3d_format *format)
3356 {
3357     return adapter->gl_info.supported[EXT_TEXTURE_SRGB] && (format->Flags & WINED3DFMT_FLAG_SRGB_READ);
3358 }
3359
3360 static BOOL CheckSrgbWriteCapability(struct wined3d_adapter *adapter, const struct wined3d_format *format)
3361 {
3362     /* Only offer SRGB writing on X8R8G8B8/A8R8G8B8 when we use ARB or GLSL shaders as we are
3363      * doing the color fixup in shaders.
3364      * Note Windows drivers (at least on the Geforce 8800) also offer this on R5G6B5. */
3365     if (format->Flags & WINED3DFMT_FLAG_SRGB_WRITE)
3366     {
3367         int vs_selected_mode;
3368         int ps_selected_mode;
3369         select_shader_mode(&adapter->gl_info, &ps_selected_mode, &vs_selected_mode);
3370
3371         if((ps_selected_mode == SHADER_ARB) || (ps_selected_mode == SHADER_GLSL)) {
3372             TRACE_(d3d_caps)("[OK]\n");
3373             return TRUE;
3374         }
3375     }
3376
3377     TRACE_(d3d_caps)("[FAILED] - sRGB writes not supported by format %s.\n", debug_d3dformat(format->id));
3378     return FALSE;
3379 }
3380
3381 /* Check if a format support blending in combination with pixel shaders */
3382 static BOOL CheckPostPixelShaderBlendingCapability(struct wined3d_adapter *adapter,
3383         const struct wined3d_format *format)
3384 {
3385     /* The flags entry of a format contains the post pixel shader blending capability */
3386     if (format->Flags & WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING) return TRUE;
3387
3388     return FALSE;
3389 }
3390
3391 static BOOL CheckWrapAndMipCapability(struct wined3d_adapter *adapter, const struct wined3d_format *format)
3392 {
3393     /* OpenGL supports mipmapping on all formats basically. Wrapping is unsupported,
3394      * but we have to report mipmapping so we cannot reject this flag. Tests show that
3395      * windows reports WRAPANDMIP on unfilterable surfaces as well, apparently to show
3396      * that wrapping is supported. The lack of filtering will sort out the mipmapping
3397      * capability anyway.
3398      *
3399      * For now lets report this on all formats, but in the future we may want to
3400      * restrict it to some should games need that
3401      */
3402     return TRUE;
3403 }
3404
3405 /* Check if a texture format is supported on the given adapter */
3406 static BOOL CheckTextureCapability(struct wined3d_adapter *adapter, const struct wined3d_format *format)
3407 {
3408     const struct wined3d_gl_info *gl_info = &adapter->gl_info;
3409
3410     switch (format->id)
3411     {
3412         /*****
3413          *  supported: RGB(A) formats
3414          */
3415         case WINED3DFMT_B8G8R8_UNORM: /* Enable for dx7, blacklisted for 8 and 9 above */
3416         case WINED3DFMT_B8G8R8A8_UNORM:
3417         case WINED3DFMT_B8G8R8X8_UNORM:
3418         case WINED3DFMT_B5G6R5_UNORM:
3419         case WINED3DFMT_B5G5R5X1_UNORM:
3420         case WINED3DFMT_B5G5R5A1_UNORM:
3421         case WINED3DFMT_B4G4R4A4_UNORM:
3422         case WINED3DFMT_A8_UNORM:
3423         case WINED3DFMT_B4G4R4X4_UNORM:
3424         case WINED3DFMT_R8G8B8A8_UNORM:
3425         case WINED3DFMT_R8G8B8X8_UNORM:
3426         case WINED3DFMT_B10G10R10A2_UNORM:
3427         case WINED3DFMT_R10G10B10A2_UNORM:
3428         case WINED3DFMT_R16G16_UNORM:
3429             TRACE_(d3d_caps)("[OK]\n");
3430             return TRUE;
3431
3432         case WINED3DFMT_B2G3R3_UNORM:
3433             TRACE_(d3d_caps)("[FAILED] - Not supported on Windows\n");
3434             return FALSE;
3435
3436         /*****
3437          *  Not supported: Palettized
3438          *  Only some Geforce/Voodoo3/G400 cards offer 8-bit textures in case of <=Direct3D7.
3439          *  Since it is not widely available, don't offer it. Further no Windows driver offers
3440          *  WINED3DFMT_P8_UINT_A8_NORM, so don't offer it either.
3441          */
3442         case WINED3DFMT_P8_UINT:
3443         case WINED3DFMT_P8_UINT_A8_UNORM:
3444             return FALSE;
3445
3446         /*****
3447          *  Supported: (Alpha)-Luminance
3448          */
3449         case WINED3DFMT_L8_UNORM:
3450         case WINED3DFMT_L8A8_UNORM:
3451         case WINED3DFMT_L16_UNORM:
3452             TRACE_(d3d_caps)("[OK]\n");
3453             return TRUE;
3454
3455         /* Not supported on Windows, thus disabled */
3456         case WINED3DFMT_L4A4_UNORM:
3457             TRACE_(d3d_caps)("[FAILED] - not supported on windows\n");
3458             return FALSE;
3459
3460         /*****
3461          *  Supported: Depth/Stencil formats
3462          */
3463         case WINED3DFMT_D16_LOCKABLE:
3464         case WINED3DFMT_D16_UNORM:
3465         case WINED3DFMT_S1_UINT_D15_UNORM:
3466         case WINED3DFMT_X8D24_UNORM:
3467         case WINED3DFMT_S4X4_UINT_D24_UNORM:
3468         case WINED3DFMT_D24_UNORM_S8_UINT:
3469         case WINED3DFMT_S8_UINT_D24_FLOAT:
3470         case WINED3DFMT_D32_UNORM:
3471         case WINED3DFMT_D32_FLOAT:
3472             return TRUE;
3473
3474         case WINED3DFMT_INTZ:
3475             if (gl_info->supported[EXT_PACKED_DEPTH_STENCIL]
3476                     || gl_info->supported[ARB_FRAMEBUFFER_OBJECT])
3477                 return TRUE;
3478             return FALSE;
3479
3480         /*****
3481          *  Not supported everywhere(depends on GL_ATI_envmap_bumpmap or
3482          *  GL_NV_texture_shader). Emulated by shaders
3483          */
3484         case WINED3DFMT_R8G8_SNORM:
3485         case WINED3DFMT_R8G8_SNORM_L8X8_UNORM:
3486         case WINED3DFMT_R5G5_SNORM_L6_UNORM:
3487         case WINED3DFMT_R8G8B8A8_SNORM:
3488         case WINED3DFMT_R16G16_SNORM:
3489             /* Ask the shader backend if it can deal with the conversion. If
3490              * we've got a GL extension giving native support this will be an
3491              * identity conversion. */
3492             if (adapter->shader_backend->shader_color_fixup_supported(format->color_fixup))
3493             {
3494                 TRACE_(d3d_caps)("[OK]\n");
3495                 return TRUE;
3496             }
3497             TRACE_(d3d_caps)("[FAILED]\n");
3498             return FALSE;
3499
3500         case WINED3DFMT_DXT1:
3501         case WINED3DFMT_DXT2:
3502         case WINED3DFMT_DXT3:
3503         case WINED3DFMT_DXT4:
3504         case WINED3DFMT_DXT5:
3505             if (gl_info->supported[EXT_TEXTURE_COMPRESSION_S3TC])
3506             {
3507                 TRACE_(d3d_caps)("[OK]\n");
3508                 return TRUE;
3509             }
3510             TRACE_(d3d_caps)("[FAILED]\n");
3511             return FALSE;
3512
3513
3514         /*****
3515          *  Odd formats - not supported
3516          */
3517         case WINED3DFMT_VERTEXDATA:
3518         case WINED3DFMT_R16_UINT:
3519         case WINED3DFMT_R32_UINT:
3520         case WINED3DFMT_R16G16B16A16_SNORM:
3521         case WINED3DFMT_R10G10B10_SNORM_A2_UNORM:
3522         case WINED3DFMT_R10G11B11_SNORM:
3523             TRACE_(d3d_caps)("[FAILED]\n"); /* Enable when implemented */
3524             return FALSE;
3525
3526         /*****
3527          *  WINED3DFMT_R8G8_SNORM_Cx: Not supported right now
3528          */
3529         case WINED3DFMT_R8G8_SNORM_Cx:
3530             TRACE_(d3d_caps)("[FAILED]\n"); /* Enable when implemented */
3531             return FALSE;
3532
3533         /* YUV formats */
3534         case WINED3DFMT_UYVY:
3535         case WINED3DFMT_YUY2:
3536             if (gl_info->supported[APPLE_YCBCR_422])
3537             {
3538                 TRACE_(d3d_caps)("[OK]\n");
3539                 return TRUE;
3540             }
3541             TRACE_(d3d_caps)("[FAILED]\n");
3542             return FALSE;
3543         case WINED3DFMT_YV12:
3544             TRACE_(d3d_caps)("[FAILED]\n");
3545             return FALSE;
3546
3547             /* Not supported */
3548         case WINED3DFMT_R16G16B16A16_UNORM:
3549         case WINED3DFMT_B2G3R3A8_UNORM:
3550             TRACE_(d3d_caps)("[FAILED]\n"); /* Enable when implemented */
3551             return FALSE;
3552
3553             /* Floating point formats */
3554         case WINED3DFMT_R16_FLOAT:
3555         case WINED3DFMT_R16G16_FLOAT:
3556         case WINED3DFMT_R16G16B16A16_FLOAT:
3557             if (gl_info->supported[ARB_TEXTURE_FLOAT] && gl_info->supported[ARB_HALF_FLOAT_PIXEL])
3558             {
3559                 TRACE_(d3d_caps)("[OK]\n");
3560                 return TRUE;
3561             }
3562             TRACE_(d3d_caps)("[FAILED]\n");
3563             return FALSE;
3564
3565         case WINED3DFMT_R32_FLOAT:
3566         case WINED3DFMT_R32G32_FLOAT:
3567         case WINED3DFMT_R32G32B32A32_FLOAT:
3568             if (gl_info->supported[ARB_TEXTURE_FLOAT])
3569             {
3570                 TRACE_(d3d_caps)("[OK]\n");
3571                 return TRUE;
3572             }
3573             TRACE_(d3d_caps)("[FAILED]\n");
3574             return FALSE;
3575
3576         /* ATI instancing hack: Although ATI cards do not support Shader Model 3.0, they support
3577          * instancing. To query if the card supports instancing CheckDeviceFormat with the special format
3578          * MAKEFOURCC('I','N','S','T') is used. Should a (broken) app check for this provide a proper return value.
3579          * We can do instancing with all shader versions, but we need vertex shaders.
3580          *
3581          * Additionally applications have to set the D3DRS_POINTSIZE render state to MAKEFOURCC('I','N','S','T') once
3582          * to enable instancing. WineD3D doesn't need that and just ignores it.
3583          *
3584          * With Shader Model 3.0 capable cards Instancing 'just works' in Windows.
3585          */
3586         case WINED3DFMT_INST:
3587             TRACE("ATI Instancing check hack\n");
3588             if (gl_info->supported[ARB_VERTEX_PROGRAM] || gl_info->supported[ARB_VERTEX_SHADER])
3589             {
3590                 TRACE_(d3d_caps)("[OK]\n");
3591                 return TRUE;
3592             }
3593             TRACE_(d3d_caps)("[FAILED]\n");
3594             return FALSE;
3595
3596         /* Some weird FOURCC formats */
3597         case WINED3DFMT_R8G8_B8G8:
3598         case WINED3DFMT_G8R8_G8B8:
3599         case WINED3DFMT_MULTI2_ARGB8:
3600             TRACE_(d3d_caps)("[FAILED]\n");
3601             return FALSE;
3602
3603         /* Vendor specific formats */
3604         case WINED3DFMT_ATI2N:
3605             if (gl_info->supported[ATI_TEXTURE_COMPRESSION_3DC]
3606                     || gl_info->supported[ARB_TEXTURE_COMPRESSION_RGTC])
3607             {
3608                 if (adapter->shader_backend->shader_color_fixup_supported(format->color_fixup)
3609                         && adapter->fragment_pipe->color_fixup_supported(format->color_fixup))
3610                 {
3611                     TRACE_(d3d_caps)("[OK]\n");
3612                     return TRUE;
3613                 }
3614
3615                 TRACE_(d3d_caps)("[OK]\n");
3616                 return TRUE;
3617             }
3618             TRACE_(d3d_caps)("[FAILED]\n");
3619             return FALSE;
3620
3621         /* Depth bound test. To query if the card supports it CheckDeviceFormat with the special
3622          * format MAKEFOURCC('N','V','D','B') is used.
3623          * It is enabled by setting D3DRS_ADAPTIVETESS_X render state to MAKEFOURCC('N','V','D','B') and
3624          * then controlled by setting D3DRS_ADAPTIVETESS_Z (zMin) and D3DRS_ADAPTIVETESS_W (zMax)
3625          * to test value.
3626          */
3627         case WINED3DFMT_NVDB:
3628             if (gl_info->supported[EXT_DEPTH_BOUNDS_TEST])
3629             {
3630                 TRACE_(d3d_caps)("[OK]\n");
3631                 return TRUE;
3632             }
3633             TRACE_(d3d_caps)("[FAILED]\n");
3634             return FALSE;
3635
3636         case WINED3DFMT_NVHU:
3637         case WINED3DFMT_NVHS:
3638             /* These formats seem to be similar to the HILO formats in GL_NV_texture_shader. NVHU
3639              * is said to be GL_UNSIGNED_HILO16, NVHS GL_SIGNED_HILO16. Rumours say that d3d computes
3640              * a 3rd channel similarly to D3DFMT_CxV8U8(So NVHS could be called D3DFMT_CxV16U16).
3641              * ATI refused to support formats which can easilly be emulated with pixel shaders, so
3642              * Applications have to deal with not having NVHS and NVHU.
3643              */
3644             TRACE_(d3d_caps)("[FAILED]\n");
3645             return FALSE;
3646
3647         case WINED3DFMT_UNKNOWN:
3648             return FALSE;
3649
3650         default:
3651             ERR("Unhandled format %s.\n", debug_d3dformat(format->id));
3652             break;
3653     }
3654     return FALSE;
3655 }
3656
3657 static BOOL CheckSurfaceCapability(struct wined3d_adapter *adapter,
3658         const struct wined3d_format *adapter_format,
3659         const struct wined3d_format *check_format,
3660         WINED3DSURFTYPE SurfaceType)
3661 {
3662     if (SurfaceType == SURFACE_GDI)
3663     {
3664         switch (check_format->id)
3665         {
3666             case WINED3DFMT_B8G8R8_UNORM:
3667             case WINED3DFMT_B8G8R8A8_UNORM:
3668             case WINED3DFMT_B8G8R8X8_UNORM:
3669             case WINED3DFMT_B5G6R5_UNORM:
3670             case WINED3DFMT_B5G5R5X1_UNORM:
3671             case WINED3DFMT_B5G5R5A1_UNORM:
3672             case WINED3DFMT_B4G4R4A4_UNORM:
3673             case WINED3DFMT_B2G3R3_UNORM:
3674             case WINED3DFMT_A8_UNORM:
3675             case WINED3DFMT_B2G3R3A8_UNORM:
3676             case WINED3DFMT_B4G4R4X4_UNORM:
3677             case WINED3DFMT_R10G10B10A2_UNORM:
3678             case WINED3DFMT_R8G8B8A8_UNORM:
3679             case WINED3DFMT_R8G8B8X8_UNORM:
3680             case WINED3DFMT_R16G16_UNORM:
3681             case WINED3DFMT_B10G10R10A2_UNORM:
3682             case WINED3DFMT_R16G16B16A16_UNORM:
3683             case WINED3DFMT_P8_UINT:
3684                 TRACE_(d3d_caps)("[OK]\n");
3685                 return TRUE;
3686             default:
3687                 TRACE_(d3d_caps)("[FAILED] - not available on GDI surfaces\n");
3688                 return FALSE;
3689         }
3690     }
3691
3692     /* All format that are supported for textures are supported for surfaces as well */
3693     if (CheckTextureCapability(adapter, check_format)) return TRUE;
3694     /* All depth stencil formats are supported on surfaces */
3695     if (CheckDepthStencilCapability(adapter, adapter_format, check_format)) return TRUE;
3696
3697     /* If opengl can't process the format natively, the blitter may be able to convert it */
3698     if (adapter->blitter->blit_supported(&adapter->gl_info, BLIT_OP_BLIT,
3699             NULL, WINED3DPOOL_DEFAULT, 0, check_format,
3700             NULL, WINED3DPOOL_DEFAULT, 0, adapter_format))
3701     {
3702         TRACE_(d3d_caps)("[OK]\n");
3703         return TRUE;
3704     }
3705
3706     /* Reject other formats */
3707     TRACE_(d3d_caps)("[FAILED]\n");
3708     return FALSE;
3709 }
3710
3711 static BOOL CheckVertexTextureCapability(struct wined3d_adapter *adapter,
3712         const struct wined3d_format *format)
3713 {
3714     return adapter->gl_info.limits.vertex_samplers && (format->Flags & WINED3DFMT_FLAG_VTF);
3715 }
3716
3717 static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
3718         enum wined3d_format_id AdapterFormat, DWORD Usage, WINED3DRESOURCETYPE RType,
3719         enum wined3d_format_id CheckFormat, WINED3DSURFTYPE SurfaceType)
3720 {
3721     IWineD3DImpl *This = (IWineD3DImpl *)iface;
3722     struct wined3d_adapter *adapter = &This->adapters[Adapter];
3723     const struct wined3d_gl_info *gl_info = &adapter->gl_info;
3724     const struct wined3d_format *format = wined3d_get_format(gl_info, CheckFormat);
3725     const struct wined3d_format *adapter_format = wined3d_get_format(gl_info, AdapterFormat);
3726     DWORD UsageCaps = 0;
3727
3728     TRACE_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, DevType:(%u,%s), AdptFmt:(%u,%s), Use:(%u,%s,%s), ResTyp:(%x,%s), CheckFmt:(%u,%s))\n",
3729           This,
3730           Adapter,
3731           DeviceType, debug_d3ddevicetype(DeviceType),
3732           AdapterFormat, debug_d3dformat(AdapterFormat),
3733           Usage, debug_d3dusage(Usage), debug_d3dusagequery(Usage),
3734           RType, debug_d3dresourcetype(RType),
3735           CheckFormat, debug_d3dformat(CheckFormat));
3736
3737     if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
3738         return WINED3DERR_INVALIDCALL;
3739     }
3740
3741     switch (RType)
3742     {
3743         case WINED3DRTYPE_CUBETEXTURE:
3744             /* Cubetexture allows:
3745              *      - WINED3DUSAGE_AUTOGENMIPMAP
3746              *      - WINED3DUSAGE_DEPTHSTENCIL
3747              *      - WINED3DUSAGE_DYNAMIC
3748              *      - WINED3DUSAGE_NONSECURE (d3d9ex)
3749              *      - WINED3DUSAGE_RENDERTARGET
3750              *      - WINED3DUSAGE_SOFTWAREPROCESSING
3751              *      - WINED3DUSAGE_QUERY_WRAPANDMIP
3752              */
3753             if (SurfaceType != SURFACE_OPENGL)
3754             {
3755                 TRACE_(d3d_caps)("[FAILED]\n");
3756                 return WINED3DERR_NOTAVAILABLE;
3757             }
3758
3759             if (!gl_info->supported[ARB_TEXTURE_CUBE_MAP])
3760             {
3761                 TRACE_(d3d_caps)("[FAILED] - No cube texture support\n");
3762                 return WINED3DERR_NOTAVAILABLE;
3763             }
3764
3765             if (!CheckTextureCapability(adapter, format))
3766             {
3767                 TRACE_(d3d_caps)("[FAILED] - Cube texture format not supported\n");
3768                 return WINED3DERR_NOTAVAILABLE;
3769             }
3770
3771             if (Usage & WINED3DUSAGE_AUTOGENMIPMAP)
3772             {
3773                 if (!gl_info->supported[SGIS_GENERATE_MIPMAP])
3774                     /* When autogenmipmap isn't around continue and return
3775                      * WINED3DOK_NOAUTOGEN instead of D3D_OK. */
3776                     TRACE_(d3d_caps)("[FAILED] - No autogenmipmap support, but continuing\n");
3777                 else
3778                     UsageCaps |= WINED3DUSAGE_AUTOGENMIPMAP;
3779             }
3780
3781             /* Always report dynamic locking. */
3782             if (Usage & WINED3DUSAGE_DYNAMIC)
3783                 UsageCaps |= WINED3DUSAGE_DYNAMIC;
3784
3785             if (Usage & WINED3DUSAGE_RENDERTARGET)
3786             {
3787                 if (!CheckRenderTargetCapability(adapter, adapter_format, format))
3788                 {
3789                     TRACE_(d3d_caps)("[FAILED] - No rendertarget support\n");
3790                     return WINED3DERR_NOTAVAILABLE;
3791                 }
3792                 UsageCaps |= WINED3DUSAGE_RENDERTARGET;
3793             }
3794
3795             /* Always report software processing. */
3796             if (Usage & WINED3DUSAGE_SOFTWAREPROCESSING)
3797                 UsageCaps |= WINED3DUSAGE_SOFTWAREPROCESSING;
3798
3799             if (Usage & WINED3DUSAGE_QUERY_FILTER)
3800             {
3801                 if (!CheckFilterCapability(adapter, format))
3802                 {
3803                     TRACE_(d3d_caps)("[FAILED] - No query filter support\n");
3804                     return WINED3DERR_NOTAVAILABLE;
3805                 }
3806                 UsageCaps |= WINED3DUSAGE_QUERY_FILTER;
3807             }
3808
3809             if (Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING)
3810             {
3811                 if (!CheckPostPixelShaderBlendingCapability(adapter, format))
3812                 {
3813                     TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
3814                     return WINED3DERR_NOTAVAILABLE;
3815                 }
3816                 UsageCaps |= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
3817             }
3818
3819             if (Usage & WINED3DUSAGE_QUERY_SRGBREAD)
3820             {
3821                 if (!CheckSrgbReadCapability(adapter, format))
3822                 {
3823                     TRACE_(d3d_caps)("[FAILED] - No query srgbread support\n");
3824                     return WINED3DERR_NOTAVAILABLE;
3825                 }
3826                 UsageCaps |= WINED3DUSAGE_QUERY_SRGBREAD;
3827             }
3828
3829             if (Usage & WINED3DUSAGE_QUERY_SRGBWRITE)
3830             {
3831                 if (!CheckSrgbWriteCapability(adapter, format))
3832                 {
3833                     TRACE_(d3d_caps)("[FAILED] - No query srgbwrite support\n");
3834                     return WINED3DERR_NOTAVAILABLE;
3835                 }
3836                 UsageCaps |= WINED3DUSAGE_QUERY_SRGBWRITE;
3837             }
3838
3839             if (Usage & WINED3DUSAGE_QUERY_VERTEXTEXTURE)
3840             {
3841                 if (!CheckVertexTextureCapability(adapter, format))
3842                 {
3843                     TRACE_(d3d_caps)("[FAILED] - No query vertextexture support\n");
3844                     return WINED3DERR_NOTAVAILABLE;
3845                 }
3846                 UsageCaps |= WINED3DUSAGE_QUERY_VERTEXTEXTURE;
3847             }
3848
3849             if (Usage & WINED3DUSAGE_QUERY_WRAPANDMIP)
3850             {
3851                 if (!CheckWrapAndMipCapability(adapter, format))
3852                 {
3853                     TRACE_(d3d_caps)("[FAILED] - No wrapping and mipmapping support\n");
3854                     return WINED3DERR_NOTAVAILABLE;
3855                 }
3856                 UsageCaps |= WINED3DUSAGE_QUERY_WRAPANDMIP;
3857             }
3858             break;
3859
3860         case WINED3DRTYPE_SURFACE:
3861             /* Surface allows:
3862              *      - WINED3DUSAGE_DEPTHSTENCIL
3863              *      - WINED3DUSAGE_NONSECURE (d3d9ex)
3864              *      - WINED3DUSAGE_RENDERTARGET
3865              */
3866             if (!CheckSurfaceCapability(adapter, adapter_format, format, SurfaceType))
3867             {
3868                 TRACE_(d3d_caps)("[FAILED] - Not supported for plain surfaces\n");
3869                 return WINED3DERR_NOTAVAILABLE;
3870             }
3871
3872             if (Usage & WINED3DUSAGE_DEPTHSTENCIL)
3873             {
3874                 if (!CheckDepthStencilCapability(adapter, adapter_format, format))
3875                 {
3876                     TRACE_(d3d_caps)("[FAILED] - No depthstencil support\n");
3877                     return WINED3DERR_NOTAVAILABLE;
3878                 }
3879                 UsageCaps |= WINED3DUSAGE_DEPTHSTENCIL;
3880             }
3881
3882             if (Usage & WINED3DUSAGE_RENDERTARGET)
3883             {
3884                 if (!CheckRenderTargetCapability(adapter, adapter_format, format))
3885                 {
3886                     TRACE_(d3d_caps)("[FAILED] - No rendertarget support\n");
3887                     return WINED3DERR_NOTAVAILABLE;
3888                 }
3889                 UsageCaps |= WINED3DUSAGE_RENDERTARGET;
3890             }
3891
3892             if (Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING)
3893             {
3894                 if (!CheckPostPixelShaderBlendingCapability(adapter, format))
3895                 {
3896                     TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
3897                     return WINED3DERR_NOTAVAILABLE;
3898                 }
3899                 UsageCaps |= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
3900             }
3901             break;
3902
3903         case WINED3DRTYPE_TEXTURE:
3904             /* Texture allows:
3905              *      - WINED3DUSAGE_AUTOGENMIPMAP
3906              *      - WINED3DUSAGE_DEPTHSTENCIL
3907              *      - WINED3DUSAGE_DMAP
3908              *      - WINED3DUSAGE_DYNAMIC
3909              *      - WINED3DUSAGE_NONSECURE (d3d9ex)
3910              *      - WINED3DUSAGE_RENDERTARGET
3911              *      - WINED3DUSAGE_SOFTWAREPROCESSING
3912              *      - WINED3DUSAGE_TEXTAPI (d3d9ex)
3913              *      - WINED3DUSAGE_QUERY_WRAPANDMIP
3914              */
3915             if (SurfaceType != SURFACE_OPENGL)
3916             {
3917                 TRACE_(d3d_caps)("[FAILED]\n");
3918                 return WINED3DERR_NOTAVAILABLE;
3919             }
3920
3921             if (!CheckTextureCapability(adapter, format))
3922             {
3923                 TRACE_(d3d_caps)("[FAILED] - Texture format not supported\n");
3924                 return WINED3DERR_NOTAVAILABLE;
3925             }
3926
3927             if (Usage & WINED3DUSAGE_AUTOGENMIPMAP)
3928             {
3929                 if (!gl_info->supported[SGIS_GENERATE_MIPMAP])
3930                     /* When autogenmipmap isn't around continue and return
3931                      * WINED3DOK_NOAUTOGEN instead of D3D_OK. */
3932                     TRACE_(d3d_caps)("[FAILED] - No autogenmipmap support, but continuing\n");
3933                 else
3934                     UsageCaps |= WINED3DUSAGE_AUTOGENMIPMAP;
3935             }
3936
3937             /* Always report dynamic locking. */
3938             if (Usage & WINED3DUSAGE_DYNAMIC)
3939                 UsageCaps |= WINED3DUSAGE_DYNAMIC;
3940
3941             if (Usage & WINED3DUSAGE_RENDERTARGET)
3942             {
3943                 if (!CheckRenderTargetCapability(adapter, adapter_format, format))
3944                 {
3945                     TRACE_(d3d_caps)("[FAILED] - No rendertarget support\n");
3946                     return WINED3DERR_NOTAVAILABLE;
3947                 }
3948                 UsageCaps |= WINED3DUSAGE_RENDERTARGET;
3949             }
3950
3951             /* Always report software processing. */
3952             if (Usage & WINED3DUSAGE_SOFTWAREPROCESSING)
3953                 UsageCaps |= WINED3DUSAGE_SOFTWAREPROCESSING;
3954
3955             if (Usage & WINED3DUSAGE_QUERY_FILTER)
3956             {
3957                 if (!CheckFilterCapability(adapter, format))
3958                 {
3959                     TRACE_(d3d_caps)("[FAILED] - No query filter support\n");
3960                     return WINED3DERR_NOTAVAILABLE;
3961                 }
3962                 UsageCaps |= WINED3DUSAGE_QUERY_FILTER;
3963             }
3964
3965             if (Usage & WINED3DUSAGE_QUERY_LEGACYBUMPMAP)
3966             {
3967                 if (!CheckBumpMapCapability(adapter, format))
3968                 {
3969                     TRACE_(d3d_caps)("[FAILED] - No legacy bumpmap support\n");
3970                     return WINED3DERR_NOTAVAILABLE;
3971                 }
3972                 UsageCaps |= WINED3DUSAGE_QUERY_LEGACYBUMPMAP;
3973             }
3974
3975             if (Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING)
3976             {
3977                 if (!CheckPostPixelShaderBlendingCapability(adapter, format))
3978                 {
3979                     TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
3980                     return WINED3DERR_NOTAVAILABLE;
3981                 }
3982                 UsageCaps |= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
3983             }
3984
3985             if (Usage & WINED3DUSAGE_QUERY_SRGBREAD)
3986             {
3987                 if (!CheckSrgbReadCapability(adapter, format))
3988                 {
3989                     TRACE_(d3d_caps)("[FAILED] - No query srgbread support\n");
3990                     return WINED3DERR_NOTAVAILABLE;
3991                 }
3992                 UsageCaps |= WINED3DUSAGE_QUERY_SRGBREAD;
3993             }
3994
3995             if (Usage & WINED3DUSAGE_QUERY_SRGBWRITE)
3996             {
3997                 if (!CheckSrgbWriteCapability(adapter, format))
3998                 {
3999                     TRACE_(d3d_caps)("[FAILED] - No query srgbwrite support\n");
4000                     return WINED3DERR_NOTAVAILABLE;
4001                 }
4002                 UsageCaps |= WINED3DUSAGE_QUERY_SRGBWRITE;
4003             }
4004
4005             if (Usage & WINED3DUSAGE_QUERY_VERTEXTEXTURE)
4006             {
4007                 if (!CheckVertexTextureCapability(adapter, format))
4008                 {
4009                     TRACE_(d3d_caps)("[FAILED] - No query vertextexture support\n");
4010                     return WINED3DERR_NOTAVAILABLE;
4011                 }
4012                 UsageCaps |= WINED3DUSAGE_QUERY_VERTEXTEXTURE;
4013             }
4014
4015             if (Usage & WINED3DUSAGE_QUERY_WRAPANDMIP)
4016             {
4017                 if (!CheckWrapAndMipCapability(adapter, format))
4018                 {
4019                     TRACE_(d3d_caps)("[FAILED] - No wrapping and mipmapping support\n");
4020                     return WINED3DERR_NOTAVAILABLE;
4021                 }
4022                 UsageCaps |= WINED3DUSAGE_QUERY_WRAPANDMIP;
4023             }
4024
4025             if (Usage & WINED3DUSAGE_DEPTHSTENCIL)
4026             {
4027                 if (!CheckDepthStencilCapability(adapter, adapter_format, format))
4028                 {
4029                     TRACE_(d3d_caps)("[FAILED] - No depth stencil support\n");
4030                     return WINED3DERR_NOTAVAILABLE;
4031                 }
4032                 if ((format->Flags & WINED3DFMT_FLAG_SHADOW) && !gl_info->supported[ARB_SHADOW])
4033                 {
4034                     TRACE_(d3d_caps)("[FAILED] - No shadow sampler support.\n");
4035                     return WINED3DERR_NOTAVAILABLE;
4036                 }
4037                 UsageCaps |= WINED3DUSAGE_DEPTHSTENCIL;
4038             }
4039             break;
4040
4041         case WINED3DRTYPE_VOLUMETEXTURE:
4042         case WINED3DRTYPE_VOLUME:
4043             /* Volume is to VolumeTexture what Surface is to Texture, but its
4044              * usage caps are not documented. Most driver seem to offer
4045              * (nearly) the same on Volume and VolumeTexture, so do that too.
4046              *
4047              * Volumetexture allows:
4048              *      - D3DUSAGE_DYNAMIC
4049              *      - D3DUSAGE_NONSECURE (d3d9ex)
4050              *      - D3DUSAGE_SOFTWAREPROCESSING
4051              *      - D3DUSAGE_QUERY_WRAPANDMIP
4052              */
4053             if (SurfaceType != SURFACE_OPENGL)
4054             {
4055                 TRACE_(d3d_caps)("[FAILED]\n");
4056                 return WINED3DERR_NOTAVAILABLE;
4057             }
4058
4059             if (!gl_info->supported[EXT_TEXTURE3D])
4060             {
4061                 TRACE_(d3d_caps)("[FAILED] - No volume texture support\n");
4062                 return WINED3DERR_NOTAVAILABLE;
4063             }
4064
4065             if (!CheckTextureCapability(adapter, format))
4066             {
4067                 TRACE_(d3d_caps)("[FAILED] - Format not supported\n");
4068                 return WINED3DERR_NOTAVAILABLE;
4069             }
4070
4071             /* Filter formats that need conversion; For one part, this
4072              * conversion is unimplemented, and volume textures are huge, so
4073              * it would be a big performance hit. Unless we hit an application
4074              * needing one of those formats, don't advertize them to avoid
4075              * leading applications into temptation. The windows drivers don't
4076              * support most of those formats on volumes anyway, except for
4077              * WINED3DFMT_R32_FLOAT. */
4078             switch (CheckFormat)
4079             {
4080                 case WINED3DFMT_P8_UINT:
4081                 case WINED3DFMT_L4A4_UNORM:
4082                 case WINED3DFMT_R32_FLOAT:
4083                 case WINED3DFMT_R16_FLOAT:
4084                 case WINED3DFMT_R8G8_SNORM_L8X8_UNORM:
4085                 case WINED3DFMT_R5G5_SNORM_L6_UNORM:
4086                 case WINED3DFMT_R16G16_UNORM:
4087                     TRACE_(d3d_caps)("[FAILED] - No converted formats on volumes\n");
4088                     return WINED3DERR_NOTAVAILABLE;
4089
4090                 case WINED3DFMT_R8G8B8A8_SNORM:
4091                 case WINED3DFMT_R16G16_SNORM:
4092                     if (!gl_info->supported[NV_TEXTURE_SHADER])
4093                     {
4094                         TRACE_(d3d_caps)("[FAILED] - No converted formats on volumes\n");
4095                         return WINED3DERR_NOTAVAILABLE;
4096                     }
4097                     break;
4098
4099                 case WINED3DFMT_R8G8_SNORM:
4100                     if (!gl_info->supported[NV_TEXTURE_SHADER])
4101                     {
4102                         TRACE_(d3d_caps)("[FAILED] - No converted formats on volumes\n");
4103                         return WINED3DERR_NOTAVAILABLE;
4104                     }
4105                     break;
4106
4107                 case WINED3DFMT_DXT1:
4108                 case WINED3DFMT_DXT2:
4109                 case WINED3DFMT_DXT3:
4110                 case WINED3DFMT_DXT4:
4111                 case WINED3DFMT_DXT5:
4112                     /* The GL_EXT_texture_compression_s3tc spec requires that
4113                      * loading an s3tc compressed texture results in an error.
4114                      * While the D3D refrast does support s3tc volumes, at
4115                      * least the nvidia windows driver does not, so we're free
4116                      * not to support this format. */
4117                     TRACE_(d3d_caps)("[FAILED] - DXTn does not support 3D textures\n");
4118                     return WINED3DERR_NOTAVAILABLE;
4119
4120                 default:
4121                     /* Do nothing, continue with checking the format below */
4122                     break;
4123             }
4124
4125             /* Always report dynamic locking. */
4126             if (Usage & WINED3DUSAGE_DYNAMIC)
4127                 UsageCaps |= WINED3DUSAGE_DYNAMIC;
4128
4129             /* Always report software processing. */
4130             if (Usage & WINED3DUSAGE_SOFTWAREPROCESSING)
4131                 UsageCaps |= WINED3DUSAGE_SOFTWAREPROCESSING;
4132
4133             if (Usage & WINED3DUSAGE_QUERY_FILTER)
4134             {
4135                 if (!CheckFilterCapability(adapter, format))
4136                 {
4137                     TRACE_(d3d_caps)("[FAILED] - No query filter support\n");
4138                     return WINED3DERR_NOTAVAILABLE;
4139                 }
4140                 UsageCaps |= WINED3DUSAGE_QUERY_FILTER;
4141             }
4142
4143             if (Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING)
4144             {
4145                 if (!CheckPostPixelShaderBlendingCapability(adapter, format))
4146                 {
4147                     TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
4148                     return WINED3DERR_NOTAVAILABLE;
4149                 }
4150                 UsageCaps |= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
4151             }
4152
4153             if (Usage & WINED3DUSAGE_QUERY_SRGBREAD)
4154             {
4155                 if (!CheckSrgbReadCapability(adapter, format))
4156                 {
4157                     TRACE_(d3d_caps)("[FAILED] - No query srgbread support\n");
4158                     return WINED3DERR_NOTAVAILABLE;
4159                 }
4160                 UsageCaps |= WINED3DUSAGE_QUERY_SRGBREAD;
4161             }
4162
4163             if (Usage & WINED3DUSAGE_QUERY_SRGBWRITE)
4164             {
4165                 if (!CheckSrgbWriteCapability(adapter, format))
4166                 {
4167                     TRACE_(d3d_caps)("[FAILED] - No query srgbwrite support\n");
4168                     return WINED3DERR_NOTAVAILABLE;
4169                 }
4170                 UsageCaps |= WINED3DUSAGE_QUERY_SRGBWRITE;
4171             }
4172
4173             if (Usage & WINED3DUSAGE_QUERY_VERTEXTEXTURE)
4174             {
4175                 if (!CheckVertexTextureCapability(adapter, format))
4176                 {
4177                     TRACE_(d3d_caps)("[FAILED] - No query vertextexture support\n");
4178                     return WINED3DERR_NOTAVAILABLE;
4179                 }
4180                 UsageCaps |= WINED3DUSAGE_QUERY_VERTEXTEXTURE;
4181             }
4182
4183             if (Usage & WINED3DUSAGE_QUERY_WRAPANDMIP)
4184             {
4185                 if (!CheckWrapAndMipCapability(adapter, format))
4186                 {
4187                     TRACE_(d3d_caps)("[FAILED] - No wrapping and mipmapping support\n");
4188                     return WINED3DERR_NOTAVAILABLE;
4189                 }
4190                 UsageCaps |= WINED3DUSAGE_QUERY_WRAPANDMIP;
4191             }
4192             break;
4193
4194         default:
4195             FIXME_(d3d_caps)("Unhandled resource type %s.\n", debug_d3dresourcetype(RType));
4196             return WINED3DERR_NOTAVAILABLE;
4197     }
4198
4199     /* When the UsageCaps exactly matches Usage return WINED3D_OK except for
4200      * the situation in which WINED3DUSAGE_AUTOGENMIPMAP isn't around, then
4201      * WINED3DOK_NOAUTOGEN is returned if all the other usage flags match. */
4202     if (UsageCaps == Usage)
4203         return WINED3D_OK;
4204     if (UsageCaps == (Usage & ~WINED3DUSAGE_AUTOGENMIPMAP))
4205         return WINED3DOK_NOAUTOGEN;
4206
4207     TRACE_(d3d_caps)("[FAILED] - Usage %#x requested for CheckFormat %s and RType %s but only %#x is available\n",
4208             Usage, debug_d3dformat(CheckFormat), debug_d3dresourcetype(RType), UsageCaps);
4209
4210     return WINED3DERR_NOTAVAILABLE;
4211 }
4212
4213 static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormatConversion(IWineD3D *iface, UINT adapter_idx,
4214         WINED3DDEVTYPE device_type, enum wined3d_format_id src_format, enum wined3d_format_id dst_format)
4215 {
4216     FIXME("iface %p, adapter_idx %u, device_type %s, src_format %s, dst_format %s stub!\n",
4217             iface, adapter_idx, debug_d3ddevicetype(device_type), debug_d3dformat(src_format),
4218             debug_d3dformat(dst_format));
4219
4220     return WINED3D_OK;
4221 }
4222
4223 static HRESULT WINAPI IWineD3DImpl_CheckDeviceType(IWineD3D *iface, UINT adapter_idx, WINED3DDEVTYPE device_type,
4224         enum wined3d_format_id display_format, enum wined3d_format_id backbuffer_format, BOOL windowed)
4225 {
4226     UINT mode_count;
4227     HRESULT hr;
4228
4229     TRACE("iface %p, adapter_idx %u, device_type %s, display_format %s, backbuffer_format %s, windowed %#x.\n",
4230             iface, adapter_idx, debug_d3ddevicetype(device_type), debug_d3dformat(display_format),
4231             debug_d3dformat(backbuffer_format), windowed);
4232
4233     if (adapter_idx >= IWineD3D_GetAdapterCount(iface))
4234     {
4235         WARN_(d3d_caps)("adapter_idx >= IWineD3D_GetAdapterCount(iface), returning WINED3DERR_INVALIDCALL\n");
4236         return WINED3DERR_INVALIDCALL;
4237     }
4238
4239     /* The task of this function is to check whether a certain display / backbuffer format
4240      * combination is available on the given adapter. In fullscreen mode microsoft specified
4241      * that the display format shouldn't provide alpha and that ignoring alpha the backbuffer
4242      * and display format should match exactly.
4243      * In windowed mode format conversion can occur and this depends on the driver. When format
4244      * conversion is done, this function should nevertheless fail and applications need to use
4245      * CheckDeviceFormatConversion.
4246      * At the moment we assume that fullscreen and windowed have the same capabilities. */
4247
4248     /* There are only 4 display formats. */
4249     if (!(display_format == WINED3DFMT_B5G6R5_UNORM
4250             || display_format == WINED3DFMT_B5G5R5X1_UNORM
4251             || display_format == WINED3DFMT_B8G8R8X8_UNORM
4252             || display_format == WINED3DFMT_B10G10R10A2_UNORM))
4253     {
4254         TRACE_(d3d_caps)("Format %s is not supported as display format.\n", debug_d3dformat(display_format));
4255         return WINED3DERR_NOTAVAILABLE;
4256     }
4257
4258     /* If the requested display format is not available, don't continue. */
4259     mode_count = IWineD3DImpl_GetAdapterModeCount(iface, adapter_idx, display_format);
4260     if (!mode_count)
4261     {
4262         TRACE_(d3d_caps)("No available modes for display format %s.\n", debug_d3dformat(display_format));
4263         return WINED3DERR_NOTAVAILABLE;
4264     }
4265
4266     /* Windowed mode allows you to specify WINED3DFMT_UNKNOWN for the backbuffer format,
4267      * it means 'reuse' the display format for the backbuffer. */
4268     if (!windowed && backbuffer_format == WINED3DFMT_UNKNOWN)
4269     {
4270         TRACE_(d3d_caps)("backbuffer_format WINED3FMT_UNKNOWN only available in windowed mode.\n");
4271         return WINED3DERR_NOTAVAILABLE;
4272     }
4273
4274     /* In FULLSCREEN mode WINED3DFMT_B5G6R5_UNORM can only be mixed with
4275      * backbuffer format WINED3DFMT_B5G6R5_UNORM. */
4276     if (display_format == WINED3DFMT_B5G6R5_UNORM && backbuffer_format != WINED3DFMT_B5G6R5_UNORM)
4277     {
4278         TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s / %s.\n",
4279                 debug_d3dformat(display_format), debug_d3dformat(backbuffer_format));
4280         return WINED3DERR_NOTAVAILABLE;
4281     }
4282
4283     /* In FULLSCREEN mode WINED3DFMT_B5G5R5X1_UNORM can only be mixed with
4284      * backbuffer formats WINED3DFMT_B5G5R5X1_UNORM and
4285      * WINED3DFMT_B5G5R5A1_UNORM. */
4286     if (display_format == WINED3DFMT_B5G5R5X1_UNORM
4287             && !(backbuffer_format == WINED3DFMT_B5G5R5X1_UNORM || backbuffer_format == WINED3DFMT_B5G5R5A1_UNORM))
4288     {
4289         TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s / %s.\n",
4290                 debug_d3dformat(display_format), debug_d3dformat(backbuffer_format));
4291         return WINED3DERR_NOTAVAILABLE;
4292     }
4293
4294     /* In FULLSCREEN mode WINED3DFMT_B8G8R8X8_UNORM can only be mixed with
4295      * backbuffer formats WINED3DFMT_B8G8R8X8_UNORM and
4296      * WINED3DFMT_B8G8R8A8_UNORM. */
4297     if (display_format == WINED3DFMT_B8G8R8X8_UNORM
4298             && !(backbuffer_format == WINED3DFMT_B8G8R8X8_UNORM || backbuffer_format == WINED3DFMT_B8G8R8A8_UNORM))
4299     {
4300         TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s / %s.\n",
4301                 debug_d3dformat(display_format), debug_d3dformat(backbuffer_format));
4302         return WINED3DERR_NOTAVAILABLE;
4303     }
4304
4305     /* WINED3DFMT_B10G10R10A2_UNORM is only allowed in fullscreen mode and it
4306      * can only be mixed with backbuffer format WINED3DFMT_B10G10R10A2_UNORM. */
4307     if (display_format == WINED3DFMT_B10G10R10A2_UNORM
4308             && (backbuffer_format != WINED3DFMT_B10G10R10A2_UNORM || windowed))
4309     {
4310         TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s / %s.\n",
4311                 debug_d3dformat(display_format), debug_d3dformat(backbuffer_format));
4312         return WINED3DERR_NOTAVAILABLE;
4313     }
4314
4315     /* Use CheckDeviceFormat to see if the backbuffer_format is usable with the given display_format */
4316     hr = IWineD3DImpl_CheckDeviceFormat(iface, adapter_idx, device_type, display_format,
4317             WINED3DUSAGE_RENDERTARGET, WINED3DRTYPE_SURFACE, backbuffer_format, SURFACE_OPENGL);
4318     if (FAILED(hr))
4319         TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s / %s.\n",
4320                 debug_d3dformat(display_format), debug_d3dformat(backbuffer_format));
4321
4322     return hr;
4323 }
4324
4325 /* Note: d3d8 passes in a pointer to a D3DCAPS8 structure, which is a true
4326       subset of a D3DCAPS9 structure. However, it has to come via a void *
4327       as the d3d8 interface cannot import the d3d9 header                  */
4328 static HRESULT WINAPI IWineD3DImpl_GetDeviceCaps(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType, WINED3DCAPS* pCaps) {
4329
4330     IWineD3DImpl    *This = (IWineD3DImpl *)iface;
4331     struct wined3d_adapter *adapter = &This->adapters[Adapter];
4332     const struct wined3d_gl_info *gl_info = &adapter->gl_info;
4333     int vs_selected_mode;
4334     int ps_selected_mode;
4335     struct shader_caps shader_caps;
4336     struct fragment_caps fragment_caps;
4337     DWORD ckey_caps, blit_caps, fx_caps, pal_caps;
4338
4339     TRACE_(d3d_caps)("(%p)->(Adptr:%d, DevType: %x, pCaps: %p)\n", This, Adapter, DeviceType, pCaps);
4340
4341     if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
4342         return WINED3DERR_INVALIDCALL;
4343     }
4344
4345     select_shader_mode(&adapter->gl_info, &ps_selected_mode, &vs_selected_mode);
4346
4347     /* ------------------------------------------------
4348        The following fields apply to both d3d8 and d3d9
4349        ------------------------------------------------ */
4350     pCaps->DeviceType              = (DeviceType == WINED3DDEVTYPE_HAL) ? WINED3DDEVTYPE_HAL : WINED3DDEVTYPE_REF;  /* Not quite true, but use h/w supported by opengl I suppose */
4351     pCaps->AdapterOrdinal          = Adapter;
4352
4353     pCaps->Caps                    = 0;
4354     pCaps->Caps2                   = WINED3DCAPS2_CANRENDERWINDOWED |
4355                                      WINED3DCAPS2_FULLSCREENGAMMA |
4356                                      WINED3DCAPS2_DYNAMICTEXTURES;
4357     if (gl_info->supported[SGIS_GENERATE_MIPMAP])
4358     {
4359         pCaps->Caps2 |= WINED3DCAPS2_CANAUTOGENMIPMAP;
4360     }
4361
4362     pCaps->Caps3                   = WINED3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD |
4363                                      WINED3DCAPS3_COPY_TO_VIDMEM                   |
4364                                      WINED3DCAPS3_COPY_TO_SYSTEMMEM;
4365
4366     pCaps->PresentationIntervals   = WINED3DPRESENT_INTERVAL_IMMEDIATE  |
4367                                      WINED3DPRESENT_INTERVAL_ONE;
4368
4369     pCaps->CursorCaps              = WINED3DCURSORCAPS_COLOR            |
4370                                      WINED3DCURSORCAPS_LOWRES;
4371
4372     pCaps->DevCaps                 = WINED3DDEVCAPS_FLOATTLVERTEX       |
4373                                      WINED3DDEVCAPS_EXECUTESYSTEMMEMORY |
4374                                      WINED3DDEVCAPS_TLVERTEXSYSTEMMEMORY|
4375                                      WINED3DDEVCAPS_TLVERTEXVIDEOMEMORY |
4376                                      WINED3DDEVCAPS_DRAWPRIMTLVERTEX    |
4377                                      WINED3DDEVCAPS_HWTRANSFORMANDLIGHT |
4378                                      WINED3DDEVCAPS_EXECUTEVIDEOMEMORY  |
4379                                      WINED3DDEVCAPS_PUREDEVICE          |
4380                                      WINED3DDEVCAPS_HWRASTERIZATION     |
4381                                      WINED3DDEVCAPS_TEXTUREVIDEOMEMORY  |
4382                                      WINED3DDEVCAPS_TEXTURESYSTEMMEMORY |
4383                                      WINED3DDEVCAPS_CANRENDERAFTERFLIP  |
4384                                      WINED3DDEVCAPS_DRAWPRIMITIVES2     |
4385                                      WINED3DDEVCAPS_DRAWPRIMITIVES2EX   |
4386                                      WINED3DDEVCAPS_RTPATCHES;
4387
4388     pCaps->PrimitiveMiscCaps       = WINED3DPMISCCAPS_CULLNONE              |
4389                                      WINED3DPMISCCAPS_CULLCCW               |
4390                                      WINED3DPMISCCAPS_CULLCW                |
4391                                      WINED3DPMISCCAPS_COLORWRITEENABLE      |
4392                                      WINED3DPMISCCAPS_CLIPTLVERTS           |
4393                                      WINED3DPMISCCAPS_CLIPPLANESCALEDPOINTS |
4394                                      WINED3DPMISCCAPS_MASKZ                 |
4395                                      WINED3DPMISCCAPS_BLENDOP               |
4396                                      WINED3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING;
4397                                     /* TODO:
4398                                         WINED3DPMISCCAPS_NULLREFERENCE
4399                                         WINED3DPMISCCAPS_FOGANDSPECULARALPHA
4400                                         WINED3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS
4401                                         WINED3DPMISCCAPS_FOGVERTEXCLAMPED */
4402
4403     if (gl_info->supported[EXT_BLEND_EQUATION_SEPARATE] && gl_info->supported[EXT_BLEND_FUNC_SEPARATE])
4404         pCaps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_SEPARATEALPHABLEND;
4405     if (gl_info->supported[EXT_DRAW_BUFFERS2])
4406         pCaps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_INDEPENDENTWRITEMASKS;
4407
4408     pCaps->RasterCaps              = WINED3DPRASTERCAPS_DITHER    |
4409                                      WINED3DPRASTERCAPS_PAT       |
4410                                      WINED3DPRASTERCAPS_WFOG      |
4411                                      WINED3DPRASTERCAPS_ZFOG      |
4412                                      WINED3DPRASTERCAPS_FOGVERTEX |
4413                                      WINED3DPRASTERCAPS_FOGTABLE  |
4414                                      WINED3DPRASTERCAPS_STIPPLE   |
4415                                      WINED3DPRASTERCAPS_SUBPIXEL  |
4416                                      WINED3DPRASTERCAPS_ZTEST     |
4417                                      WINED3DPRASTERCAPS_SCISSORTEST   |
4418                                      WINED3DPRASTERCAPS_SLOPESCALEDEPTHBIAS |
4419                                      WINED3DPRASTERCAPS_DEPTHBIAS;
4420
4421     if (gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC])
4422     {
4423         pCaps->RasterCaps |= WINED3DPRASTERCAPS_ANISOTROPY    |
4424                              WINED3DPRASTERCAPS_ZBIAS         |
4425                              WINED3DPRASTERCAPS_MIPMAPLODBIAS;
4426     }
4427     if (gl_info->supported[NV_FOG_DISTANCE])
4428     {
4429         pCaps->RasterCaps         |= WINED3DPRASTERCAPS_FOGRANGE;
4430     }
4431                         /* FIXME Add:
4432                            WINED3DPRASTERCAPS_COLORPERSPECTIVE
4433                            WINED3DPRASTERCAPS_STRETCHBLTMULTISAMPLE
4434                            WINED3DPRASTERCAPS_ANTIALIASEDGES
4435                            WINED3DPRASTERCAPS_ZBUFFERLESSHSR
4436                            WINED3DPRASTERCAPS_WBUFFER */
4437
4438     pCaps->ZCmpCaps = WINED3DPCMPCAPS_ALWAYS       |
4439                       WINED3DPCMPCAPS_EQUAL        |
4440                       WINED3DPCMPCAPS_GREATER      |
4441                       WINED3DPCMPCAPS_GREATEREQUAL |
4442                       WINED3DPCMPCAPS_LESS         |
4443                       WINED3DPCMPCAPS_LESSEQUAL    |
4444                       WINED3DPCMPCAPS_NEVER        |
4445                       WINED3DPCMPCAPS_NOTEQUAL;
4446
4447     pCaps->SrcBlendCaps  = WINED3DPBLENDCAPS_BOTHINVSRCALPHA |
4448                            WINED3DPBLENDCAPS_BOTHSRCALPHA    |
4449                            WINED3DPBLENDCAPS_DESTALPHA       |
4450                            WINED3DPBLENDCAPS_DESTCOLOR       |
4451                            WINED3DPBLENDCAPS_INVDESTALPHA    |
4452                            WINED3DPBLENDCAPS_INVDESTCOLOR    |
4453                            WINED3DPBLENDCAPS_INVSRCALPHA     |
4454                            WINED3DPBLENDCAPS_INVSRCCOLOR     |
4455                            WINED3DPBLENDCAPS_ONE             |
4456                            WINED3DPBLENDCAPS_SRCALPHA        |
4457                            WINED3DPBLENDCAPS_SRCALPHASAT     |
4458                            WINED3DPBLENDCAPS_SRCCOLOR        |
4459                            WINED3DPBLENDCAPS_ZERO;
4460
4461     pCaps->DestBlendCaps = WINED3DPBLENDCAPS_DESTALPHA       |
4462                            WINED3DPBLENDCAPS_DESTCOLOR       |
4463                            WINED3DPBLENDCAPS_INVDESTALPHA    |
4464                            WINED3DPBLENDCAPS_INVDESTCOLOR    |
4465                            WINED3DPBLENDCAPS_INVSRCALPHA     |
4466                            WINED3DPBLENDCAPS_INVSRCCOLOR     |
4467                            WINED3DPBLENDCAPS_ONE             |
4468                            WINED3DPBLENDCAPS_SRCALPHA        |
4469                            WINED3DPBLENDCAPS_SRCCOLOR        |
4470                            WINED3DPBLENDCAPS_ZERO;
4471     /* NOTE: WINED3DPBLENDCAPS_SRCALPHASAT is not supported as dest blend factor,
4472      * according to the glBlendFunc manpage
4473      *
4474      * WINED3DPBLENDCAPS_BOTHINVSRCALPHA and WINED3DPBLENDCAPS_BOTHSRCALPHA are
4475      * legacy settings for srcblend only
4476      */
4477
4478     if (gl_info->supported[EXT_BLEND_COLOR])
4479     {
4480         pCaps->SrcBlendCaps |= WINED3DPBLENDCAPS_BLENDFACTOR;
4481         pCaps->DestBlendCaps |= WINED3DPBLENDCAPS_BLENDFACTOR;
4482     }
4483
4484
4485     pCaps->AlphaCmpCaps = WINED3DPCMPCAPS_ALWAYS       |
4486                           WINED3DPCMPCAPS_EQUAL        |
4487                           WINED3DPCMPCAPS_GREATER      |
4488                           WINED3DPCMPCAPS_GREATEREQUAL |
4489                           WINED3DPCMPCAPS_LESS         |
4490                           WINED3DPCMPCAPS_LESSEQUAL    |
4491                           WINED3DPCMPCAPS_NEVER        |
4492                           WINED3DPCMPCAPS_NOTEQUAL;
4493
4494     pCaps->ShadeCaps     = WINED3DPSHADECAPS_SPECULARGOURAUDRGB |
4495                            WINED3DPSHADECAPS_COLORGOURAUDRGB    |
4496                            WINED3DPSHADECAPS_ALPHAFLATBLEND     |
4497                            WINED3DPSHADECAPS_ALPHAGOURAUDBLEND  |
4498                            WINED3DPSHADECAPS_COLORFLATRGB       |
4499                            WINED3DPSHADECAPS_FOGFLAT            |
4500                            WINED3DPSHADECAPS_FOGGOURAUD         |
4501                            WINED3DPSHADECAPS_SPECULARFLATRGB;
4502
4503     pCaps->TextureCaps =  WINED3DPTEXTURECAPS_ALPHA              |
4504                           WINED3DPTEXTURECAPS_ALPHAPALETTE       |
4505                           WINED3DPTEXTURECAPS_TRANSPARENCY       |
4506                           WINED3DPTEXTURECAPS_BORDER             |
4507                           WINED3DPTEXTURECAPS_MIPMAP             |
4508                           WINED3DPTEXTURECAPS_PROJECTED          |
4509                           WINED3DPTEXTURECAPS_PERSPECTIVE;
4510
4511     if (!gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO])
4512     {
4513         pCaps->TextureCaps |= WINED3DPTEXTURECAPS_POW2 |
4514                               WINED3DPTEXTURECAPS_NONPOW2CONDITIONAL;
4515     }
4516
4517     if (gl_info->supported[EXT_TEXTURE3D])
4518     {
4519         pCaps->TextureCaps |=  WINED3DPTEXTURECAPS_VOLUMEMAP      |
4520                                WINED3DPTEXTURECAPS_MIPVOLUMEMAP   |
4521                                WINED3DPTEXTURECAPS_VOLUMEMAP_POW2;
4522     }
4523
4524     if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
4525     {
4526         pCaps->TextureCaps |= WINED3DPTEXTURECAPS_CUBEMAP     |
4527                               WINED3DPTEXTURECAPS_MIPCUBEMAP    |
4528                               WINED3DPTEXTURECAPS_CUBEMAP_POW2;
4529
4530     }
4531
4532     pCaps->TextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR       |
4533                                WINED3DPTFILTERCAPS_MAGFPOINT        |
4534                                WINED3DPTFILTERCAPS_MINFLINEAR       |
4535                                WINED3DPTFILTERCAPS_MINFPOINT        |
4536                                WINED3DPTFILTERCAPS_MIPFLINEAR       |
4537                                WINED3DPTFILTERCAPS_MIPFPOINT        |
4538                                WINED3DPTFILTERCAPS_LINEAR           |
4539                                WINED3DPTFILTERCAPS_LINEARMIPLINEAR  |
4540                                WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
4541                                WINED3DPTFILTERCAPS_MIPLINEAR        |
4542                                WINED3DPTFILTERCAPS_MIPNEAREST       |
4543                                WINED3DPTFILTERCAPS_NEAREST;
4544
4545     if (gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC])
4546     {
4547         pCaps->TextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC |
4548                                     WINED3DPTFILTERCAPS_MINFANISOTROPIC;
4549     }
4550
4551     if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
4552     {
4553         pCaps->CubeTextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR       |
4554                                        WINED3DPTFILTERCAPS_MAGFPOINT        |
4555                                        WINED3DPTFILTERCAPS_MINFLINEAR       |
4556                                        WINED3DPTFILTERCAPS_MINFPOINT        |
4557                                        WINED3DPTFILTERCAPS_MIPFLINEAR       |
4558                                        WINED3DPTFILTERCAPS_MIPFPOINT        |
4559                                        WINED3DPTFILTERCAPS_LINEAR           |
4560                                        WINED3DPTFILTERCAPS_LINEARMIPLINEAR  |
4561                                        WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
4562                                        WINED3DPTFILTERCAPS_MIPLINEAR        |
4563                                        WINED3DPTFILTERCAPS_MIPNEAREST       |
4564                                        WINED3DPTFILTERCAPS_NEAREST;
4565
4566         if (gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC])
4567         {
4568             pCaps->CubeTextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC |
4569                                             WINED3DPTFILTERCAPS_MINFANISOTROPIC;
4570         }
4571     } else
4572         pCaps->CubeTextureFilterCaps = 0;
4573
4574     if (gl_info->supported[EXT_TEXTURE3D])
4575     {
4576         pCaps->VolumeTextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR       |
4577                                          WINED3DPTFILTERCAPS_MAGFPOINT        |
4578                                          WINED3DPTFILTERCAPS_MINFLINEAR       |
4579                                          WINED3DPTFILTERCAPS_MINFPOINT        |
4580                                          WINED3DPTFILTERCAPS_MIPFLINEAR       |
4581                                          WINED3DPTFILTERCAPS_MIPFPOINT        |
4582                                          WINED3DPTFILTERCAPS_LINEAR           |
4583                                          WINED3DPTFILTERCAPS_LINEARMIPLINEAR  |
4584                                          WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
4585                                          WINED3DPTFILTERCAPS_MIPLINEAR        |
4586                                          WINED3DPTFILTERCAPS_MIPNEAREST       |
4587                                          WINED3DPTFILTERCAPS_NEAREST;
4588     } else
4589         pCaps->VolumeTextureFilterCaps = 0;
4590
4591     pCaps->TextureAddressCaps =  WINED3DPTADDRESSCAPS_INDEPENDENTUV |
4592                                  WINED3DPTADDRESSCAPS_CLAMP  |
4593                                  WINED3DPTADDRESSCAPS_WRAP;
4594
4595     if (gl_info->supported[ARB_TEXTURE_BORDER_CLAMP])
4596     {
4597         pCaps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_BORDER;
4598     }
4599     if (gl_info->supported[ARB_TEXTURE_MIRRORED_REPEAT])
4600     {
4601         pCaps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRROR;
4602     }
4603     if (gl_info->supported[ATI_TEXTURE_MIRROR_ONCE])
4604     {
4605         pCaps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRRORONCE;
4606     }
4607
4608     if (gl_info->supported[EXT_TEXTURE3D])
4609     {
4610         pCaps->VolumeTextureAddressCaps =  WINED3DPTADDRESSCAPS_INDEPENDENTUV |
4611                                            WINED3DPTADDRESSCAPS_CLAMP  |
4612                                            WINED3DPTADDRESSCAPS_WRAP;
4613         if (gl_info->supported[ARB_TEXTURE_BORDER_CLAMP])
4614         {
4615             pCaps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_BORDER;
4616         }
4617         if (gl_info->supported[ARB_TEXTURE_MIRRORED_REPEAT])
4618         {
4619             pCaps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRROR;
4620         }
4621         if (gl_info->supported[ATI_TEXTURE_MIRROR_ONCE])
4622         {
4623             pCaps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRRORONCE;
4624         }
4625     } else
4626         pCaps->VolumeTextureAddressCaps = 0;
4627
4628     pCaps->LineCaps = WINED3DLINECAPS_TEXTURE       |
4629                       WINED3DLINECAPS_ZTEST         |
4630                       WINED3DLINECAPS_BLEND         |
4631                       WINED3DLINECAPS_ALPHACMP      |
4632                       WINED3DLINECAPS_FOG;
4633     /* WINED3DLINECAPS_ANTIALIAS is not supported on Windows, and dx and gl seem to have a different
4634      * idea how generating the smoothing alpha values works; the result is different
4635      */
4636
4637     pCaps->MaxTextureWidth = gl_info->limits.texture_size;
4638     pCaps->MaxTextureHeight = gl_info->limits.texture_size;
4639
4640     if (gl_info->supported[EXT_TEXTURE3D])
4641         pCaps->MaxVolumeExtent = gl_info->limits.texture3d_size;
4642     else
4643         pCaps->MaxVolumeExtent = 0;
4644
4645     pCaps->MaxTextureRepeat = 32768;
4646     pCaps->MaxTextureAspectRatio = gl_info->limits.texture_size;
4647     pCaps->MaxVertexW = 1.0f;
4648
4649     pCaps->GuardBandLeft = 0.0f;
4650     pCaps->GuardBandTop = 0.0f;
4651     pCaps->GuardBandRight = 0.0f;
4652     pCaps->GuardBandBottom = 0.0f;
4653
4654     pCaps->ExtentsAdjust = 0.0f;
4655
4656     pCaps->StencilCaps =  WINED3DSTENCILCAPS_DECRSAT |
4657                           WINED3DSTENCILCAPS_INCRSAT |
4658                           WINED3DSTENCILCAPS_INVERT  |
4659                           WINED3DSTENCILCAPS_KEEP    |
4660                           WINED3DSTENCILCAPS_REPLACE |
4661                           WINED3DSTENCILCAPS_ZERO;
4662     if (gl_info->supported[EXT_STENCIL_WRAP])
4663     {
4664         pCaps->StencilCaps |= WINED3DSTENCILCAPS_DECR  |
4665                               WINED3DSTENCILCAPS_INCR;
4666     }
4667     if (gl_info->supported[EXT_STENCIL_TWO_SIDE] || gl_info->supported[ATI_SEPARATE_STENCIL])
4668     {
4669         pCaps->StencilCaps |= WINED3DSTENCILCAPS_TWOSIDED;
4670     }
4671
4672     pCaps->FVFCaps = WINED3DFVFCAPS_PSIZE | 0x0008; /* 8 texture coords */
4673
4674     pCaps->MaxUserClipPlanes = gl_info->limits.clipplanes;
4675     pCaps->MaxActiveLights = gl_info->limits.lights;
4676
4677     pCaps->MaxVertexBlendMatrices = gl_info->limits.blends;
4678     pCaps->MaxVertexBlendMatrixIndex   = 0;
4679
4680     pCaps->MaxAnisotropy = gl_info->limits.anisotropy;
4681     pCaps->MaxPointSize = gl_info->limits.pointsize_max;
4682
4683
4684     /* FIXME: Add D3DVTXPCAPS_TWEENING, D3DVTXPCAPS_TEXGEN_SPHEREMAP */
4685     pCaps->VertexProcessingCaps = WINED3DVTXPCAPS_DIRECTIONALLIGHTS |
4686                                   WINED3DVTXPCAPS_MATERIALSOURCE7   |
4687                                   WINED3DVTXPCAPS_POSITIONALLIGHTS  |
4688                                   WINED3DVTXPCAPS_LOCALVIEWER       |
4689                                   WINED3DVTXPCAPS_VERTEXFOG         |
4690                                   WINED3DVTXPCAPS_TEXGEN;
4691
4692     pCaps->MaxPrimitiveCount   = 0xFFFFF; /* For now set 2^20-1 which is used by most >=Geforce3/Radeon8500 cards */
4693     pCaps->MaxVertexIndex      = 0xFFFFF;
4694     pCaps->MaxStreams          = MAX_STREAMS;
4695     pCaps->MaxStreamStride     = 1024;
4696
4697     /* d3d9.dll sets D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES here because StretchRects is implemented in d3d9 */
4698     pCaps->DevCaps2                          = WINED3DDEVCAPS2_STREAMOFFSET |
4699                                                WINED3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET;
4700     pCaps->MaxNpatchTessellationLevel        = 0;
4701     pCaps->MasterAdapterOrdinal              = 0;
4702     pCaps->AdapterOrdinalInGroup             = 0;
4703     pCaps->NumberOfAdaptersInGroup           = 1;
4704
4705     pCaps->NumSimultaneousRTs = gl_info->limits.buffers;
4706
4707     pCaps->StretchRectFilterCaps             = WINED3DPTFILTERCAPS_MINFPOINT  |
4708                                                 WINED3DPTFILTERCAPS_MAGFPOINT  |
4709                                                 WINED3DPTFILTERCAPS_MINFLINEAR |
4710                                                 WINED3DPTFILTERCAPS_MAGFLINEAR;
4711     pCaps->VertexTextureFilterCaps           = 0;
4712
4713     adapter->shader_backend->shader_get_caps(&adapter->gl_info, &shader_caps);
4714     adapter->fragment_pipe->get_caps(&adapter->gl_info, &fragment_caps);
4715
4716     /* Add shader misc caps. Only some of them belong to the shader parts of the pipeline */
4717     pCaps->PrimitiveMiscCaps |= fragment_caps.PrimitiveMiscCaps;
4718
4719     /* This takes care for disabling vertex shader or pixel shader caps while leaving the other one enabled.
4720      * Ignore shader model capabilities if disabled in config
4721      */
4722     if(vs_selected_mode == SHADER_NONE) {
4723         TRACE_(d3d_caps)("Vertex shader disabled in config, reporting version 0.0\n");
4724         pCaps->VertexShaderVersion          = WINED3DVS_VERSION(0,0);
4725         pCaps->MaxVertexShaderConst         = 0;
4726     } else {
4727         pCaps->VertexShaderVersion          = shader_caps.VertexShaderVersion;
4728         pCaps->MaxVertexShaderConst         = shader_caps.MaxVertexShaderConst;
4729     }
4730
4731     if(ps_selected_mode == SHADER_NONE) {
4732         TRACE_(d3d_caps)("Pixel shader disabled in config, reporting version 0.0\n");
4733         pCaps->PixelShaderVersion           = WINED3DPS_VERSION(0,0);
4734         pCaps->PixelShader1xMaxValue        = 0.0f;
4735     } else {
4736         pCaps->PixelShaderVersion           = shader_caps.PixelShaderVersion;
4737         pCaps->PixelShader1xMaxValue        = shader_caps.PixelShader1xMaxValue;
4738     }
4739
4740     pCaps->TextureOpCaps                    = fragment_caps.TextureOpCaps;
4741     pCaps->MaxTextureBlendStages            = fragment_caps.MaxTextureBlendStages;
4742     pCaps->MaxSimultaneousTextures          = fragment_caps.MaxSimultaneousTextures;
4743
4744     /* The following caps are shader specific, but they are things we cannot detect, or which
4745      * are the same among all shader models. So to avoid code duplication set the shader version
4746      * specific, but otherwise constant caps here
4747      */
4748     if(pCaps->VertexShaderVersion == WINED3DVS_VERSION(3,0)) {
4749         /* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering)
4750         use the VS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum VS3.0 value. */
4751         pCaps->VS20Caps.Caps                     = WINED3DVS20CAPS_PREDICATION;
4752         pCaps->VS20Caps.DynamicFlowControlDepth  = WINED3DVS20_MAX_DYNAMICFLOWCONTROLDEPTH; /* VS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
4753         pCaps->VS20Caps.NumTemps = max(32, adapter->gl_info.limits.arb_vs_temps);
4754         pCaps->VS20Caps.StaticFlowControlDepth   = WINED3DVS20_MAX_STATICFLOWCONTROLDEPTH ; /* level of nesting in loops / if-statements; VS 3.0 requires MAX (4) */
4755
4756         pCaps->MaxVShaderInstructionsExecuted    = 65535; /* VS 3.0 needs at least 65535, some cards even use 2^32-1 */
4757         pCaps->MaxVertexShader30InstructionSlots = max(512, adapter->gl_info.limits.arb_vs_instructions);
4758     }
4759     else if (pCaps->VertexShaderVersion == WINED3DVS_VERSION(2,0))
4760     {
4761         pCaps->VS20Caps.Caps                     = 0;
4762         pCaps->VS20Caps.DynamicFlowControlDepth  = WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH;
4763         pCaps->VS20Caps.NumTemps = max(12, adapter->gl_info.limits.arb_vs_temps);
4764         pCaps->VS20Caps.StaticFlowControlDepth   = 1;
4765
4766         pCaps->MaxVShaderInstructionsExecuted    = 65535;
4767         pCaps->MaxVertexShader30InstructionSlots = 0;
4768     } else { /* VS 1.x */
4769         pCaps->VS20Caps.Caps                     = 0;
4770         pCaps->VS20Caps.DynamicFlowControlDepth  = 0;
4771         pCaps->VS20Caps.NumTemps                 = 0;
4772         pCaps->VS20Caps.StaticFlowControlDepth   = 0;
4773
4774         pCaps->MaxVShaderInstructionsExecuted    = 0;
4775         pCaps->MaxVertexShader30InstructionSlots = 0;
4776     }
4777
4778     if(pCaps->PixelShaderVersion == WINED3DPS_VERSION(3,0)) {
4779         /* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering)
4780         use the PS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum PS 3.0 value. */
4781
4782         /* 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 */
4783         pCaps->PS20Caps.Caps                     = WINED3DPS20CAPS_ARBITRARYSWIZZLE     |
4784                 WINED3DPS20CAPS_GRADIENTINSTRUCTIONS |
4785                 WINED3DPS20CAPS_PREDICATION          |
4786                 WINED3DPS20CAPS_NODEPENDENTREADLIMIT |
4787                 WINED3DPS20CAPS_NOTEXINSTRUCTIONLIMIT;
4788         pCaps->PS20Caps.DynamicFlowControlDepth  = WINED3DPS20_MAX_DYNAMICFLOWCONTROLDEPTH; /* PS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
4789         pCaps->PS20Caps.NumTemps = max(32, adapter->gl_info.limits.arb_ps_temps);
4790         pCaps->PS20Caps.StaticFlowControlDepth   = WINED3DPS20_MAX_STATICFLOWCONTROLDEPTH; /* PS 3.0 requires MAX_STATICFLOWCONTROLDEPTH (4) */
4791         pCaps->PS20Caps.NumInstructionSlots      = WINED3DPS20_MAX_NUMINSTRUCTIONSLOTS; /* PS 3.0 requires MAX_NUMINSTRUCTIONSLOTS (512) */
4792
4793         pCaps->MaxPShaderInstructionsExecuted    = 65535;
4794         pCaps->MaxPixelShader30InstructionSlots = max(WINED3DMIN30SHADERINSTRUCTIONS,
4795                 adapter->gl_info.limits.arb_ps_instructions);
4796     }
4797     else if(pCaps->PixelShaderVersion == WINED3DPS_VERSION(2,0))
4798     {
4799         /* Below we assume PS2.0 specs, not extended 2.0a(GeforceFX)/2.0b(Radeon R3xx) ones */
4800         pCaps->PS20Caps.Caps                     = 0;
4801         pCaps->PS20Caps.DynamicFlowControlDepth  = 0; /* WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH = 0 */
4802         pCaps->PS20Caps.NumTemps = max(12, adapter->gl_info.limits.arb_ps_temps);
4803         pCaps->PS20Caps.StaticFlowControlDepth   = WINED3DPS20_MIN_STATICFLOWCONTROLDEPTH; /* Minimum: 1 */
4804         pCaps->PS20Caps.NumInstructionSlots      = WINED3DPS20_MIN_NUMINSTRUCTIONSLOTS; /* Minimum number (64 ALU + 32 Texture), a GeforceFX uses 512 */
4805
4806         pCaps->MaxPShaderInstructionsExecuted    = 512; /* Minimum value, a GeforceFX uses 1024 */
4807         pCaps->MaxPixelShader30InstructionSlots  = 0;
4808     } else { /* PS 1.x */
4809         pCaps->PS20Caps.Caps                     = 0;
4810         pCaps->PS20Caps.DynamicFlowControlDepth  = 0;
4811         pCaps->PS20Caps.NumTemps                 = 0;
4812         pCaps->PS20Caps.StaticFlowControlDepth   = 0;
4813         pCaps->PS20Caps.NumInstructionSlots      = 0;
4814
4815         pCaps->MaxPShaderInstructionsExecuted    = 0;
4816         pCaps->MaxPixelShader30InstructionSlots  = 0;
4817     }
4818
4819     if(pCaps->VertexShaderVersion >= WINED3DVS_VERSION(2,0)) {
4820         /* OpenGL supports all the formats below, perhaps not always
4821          * without conversion, but it supports them.
4822          * Further GLSL doesn't seem to have an official unsigned type so
4823          * don't advertise it yet as I'm not sure how we handle it.
4824          * We might need to add some clamping in the shader engine to
4825          * support it.
4826          * TODO: WINED3DDTCAPS_USHORT2N, WINED3DDTCAPS_USHORT4N, WINED3DDTCAPS_UDEC3, WINED3DDTCAPS_DEC3N */
4827         pCaps->DeclTypes = WINED3DDTCAPS_UBYTE4    |
4828                            WINED3DDTCAPS_UBYTE4N   |
4829                            WINED3DDTCAPS_SHORT2N   |
4830                            WINED3DDTCAPS_SHORT4N;
4831         if (gl_info->supported[ARB_HALF_FLOAT_VERTEX])
4832         {
4833             pCaps->DeclTypes |= WINED3DDTCAPS_FLOAT16_2 |
4834                                 WINED3DDTCAPS_FLOAT16_4;
4835         }
4836     } else
4837         pCaps->DeclTypes                         = 0;
4838
4839     /* Set DirectDraw helper Caps */
4840     ckey_caps =                         WINEDDCKEYCAPS_DESTBLT              |
4841                                         WINEDDCKEYCAPS_SRCBLT;
4842     fx_caps =                           WINEDDFXCAPS_BLTALPHA               |
4843                                         WINEDDFXCAPS_BLTMIRRORLEFTRIGHT     |
4844                                         WINEDDFXCAPS_BLTMIRRORUPDOWN        |
4845                                         WINEDDFXCAPS_BLTROTATION90          |
4846                                         WINEDDFXCAPS_BLTSHRINKX             |
4847                                         WINEDDFXCAPS_BLTSHRINKXN            |
4848                                         WINEDDFXCAPS_BLTSHRINKY             |
4849                                         WINEDDFXCAPS_BLTSHRINKXN            |
4850                                         WINEDDFXCAPS_BLTSTRETCHX            |
4851                                         WINEDDFXCAPS_BLTSTRETCHXN           |
4852                                         WINEDDFXCAPS_BLTSTRETCHY            |
4853                                         WINEDDFXCAPS_BLTSTRETCHYN;
4854     blit_caps =                         WINEDDCAPS_BLT                      |
4855                                         WINEDDCAPS_BLTCOLORFILL             |
4856                                         WINEDDCAPS_BLTDEPTHFILL             |
4857                                         WINEDDCAPS_BLTSTRETCH               |
4858                                         WINEDDCAPS_CANBLTSYSMEM             |
4859                                         WINEDDCAPS_CANCLIP                  |
4860                                         WINEDDCAPS_CANCLIPSTRETCHED         |
4861                                         WINEDDCAPS_COLORKEY                 |
4862                                         WINEDDCAPS_COLORKEYHWASSIST         |
4863                                         WINEDDCAPS_ALIGNBOUNDARYSRC;
4864     pal_caps =                          WINEDDPCAPS_8BIT                    |
4865                                         WINEDDPCAPS_PRIMARYSURFACE;
4866
4867     /* Fill the ddraw caps structure */
4868     pCaps->DirectDrawCaps.Caps =        WINEDDCAPS_GDI                      |
4869                                         WINEDDCAPS_PALETTE                  |
4870                                         blit_caps;
4871     pCaps->DirectDrawCaps.Caps2 =       WINEDDCAPS2_CERTIFIED                |
4872                                         WINEDDCAPS2_NOPAGELOCKREQUIRED       |
4873                                         WINEDDCAPS2_PRIMARYGAMMA             |
4874                                         WINEDDCAPS2_WIDESURFACES             |
4875                                         WINEDDCAPS2_CANRENDERWINDOWED;
4876     pCaps->DirectDrawCaps.CKeyCaps =    ckey_caps;
4877     pCaps->DirectDrawCaps.FXCaps =      fx_caps;
4878     pCaps->DirectDrawCaps.PalCaps =     pal_caps;
4879     pCaps->DirectDrawCaps.SVBCaps =     blit_caps;
4880     pCaps->DirectDrawCaps.SVBCKeyCaps = ckey_caps;
4881     pCaps->DirectDrawCaps.SVBFXCaps =   fx_caps;
4882     pCaps->DirectDrawCaps.VSBCaps =     blit_caps;
4883     pCaps->DirectDrawCaps.VSBCKeyCaps = ckey_caps;
4884     pCaps->DirectDrawCaps.VSBFXCaps =   fx_caps;
4885     pCaps->DirectDrawCaps.SSBCaps =     blit_caps;
4886     pCaps->DirectDrawCaps.SSBCKeyCaps = ckey_caps;
4887     pCaps->DirectDrawCaps.SSBFXCaps =   fx_caps;
4888
4889     pCaps->DirectDrawCaps.ddsCaps =     WINEDDSCAPS_ALPHA                   |
4890                                         WINEDDSCAPS_BACKBUFFER              |
4891                                         WINEDDSCAPS_FLIP                    |
4892                                         WINEDDSCAPS_FRONTBUFFER             |
4893                                         WINEDDSCAPS_OFFSCREENPLAIN          |
4894                                         WINEDDSCAPS_PALETTE                 |
4895                                         WINEDDSCAPS_PRIMARYSURFACE          |
4896                                         WINEDDSCAPS_SYSTEMMEMORY            |
4897                                         WINEDDSCAPS_VIDEOMEMORY             |
4898                                         WINEDDSCAPS_VISIBLE;
4899     pCaps->DirectDrawCaps.StrideAlign = DDRAW_PITCH_ALIGNMENT;
4900
4901     /* Set D3D caps if OpenGL is available. */
4902     if (adapter->opengl)
4903     {
4904         pCaps->DirectDrawCaps.ddsCaps |=WINEDDSCAPS_3DDEVICE                |
4905                                         WINEDDSCAPS_MIPMAP                  |
4906                                         WINEDDSCAPS_TEXTURE                 |
4907                                         WINEDDSCAPS_ZBUFFER;
4908         pCaps->DirectDrawCaps.Caps |=   WINEDDCAPS_3D;
4909     }
4910
4911     return WINED3D_OK;
4912 }
4913
4914 static HRESULT WINAPI IWineD3DImpl_CreateDevice(IWineD3D *iface, UINT adapter_idx, WINED3DDEVTYPE device_type,
4915         HWND focus_window, DWORD flags, IWineD3DDeviceParent *device_parent, IWineD3DDevice **device)
4916 {
4917     IWineD3DImpl *This = (IWineD3DImpl *)iface;
4918     IWineD3DDeviceImpl *object;
4919     HRESULT hr;
4920
4921     TRACE("iface %p, adapter_idx %u, device_type %#x, focus_window %p, flags %#x, device_parent %p, device %p.\n",
4922             iface, adapter_idx, device_type, focus_window, flags, device_parent, device);
4923
4924     /* Validate the adapter number. If no adapters are available(no GL), ignore the adapter
4925      * number and create a device without a 3D adapter for 2D only operation. */
4926     if (IWineD3D_GetAdapterCount(iface) && adapter_idx >= IWineD3D_GetAdapterCount(iface))
4927     {
4928         return WINED3DERR_INVALIDCALL;
4929     }
4930
4931     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
4932     if (!object)
4933     {
4934         ERR("Failed to allocate device memory.\n");
4935         return E_OUTOFMEMORY;
4936     }
4937
4938     hr = device_init(object, This, adapter_idx, device_type, focus_window, flags, device_parent);
4939     if (FAILED(hr))
4940     {
4941         WARN("Failed to initialize device, hr %#x.\n", hr);
4942         HeapFree(GetProcessHeap(), 0, object);
4943         return hr;
4944     }
4945
4946     TRACE("Created device %p.\n", object);
4947     *device = (IWineD3DDevice *)object;
4948
4949     IWineD3DDeviceParent_WineD3DDeviceCreated(device_parent, *device);
4950
4951     return WINED3D_OK;
4952 }
4953
4954 static void * WINAPI IWineD3DImpl_GetParent(IWineD3D *iface)
4955 {
4956     TRACE("iface %p.\n", iface);
4957
4958     return ((IWineD3DImpl *)iface)->parent;
4959 }
4960
4961 static void WINE_GLAPI invalid_func(const void *data)
4962 {
4963     ERR("Invalid vertex attribute function called\n");
4964     DebugBreak();
4965 }
4966
4967 static void WINE_GLAPI invalid_texcoord_func(GLenum unit, const void *data)
4968 {
4969     ERR("Invalid texcoord function called\n");
4970     DebugBreak();
4971 }
4972
4973 /* Helper functions for providing vertex data to opengl. The arrays are initialized based on
4974  * the extension detection and are used in drawStridedSlow
4975  */
4976 static void WINE_GLAPI position_d3dcolor(const void *data)
4977 {
4978     DWORD pos = *((const DWORD *)data);
4979
4980     FIXME("Add a test for fixed function position from d3dcolor type\n");
4981     glVertex4s(D3DCOLOR_B_R(pos),
4982                D3DCOLOR_B_G(pos),
4983                D3DCOLOR_B_B(pos),
4984                D3DCOLOR_B_A(pos));
4985 }
4986
4987 static void WINE_GLAPI position_float4(const void *data)
4988 {
4989     const GLfloat *pos = data;
4990
4991     if (pos[3] != 0.0f && pos[3] != 1.0f)
4992     {
4993         float w = 1.0f / pos[3];
4994
4995         glVertex4f(pos[0] * w, pos[1] * w, pos[2] * w, w);
4996     }
4997     else
4998     {
4999         glVertex3fv(pos);
5000     }
5001 }
5002
5003 static void WINE_GLAPI diffuse_d3dcolor(const void *data)
5004 {
5005     DWORD diffuseColor = *((const DWORD *)data);
5006
5007     glColor4ub(D3DCOLOR_B_R(diffuseColor),
5008                D3DCOLOR_B_G(diffuseColor),
5009                D3DCOLOR_B_B(diffuseColor),
5010                D3DCOLOR_B_A(diffuseColor));
5011 }
5012
5013 static void WINE_GLAPI specular_d3dcolor(const void *data)
5014 {
5015     DWORD specularColor = *((const DWORD *)data);
5016     GLbyte d[] = {D3DCOLOR_B_R(specularColor),
5017             D3DCOLOR_B_G(specularColor),
5018             D3DCOLOR_B_B(specularColor)};
5019
5020     specular_func_3ubv(d);
5021 }
5022
5023 static void WINE_GLAPI warn_no_specular_func(const void *data)
5024 {
5025     WARN("GL_EXT_secondary_color not supported\n");
5026 }
5027
5028 static void fillGLAttribFuncs(const struct wined3d_gl_info *gl_info)
5029 {
5030     position_funcs[WINED3D_FFP_EMIT_FLOAT1]      = invalid_func;
5031     position_funcs[WINED3D_FFP_EMIT_FLOAT2]      = invalid_func;
5032     position_funcs[WINED3D_FFP_EMIT_FLOAT3]      = (glAttribFunc)glVertex3fv;
5033     position_funcs[WINED3D_FFP_EMIT_FLOAT4]      = position_float4;
5034     position_funcs[WINED3D_FFP_EMIT_D3DCOLOR]    = position_d3dcolor;
5035     position_funcs[WINED3D_FFP_EMIT_UBYTE4]      = invalid_func;
5036     position_funcs[WINED3D_FFP_EMIT_SHORT2]      = invalid_func;
5037     position_funcs[WINED3D_FFP_EMIT_SHORT4]      = (glAttribFunc)glVertex2sv;
5038     position_funcs[WINED3D_FFP_EMIT_UBYTE4N]     = invalid_func;
5039     position_funcs[WINED3D_FFP_EMIT_SHORT2N]     = invalid_func;
5040     position_funcs[WINED3D_FFP_EMIT_SHORT4N]     = invalid_func;
5041     position_funcs[WINED3D_FFP_EMIT_USHORT2N]    = invalid_func;
5042     position_funcs[WINED3D_FFP_EMIT_USHORT4N]    = invalid_func;
5043     position_funcs[WINED3D_FFP_EMIT_UDEC3]       = invalid_func;
5044     position_funcs[WINED3D_FFP_EMIT_DEC3N]       = invalid_func;
5045     position_funcs[WINED3D_FFP_EMIT_FLOAT16_2]   = invalid_func;
5046     position_funcs[WINED3D_FFP_EMIT_FLOAT16_4]   = invalid_func;
5047
5048     diffuse_funcs[WINED3D_FFP_EMIT_FLOAT1]       = invalid_func;
5049     diffuse_funcs[WINED3D_FFP_EMIT_FLOAT2]       = invalid_func;
5050     diffuse_funcs[WINED3D_FFP_EMIT_FLOAT3]       = (glAttribFunc)glColor3fv;
5051     diffuse_funcs[WINED3D_FFP_EMIT_FLOAT4]       = (glAttribFunc)glColor4fv;
5052     diffuse_funcs[WINED3D_FFP_EMIT_D3DCOLOR]     = diffuse_d3dcolor;
5053     diffuse_funcs[WINED3D_FFP_EMIT_UBYTE4]       = invalid_func;
5054     diffuse_funcs[WINED3D_FFP_EMIT_SHORT2]       = invalid_func;
5055     diffuse_funcs[WINED3D_FFP_EMIT_SHORT4]       = invalid_func;
5056     diffuse_funcs[WINED3D_FFP_EMIT_UBYTE4N]      = (glAttribFunc)glColor4ubv;
5057     diffuse_funcs[WINED3D_FFP_EMIT_SHORT2N]      = invalid_func;
5058     diffuse_funcs[WINED3D_FFP_EMIT_SHORT4N]      = (glAttribFunc)glColor4sv;
5059     diffuse_funcs[WINED3D_FFP_EMIT_USHORT2N]     = invalid_func;
5060     diffuse_funcs[WINED3D_FFP_EMIT_USHORT4N]     = (glAttribFunc)glColor4usv;
5061     diffuse_funcs[WINED3D_FFP_EMIT_UDEC3]        = invalid_func;
5062     diffuse_funcs[WINED3D_FFP_EMIT_DEC3N]        = invalid_func;
5063     diffuse_funcs[WINED3D_FFP_EMIT_FLOAT16_2]    = invalid_func;
5064     diffuse_funcs[WINED3D_FFP_EMIT_FLOAT16_4]    = invalid_func;
5065
5066     /* No 4 component entry points here */
5067     specular_funcs[WINED3D_FFP_EMIT_FLOAT1]      = invalid_func;
5068     specular_funcs[WINED3D_FFP_EMIT_FLOAT2]      = invalid_func;
5069     if (gl_info->supported[EXT_SECONDARY_COLOR])
5070     {
5071         specular_funcs[WINED3D_FFP_EMIT_FLOAT3]  = (glAttribFunc)GL_EXTCALL(glSecondaryColor3fvEXT);
5072     }
5073     else
5074     {
5075         specular_funcs[WINED3D_FFP_EMIT_FLOAT3]  = warn_no_specular_func;
5076     }
5077     specular_funcs[WINED3D_FFP_EMIT_FLOAT4]      = invalid_func;
5078     if (gl_info->supported[EXT_SECONDARY_COLOR])
5079     {
5080         specular_func_3ubv = (glAttribFunc)GL_EXTCALL(glSecondaryColor3ubvEXT);
5081         specular_funcs[WINED3D_FFP_EMIT_D3DCOLOR] = specular_d3dcolor;
5082     }
5083     else
5084     {
5085         specular_funcs[WINED3D_FFP_EMIT_D3DCOLOR] = warn_no_specular_func;
5086     }
5087     specular_funcs[WINED3D_FFP_EMIT_UBYTE4]      = invalid_func;
5088     specular_funcs[WINED3D_FFP_EMIT_SHORT2]      = invalid_func;
5089     specular_funcs[WINED3D_FFP_EMIT_SHORT4]      = invalid_func;
5090     specular_funcs[WINED3D_FFP_EMIT_UBYTE4N]     = invalid_func;
5091     specular_funcs[WINED3D_FFP_EMIT_SHORT2N]     = invalid_func;
5092     specular_funcs[WINED3D_FFP_EMIT_SHORT4N]     = invalid_func;
5093     specular_funcs[WINED3D_FFP_EMIT_USHORT2N]    = invalid_func;
5094     specular_funcs[WINED3D_FFP_EMIT_USHORT4N]    = invalid_func;
5095     specular_funcs[WINED3D_FFP_EMIT_UDEC3]       = invalid_func;
5096     specular_funcs[WINED3D_FFP_EMIT_DEC3N]       = invalid_func;
5097     specular_funcs[WINED3D_FFP_EMIT_FLOAT16_2]   = invalid_func;
5098     specular_funcs[WINED3D_FFP_EMIT_FLOAT16_4]   = invalid_func;
5099
5100     /* Only 3 component entry points here. Test how others behave. Float4 normals are used
5101      * by one of our tests, trying to pass it to the pixel shader, which fails on Windows.
5102      */
5103     normal_funcs[WINED3D_FFP_EMIT_FLOAT1]         = invalid_func;
5104     normal_funcs[WINED3D_FFP_EMIT_FLOAT2]         = invalid_func;
5105     normal_funcs[WINED3D_FFP_EMIT_FLOAT3]         = (glAttribFunc)glNormal3fv;
5106     normal_funcs[WINED3D_FFP_EMIT_FLOAT4]         = (glAttribFunc)glNormal3fv; /* Just ignore the 4th value */
5107     normal_funcs[WINED3D_FFP_EMIT_D3DCOLOR]       = invalid_func;
5108     normal_funcs[WINED3D_FFP_EMIT_UBYTE4]         = invalid_func;
5109     normal_funcs[WINED3D_FFP_EMIT_SHORT2]         = invalid_func;
5110     normal_funcs[WINED3D_FFP_EMIT_SHORT4]         = invalid_func;
5111     normal_funcs[WINED3D_FFP_EMIT_UBYTE4N]        = invalid_func;
5112     normal_funcs[WINED3D_FFP_EMIT_SHORT2N]        = invalid_func;
5113     normal_funcs[WINED3D_FFP_EMIT_SHORT4N]        = invalid_func;
5114     normal_funcs[WINED3D_FFP_EMIT_USHORT2N]       = invalid_func;
5115     normal_funcs[WINED3D_FFP_EMIT_USHORT4N]       = invalid_func;
5116     normal_funcs[WINED3D_FFP_EMIT_UDEC3]          = invalid_func;
5117     normal_funcs[WINED3D_FFP_EMIT_DEC3N]          = invalid_func;
5118     normal_funcs[WINED3D_FFP_EMIT_FLOAT16_2]      = invalid_func;
5119     normal_funcs[WINED3D_FFP_EMIT_FLOAT16_4]      = invalid_func;
5120
5121     multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT1]    = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord1fvARB);
5122     multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT2]    = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord2fvARB);
5123     multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT3]    = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord3fvARB);
5124     multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT4]    = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord4fvARB);
5125     multi_texcoord_funcs[WINED3D_FFP_EMIT_D3DCOLOR]  = invalid_texcoord_func;
5126     multi_texcoord_funcs[WINED3D_FFP_EMIT_UBYTE4]    = invalid_texcoord_func;
5127     multi_texcoord_funcs[WINED3D_FFP_EMIT_SHORT2]    = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord2svARB);
5128     multi_texcoord_funcs[WINED3D_FFP_EMIT_SHORT4]    = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord4svARB);
5129     multi_texcoord_funcs[WINED3D_FFP_EMIT_UBYTE4N]   = invalid_texcoord_func;
5130     multi_texcoord_funcs[WINED3D_FFP_EMIT_SHORT2N]   = invalid_texcoord_func;
5131     multi_texcoord_funcs[WINED3D_FFP_EMIT_SHORT4N]   = invalid_texcoord_func;
5132     multi_texcoord_funcs[WINED3D_FFP_EMIT_USHORT2N]  = invalid_texcoord_func;
5133     multi_texcoord_funcs[WINED3D_FFP_EMIT_USHORT4N]  = invalid_texcoord_func;
5134     multi_texcoord_funcs[WINED3D_FFP_EMIT_UDEC3]     = invalid_texcoord_func;
5135     multi_texcoord_funcs[WINED3D_FFP_EMIT_DEC3N]     = invalid_texcoord_func;
5136     if (gl_info->supported[NV_HALF_FLOAT])
5137     {
5138         /* Not supported by ARB_HALF_FLOAT_VERTEX, so check for NV_HALF_FLOAT */
5139         multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT16_2] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord2hvNV);
5140         multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT16_4] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord4hvNV);
5141     } else {
5142         multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT16_2] = invalid_texcoord_func;
5143         multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT16_4] = invalid_texcoord_func;
5144     }
5145 }
5146
5147 /* Do not call while under the GL lock. */
5148 static BOOL InitAdapters(IWineD3DImpl *This)
5149 {
5150     static HMODULE mod_gl;
5151     BOOL ret;
5152     int ps_selected_mode, vs_selected_mode;
5153
5154     /* No need to hold any lock. The calling library makes sure only one thread calls
5155      * wined3d simultaneously
5156      */
5157
5158     TRACE("Initializing adapters\n");
5159
5160     if(!mod_gl) {
5161 #ifdef USE_WIN32_OPENGL
5162 #define USE_GL_FUNC(pfn) pfn = (void*)GetProcAddress(mod_gl, #pfn);
5163         mod_gl = LoadLibraryA("opengl32.dll");
5164         if(!mod_gl) {
5165             ERR("Can't load opengl32.dll!\n");
5166             goto nogl_adapter;
5167         }
5168 #else
5169 #define USE_GL_FUNC(pfn) pfn = (void*)pwglGetProcAddress(#pfn);
5170         /* To bypass the opengl32 thunks load wglGetProcAddress from gdi32 (glXGetProcAddress wrapper) instead of opengl32's */
5171         mod_gl = GetModuleHandleA("gdi32.dll");
5172 #endif
5173     }
5174
5175 /* Load WGL core functions from opengl32.dll */
5176 #define USE_WGL_FUNC(pfn) p##pfn = (void*)GetProcAddress(mod_gl, #pfn);
5177     WGL_FUNCS_GEN;
5178 #undef USE_WGL_FUNC
5179
5180     if(!pwglGetProcAddress) {
5181         ERR("Unable to load wglGetProcAddress!\n");
5182         goto nogl_adapter;
5183     }
5184
5185 /* Dynamically load all GL core functions */
5186     GL_FUNCS_GEN;
5187 #undef USE_GL_FUNC
5188
5189     /* Load glFinish and glFlush from opengl32.dll even if we're not using WIN32 opengl
5190      * otherwise because we have to use winex11.drv's override
5191      */
5192 #ifdef USE_WIN32_OPENGL
5193     wglFinish = (void*)GetProcAddress(mod_gl, "glFinish");
5194     wglFlush = (void*)GetProcAddress(mod_gl, "glFlush");
5195 #else
5196     wglFinish = (void*)pwglGetProcAddress("wglFinish");
5197     wglFlush = (void*)pwglGetProcAddress("wglFlush");
5198 #endif
5199
5200     glEnableWINE = glEnable;
5201     glDisableWINE = glDisable;
5202
5203     /* For now only one default adapter */
5204     {
5205         struct wined3d_adapter *adapter = &This->adapters[0];
5206         const struct wined3d_gl_info *gl_info = &adapter->gl_info;
5207         struct wined3d_fake_gl_ctx fake_gl_ctx = {0};
5208         int iPixelFormat;
5209         int res;
5210         int i;
5211         WineD3D_PixelFormat *cfgs;
5212         DISPLAY_DEVICEW DisplayDevice;
5213         HDC hdc;
5214
5215         TRACE("Initializing default adapter\n");
5216         adapter->ordinal = 0;
5217         adapter->monitorPoint.x = -1;
5218         adapter->monitorPoint.y = -1;
5219
5220         if (!AllocateLocallyUniqueId(&adapter->luid))
5221         {
5222             DWORD err = GetLastError();
5223             ERR("Failed to set adapter LUID (%#x).\n", err);
5224             goto nogl_adapter;
5225         }
5226         TRACE("Allocated LUID %08x:%08x for adapter.\n",
5227                 adapter->luid.HighPart, adapter->luid.LowPart);
5228
5229         if (!WineD3D_CreateFakeGLContext(&fake_gl_ctx))
5230         {
5231             ERR("Failed to get a gl context for default adapter\n");
5232             goto nogl_adapter;
5233         }
5234
5235         ret = IWineD3DImpl_FillGLCaps(adapter);
5236         if(!ret) {
5237             ERR("Failed to initialize gl caps for default adapter\n");
5238             WineD3D_ReleaseFakeGLContext(&fake_gl_ctx);
5239             goto nogl_adapter;
5240         }
5241         ret = initPixelFormats(&adapter->gl_info, adapter->driver_info.vendor);
5242         if(!ret) {
5243             ERR("Failed to init gl formats\n");
5244             WineD3D_ReleaseFakeGLContext(&fake_gl_ctx);
5245             goto nogl_adapter;
5246         }
5247
5248         hdc = fake_gl_ctx.dc;
5249
5250         adapter->TextureRam = adapter->driver_info.vidmem;
5251         adapter->UsedTextureRam = 0;
5252         TRACE("Emulating %dMB of texture ram\n", adapter->TextureRam/(1024*1024));
5253
5254         /* Initialize the Adapter's DeviceName which is required for ChangeDisplaySettings and friends */
5255         DisplayDevice.cb = sizeof(DisplayDevice);
5256         EnumDisplayDevicesW(NULL, 0 /* Adapter 0 = iDevNum 0 */, &DisplayDevice, 0);
5257         TRACE("DeviceName: %s\n", debugstr_w(DisplayDevice.DeviceName));
5258         strcpyW(adapter->DeviceName, DisplayDevice.DeviceName);
5259
5260         if (gl_info->supported[WGL_ARB_PIXEL_FORMAT])
5261         {
5262             int attribute;
5263             int attribs[11];
5264             int values[11];
5265             int nAttribs = 0;
5266
5267             attribute = WGL_NUMBER_PIXEL_FORMATS_ARB;
5268             GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc, 0, 0, 1, &attribute, &adapter->nCfgs));
5269
5270             adapter->cfgs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, adapter->nCfgs *sizeof(WineD3D_PixelFormat));
5271             cfgs = adapter->cfgs;
5272             attribs[nAttribs++] = WGL_RED_BITS_ARB;
5273             attribs[nAttribs++] = WGL_GREEN_BITS_ARB;
5274             attribs[nAttribs++] = WGL_BLUE_BITS_ARB;
5275             attribs[nAttribs++] = WGL_ALPHA_BITS_ARB;
5276             attribs[nAttribs++] = WGL_COLOR_BITS_ARB;
5277             attribs[nAttribs++] = WGL_DEPTH_BITS_ARB;
5278             attribs[nAttribs++] = WGL_STENCIL_BITS_ARB;
5279             attribs[nAttribs++] = WGL_DRAW_TO_WINDOW_ARB;
5280             attribs[nAttribs++] = WGL_PIXEL_TYPE_ARB;
5281             attribs[nAttribs++] = WGL_DOUBLE_BUFFER_ARB;
5282             attribs[nAttribs++] = WGL_AUX_BUFFERS_ARB;
5283
5284             for (iPixelFormat=1; iPixelFormat <= adapter->nCfgs; ++iPixelFormat)
5285             {
5286                 res = GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc, iPixelFormat, 0, nAttribs, attribs, values));
5287
5288                 if(!res)
5289                     continue;
5290
5291                 /* Cache the pixel format */
5292                 cfgs->iPixelFormat = iPixelFormat;
5293                 cfgs->redSize = values[0];
5294                 cfgs->greenSize = values[1];
5295                 cfgs->blueSize = values[2];
5296                 cfgs->alphaSize = values[3];
5297                 cfgs->colorSize = values[4];
5298                 cfgs->depthSize = values[5];
5299                 cfgs->stencilSize = values[6];
5300                 cfgs->windowDrawable = values[7];
5301                 cfgs->iPixelType = values[8];
5302                 cfgs->doubleBuffer = values[9];
5303                 cfgs->auxBuffers = values[10];
5304
5305                 cfgs->numSamples = 0;
5306                 /* Check multisample support */
5307                 if (gl_info->supported[ARB_MULTISAMPLE])
5308                 {
5309                     int attrib[2] = {WGL_SAMPLE_BUFFERS_ARB, WGL_SAMPLES_ARB};
5310                     int value[2];
5311                     if(GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc, iPixelFormat, 0, 2, attrib, value))) {
5312                         /* value[0] = WGL_SAMPLE_BUFFERS_ARB which tells whether multisampling is supported.
5313                         * value[1] = number of multi sample buffers*/
5314                         if(value[0])
5315                             cfgs->numSamples = value[1];
5316                     }
5317                 }
5318
5319                 TRACE("iPixelFormat=%d, iPixelType=%#x, doubleBuffer=%d, RGBA=%d/%d/%d/%d, "
5320                         "depth=%d, stencil=%d, samples=%d, windowDrawable=%d\n",
5321                         cfgs->iPixelFormat, cfgs->iPixelType, cfgs->doubleBuffer,
5322                         cfgs->redSize, cfgs->greenSize, cfgs->blueSize, cfgs->alphaSize,
5323                         cfgs->depthSize, cfgs->stencilSize, cfgs->numSamples, cfgs->windowDrawable);
5324                 cfgs++;
5325             }
5326         }
5327         else
5328         {
5329             int nCfgs = DescribePixelFormat(hdc, 0, 0, 0);
5330             adapter->cfgs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, nCfgs*sizeof(WineD3D_PixelFormat));
5331             adapter->nCfgs = 0; /* We won't accept all formats e.g. software accelerated ones will be skipped */
5332
5333             cfgs = adapter->cfgs;
5334             for(iPixelFormat=1; iPixelFormat<=nCfgs; iPixelFormat++)
5335             {
5336                 PIXELFORMATDESCRIPTOR ppfd;
5337
5338                 res = DescribePixelFormat(hdc, iPixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &ppfd);
5339                 if(!res)
5340                     continue;
5341
5342                 /* We only want HW acceleration using an OpenGL ICD driver.
5343                  * PFD_GENERIC_FORMAT = slow opengl 1.1 gdi software rendering
5344                  * PFD_GENERIC_ACCELERATED = partial hw acceleration using a MCD driver (e.g. 3dfx minigl)
5345                  */
5346                 if(ppfd.dwFlags & (PFD_GENERIC_FORMAT | PFD_GENERIC_ACCELERATED))
5347                 {
5348                     TRACE("Skipping iPixelFormat=%d because it isn't ICD accelerated\n", iPixelFormat);
5349                     continue;
5350                 }
5351
5352                 cfgs->iPixelFormat = iPixelFormat;
5353                 cfgs->redSize = ppfd.cRedBits;
5354                 cfgs->greenSize = ppfd.cGreenBits;
5355                 cfgs->blueSize = ppfd.cBlueBits;
5356                 cfgs->alphaSize = ppfd.cAlphaBits;
5357                 cfgs->colorSize = ppfd.cColorBits;
5358                 cfgs->depthSize = ppfd.cDepthBits;
5359                 cfgs->stencilSize = ppfd.cStencilBits;
5360                 cfgs->windowDrawable = (ppfd.dwFlags & PFD_DRAW_TO_WINDOW) ? 1 : 0;
5361                 cfgs->iPixelType = (ppfd.iPixelType == PFD_TYPE_RGBA) ? WGL_TYPE_RGBA_ARB : WGL_TYPE_COLORINDEX_ARB;
5362                 cfgs->doubleBuffer = (ppfd.dwFlags & PFD_DOUBLEBUFFER) ? 1 : 0;
5363                 cfgs->auxBuffers = ppfd.cAuxBuffers;
5364                 cfgs->numSamples = 0;
5365
5366                 TRACE("iPixelFormat=%d, iPixelType=%#x, doubleBuffer=%d, RGBA=%d/%d/%d/%d, "
5367                         "depth=%d, stencil=%d, windowDrawable=%d\n",
5368                         cfgs->iPixelFormat, cfgs->iPixelType, cfgs->doubleBuffer,
5369                         cfgs->redSize, cfgs->greenSize, cfgs->blueSize, cfgs->alphaSize,
5370                         cfgs->depthSize, cfgs->stencilSize, cfgs->windowDrawable);
5371                 cfgs++;
5372                 adapter->nCfgs++;
5373             }
5374
5375             /* 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 */
5376             if(!adapter->nCfgs)
5377             {
5378                 ERR("Disabling Direct3D because no hardware accelerated pixel formats have been found!\n");
5379
5380                 WineD3D_ReleaseFakeGLContext(&fake_gl_ctx);
5381                 HeapFree(GetProcessHeap(), 0, adapter->cfgs);
5382                 goto nogl_adapter;
5383             }
5384         }
5385
5386         /* D16, D24X8 and D24S8 are common depth / depth+stencil formats. All drivers support them though this doesn't
5387          * mean that the format is offered in hardware. For instance Geforce8 cards don't have offer D16 in hardware
5388          * but just fake it using D24(X8?) which is fine. D3D also allows that.
5389          * Some display drivers (i915 on Linux) only report mixed depth+stencil formats like D24S8. MSDN clearly mentions
5390          * that only on lockable formats (e.g. D16_locked) the bit order is guaranteed and that on other formats the
5391          * driver is allowed to consume more bits EXCEPT for stencil bits.
5392          *
5393          * Mark an adapter with this broken stencil behavior.
5394          */
5395         adapter->brokenStencil = TRUE;
5396         for (i = 0, cfgs = adapter->cfgs; i < adapter->nCfgs; ++i)
5397         {
5398             /* Nearly all drivers offer depth formats without stencil, only on i915 this if-statement won't be entered. */
5399             if(cfgs[i].depthSize && !cfgs[i].stencilSize) {
5400                 adapter->brokenStencil = FALSE;
5401                 break;
5402             }
5403         }
5404
5405         WineD3D_ReleaseFakeGLContext(&fake_gl_ctx);
5406
5407         select_shader_mode(&adapter->gl_info, &ps_selected_mode, &vs_selected_mode);
5408         fillGLAttribFuncs(&adapter->gl_info);
5409         adapter->opengl = TRUE;
5410     }
5411     This->adapter_count = 1;
5412     TRACE("%u adapters successfully initialized\n", This->adapter_count);
5413
5414     return TRUE;
5415
5416 nogl_adapter:
5417     /* Initialize an adapter for ddraw-only memory counting */
5418     memset(This->adapters, 0, sizeof(This->adapters));
5419     This->adapters[0].ordinal = 0;
5420     This->adapters[0].opengl = FALSE;
5421     This->adapters[0].monitorPoint.x = -1;
5422     This->adapters[0].monitorPoint.y = -1;
5423
5424     This->adapters[0].driver_info.name = "Display";
5425     This->adapters[0].driver_info.description = "WineD3D DirectDraw Emulation";
5426     if(wined3d_settings.emulated_textureram) {
5427         This->adapters[0].TextureRam = wined3d_settings.emulated_textureram;
5428     } else {
5429         This->adapters[0].TextureRam = 8 * 1024 * 1024; /* This is plenty for a DDraw-only card */
5430     }
5431
5432     initPixelFormatsNoGL(&This->adapters[0].gl_info);
5433
5434     This->adapter_count = 1;
5435     return FALSE;
5436 }
5437
5438 /**********************************************************
5439  * IWineD3D VTbl follows
5440  **********************************************************/
5441
5442 static const struct IWineD3DVtbl IWineD3D_Vtbl =
5443 {
5444     /* IUnknown */
5445     IWineD3DImpl_QueryInterface,
5446     IWineD3DImpl_AddRef,
5447     IWineD3DImpl_Release,
5448     /* IWineD3D */
5449     IWineD3DImpl_GetParent,
5450     IWineD3DImpl_GetAdapterCount,
5451     IWineD3DImpl_RegisterSoftwareDevice,
5452     IWineD3DImpl_GetAdapterMonitor,
5453     IWineD3DImpl_GetAdapterModeCount,
5454     IWineD3DImpl_EnumAdapterModes,
5455     IWineD3DImpl_GetAdapterDisplayMode,
5456     IWineD3DImpl_GetAdapterIdentifier,
5457     IWineD3DImpl_CheckDeviceMultiSampleType,
5458     IWineD3DImpl_CheckDepthStencilMatch,
5459     IWineD3DImpl_CheckDeviceType,
5460     IWineD3DImpl_CheckDeviceFormat,
5461     IWineD3DImpl_CheckDeviceFormatConversion,
5462     IWineD3DImpl_GetDeviceCaps,
5463     IWineD3DImpl_CreateDevice
5464 };
5465
5466 static void STDMETHODCALLTYPE wined3d_null_wined3d_object_destroyed(void *parent) {}
5467
5468 const struct wined3d_parent_ops wined3d_null_parent_ops =
5469 {
5470     wined3d_null_wined3d_object_destroyed,
5471 };
5472
5473 /* Do not call while under the GL lock. */
5474 HRESULT wined3d_init(IWineD3DImpl *wined3d, UINT version, void *parent)
5475 {
5476     wined3d->lpVtbl = &IWineD3D_Vtbl;
5477     wined3d->dxVersion = version;
5478     wined3d->ref = 1;
5479     wined3d->parent = parent;
5480
5481     if (!InitAdapters(wined3d))
5482     {
5483         WARN("Failed to initialize adapters.\n");
5484         if (version > 7)
5485         {
5486             MESSAGE("Direct3D%u is not available without OpenGL.\n", version);
5487             return E_FAIL;
5488         }
5489     }
5490
5491     return WINED3D_OK;
5492 }