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