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