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