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_UNKNOWN:
3474             return FALSE;
3475
3476         default:
3477             ERR("Unhandled format %s.\n", debug_d3dformat(format->id));
3478             break;
3479     }
3480     return FALSE;
3481 }
3482
3483 static BOOL CheckSurfaceCapability(struct wined3d_adapter *adapter,
3484         const struct wined3d_format *adapter_format,
3485         const struct wined3d_format *check_format,
3486         WINED3DSURFTYPE SurfaceType)
3487 {
3488     if (SurfaceType == SURFACE_GDI)
3489     {
3490         switch (check_format->id)
3491         {
3492             case WINED3DFMT_B8G8R8_UNORM:
3493             case WINED3DFMT_B8G8R8A8_UNORM:
3494             case WINED3DFMT_B8G8R8X8_UNORM:
3495             case WINED3DFMT_B5G6R5_UNORM:
3496             case WINED3DFMT_B5G5R5X1_UNORM:
3497             case WINED3DFMT_B5G5R5A1_UNORM:
3498             case WINED3DFMT_B4G4R4A4_UNORM:
3499             case WINED3DFMT_B2G3R3_UNORM:
3500             case WINED3DFMT_A8_UNORM:
3501             case WINED3DFMT_B2G3R3A8_UNORM:
3502             case WINED3DFMT_B4G4R4X4_UNORM:
3503             case WINED3DFMT_R10G10B10A2_UNORM:
3504             case WINED3DFMT_R8G8B8A8_UNORM:
3505             case WINED3DFMT_R8G8B8X8_UNORM:
3506             case WINED3DFMT_R16G16_UNORM:
3507             case WINED3DFMT_B10G10R10A2_UNORM:
3508             case WINED3DFMT_R16G16B16A16_UNORM:
3509             case WINED3DFMT_P8_UINT:
3510                 TRACE_(d3d_caps)("[OK]\n");
3511                 return TRUE;
3512             default:
3513                 TRACE_(d3d_caps)("[FAILED] - not available on GDI surfaces\n");
3514                 return FALSE;
3515         }
3516     }
3517
3518     /* All format that are supported for textures are supported for surfaces as well */
3519     if (CheckTextureCapability(adapter, check_format)) return TRUE;
3520     /* All depth stencil formats are supported on surfaces */
3521     if (CheckDepthStencilCapability(adapter, adapter_format, check_format)) return TRUE;
3522
3523     /* If opengl can't process the format natively, the blitter may be able to convert it */
3524     if (adapter->blitter->blit_supported(&adapter->gl_info, BLIT_OP_BLIT,
3525             NULL, WINED3DPOOL_DEFAULT, 0, check_format,
3526             NULL, WINED3DPOOL_DEFAULT, 0, adapter_format))
3527     {
3528         TRACE_(d3d_caps)("[OK]\n");
3529         return TRUE;
3530     }
3531
3532     /* Reject other formats */
3533     TRACE_(d3d_caps)("[FAILED]\n");
3534     return FALSE;
3535 }
3536
3537 static BOOL CheckVertexTextureCapability(struct wined3d_adapter *adapter,
3538         const struct wined3d_format *format)
3539 {
3540     return adapter->gl_info.limits.vertex_samplers && (format->flags & WINED3DFMT_FLAG_VTF);
3541 }
3542
3543 static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
3544         enum wined3d_format_id AdapterFormat, DWORD Usage, WINED3DRESOURCETYPE RType,
3545         enum wined3d_format_id CheckFormat, WINED3DSURFTYPE SurfaceType)
3546 {
3547     IWineD3DImpl *This = (IWineD3DImpl *)iface;
3548     struct wined3d_adapter *adapter = &This->adapters[Adapter];
3549     const struct wined3d_gl_info *gl_info = &adapter->gl_info;
3550     const struct wined3d_format *format = wined3d_get_format(gl_info, CheckFormat);
3551     const struct wined3d_format *adapter_format = wined3d_get_format(gl_info, AdapterFormat);
3552     DWORD UsageCaps = 0;
3553
3554     TRACE_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, DevType:(%u,%s), AdptFmt:(%u,%s), Use:(%u,%s,%s), ResTyp:(%x,%s), CheckFmt:(%u,%s))\n",
3555           This,
3556           Adapter,
3557           DeviceType, debug_d3ddevicetype(DeviceType),
3558           AdapterFormat, debug_d3dformat(AdapterFormat),
3559           Usage, debug_d3dusage(Usage), debug_d3dusagequery(Usage),
3560           RType, debug_d3dresourcetype(RType),
3561           CheckFormat, debug_d3dformat(CheckFormat));
3562
3563     if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
3564         return WINED3DERR_INVALIDCALL;
3565     }
3566
3567     switch (RType)
3568     {
3569         case WINED3DRTYPE_CUBETEXTURE:
3570             /* Cubetexture allows:
3571              *      - WINED3DUSAGE_AUTOGENMIPMAP
3572              *      - WINED3DUSAGE_DEPTHSTENCIL
3573              *      - WINED3DUSAGE_DYNAMIC
3574              *      - WINED3DUSAGE_NONSECURE (d3d9ex)
3575              *      - WINED3DUSAGE_RENDERTARGET
3576              *      - WINED3DUSAGE_SOFTWAREPROCESSING
3577              *      - WINED3DUSAGE_QUERY_WRAPANDMIP
3578              */
3579             if (SurfaceType != SURFACE_OPENGL)
3580             {
3581                 TRACE_(d3d_caps)("[FAILED]\n");
3582                 return WINED3DERR_NOTAVAILABLE;
3583             }
3584
3585             if (!gl_info->supported[ARB_TEXTURE_CUBE_MAP])
3586             {
3587                 TRACE_(d3d_caps)("[FAILED] - No cube texture support\n");
3588                 return WINED3DERR_NOTAVAILABLE;
3589             }
3590
3591             if (!CheckTextureCapability(adapter, format))
3592             {
3593                 TRACE_(d3d_caps)("[FAILED] - Cube texture format not supported\n");
3594                 return WINED3DERR_NOTAVAILABLE;
3595             }
3596
3597             if (Usage & WINED3DUSAGE_AUTOGENMIPMAP)
3598             {
3599                 if (!gl_info->supported[SGIS_GENERATE_MIPMAP])
3600                     /* When autogenmipmap isn't around continue and return
3601                      * WINED3DOK_NOAUTOGEN instead of D3D_OK. */
3602                     TRACE_(d3d_caps)("[FAILED] - No autogenmipmap support, but continuing\n");
3603                 else
3604                     UsageCaps |= WINED3DUSAGE_AUTOGENMIPMAP;
3605             }
3606
3607             /* Always report dynamic locking. */
3608             if (Usage & WINED3DUSAGE_DYNAMIC)
3609                 UsageCaps |= WINED3DUSAGE_DYNAMIC;
3610
3611             if (Usage & WINED3DUSAGE_RENDERTARGET)
3612             {
3613                 if (!CheckRenderTargetCapability(adapter, adapter_format, format))
3614                 {
3615                     TRACE_(d3d_caps)("[FAILED] - No rendertarget support\n");
3616                     return WINED3DERR_NOTAVAILABLE;
3617                 }
3618                 UsageCaps |= WINED3DUSAGE_RENDERTARGET;
3619             }
3620
3621             /* Always report software processing. */
3622             if (Usage & WINED3DUSAGE_SOFTWAREPROCESSING)
3623                 UsageCaps |= WINED3DUSAGE_SOFTWAREPROCESSING;
3624
3625             if (Usage & WINED3DUSAGE_QUERY_FILTER)
3626             {
3627                 if (!CheckFilterCapability(adapter, format))
3628                 {
3629                     TRACE_(d3d_caps)("[FAILED] - No query filter support\n");
3630                     return WINED3DERR_NOTAVAILABLE;
3631                 }
3632                 UsageCaps |= WINED3DUSAGE_QUERY_FILTER;
3633             }
3634
3635             if (Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING)
3636             {
3637                 if (!CheckPostPixelShaderBlendingCapability(adapter, format))
3638                 {
3639                     TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
3640                     return WINED3DERR_NOTAVAILABLE;
3641                 }
3642                 UsageCaps |= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
3643             }
3644
3645             if (Usage & WINED3DUSAGE_QUERY_SRGBREAD)
3646             {
3647                 if (!CheckSrgbReadCapability(adapter, format))
3648                 {
3649                     TRACE_(d3d_caps)("[FAILED] - No query srgbread support\n");
3650                     return WINED3DERR_NOTAVAILABLE;
3651                 }
3652                 UsageCaps |= WINED3DUSAGE_QUERY_SRGBREAD;
3653             }
3654
3655             if (Usage & WINED3DUSAGE_QUERY_SRGBWRITE)
3656             {
3657                 if (!CheckSrgbWriteCapability(adapter, format))
3658                 {
3659                     TRACE_(d3d_caps)("[FAILED] - No query srgbwrite support\n");
3660                     return WINED3DERR_NOTAVAILABLE;
3661                 }
3662                 UsageCaps |= WINED3DUSAGE_QUERY_SRGBWRITE;
3663             }
3664
3665             if (Usage & WINED3DUSAGE_QUERY_VERTEXTEXTURE)
3666             {
3667                 if (!CheckVertexTextureCapability(adapter, format))
3668                 {
3669                     TRACE_(d3d_caps)("[FAILED] - No query vertextexture support\n");
3670                     return WINED3DERR_NOTAVAILABLE;
3671                 }
3672                 UsageCaps |= WINED3DUSAGE_QUERY_VERTEXTEXTURE;
3673             }
3674
3675             if (Usage & WINED3DUSAGE_QUERY_WRAPANDMIP)
3676             {
3677                 if (!CheckWrapAndMipCapability(adapter, format))
3678                 {
3679                     TRACE_(d3d_caps)("[FAILED] - No wrapping and mipmapping support\n");
3680                     return WINED3DERR_NOTAVAILABLE;
3681                 }
3682                 UsageCaps |= WINED3DUSAGE_QUERY_WRAPANDMIP;
3683             }
3684             break;
3685
3686         case WINED3DRTYPE_SURFACE:
3687             /* Surface allows:
3688              *      - WINED3DUSAGE_DEPTHSTENCIL
3689              *      - WINED3DUSAGE_NONSECURE (d3d9ex)
3690              *      - WINED3DUSAGE_RENDERTARGET
3691              */
3692             if (!CheckSurfaceCapability(adapter, adapter_format, format, SurfaceType))
3693             {
3694                 TRACE_(d3d_caps)("[FAILED] - Not supported for plain surfaces\n");
3695                 return WINED3DERR_NOTAVAILABLE;
3696             }
3697
3698             if (Usage & WINED3DUSAGE_DEPTHSTENCIL)
3699             {
3700                 if (!CheckDepthStencilCapability(adapter, adapter_format, format))
3701                 {
3702                     TRACE_(d3d_caps)("[FAILED] - No depthstencil support\n");
3703                     return WINED3DERR_NOTAVAILABLE;
3704                 }
3705                 UsageCaps |= WINED3DUSAGE_DEPTHSTENCIL;
3706             }
3707
3708             if (Usage & WINED3DUSAGE_RENDERTARGET)
3709             {
3710                 if (!CheckRenderTargetCapability(adapter, adapter_format, format))
3711                 {
3712                     TRACE_(d3d_caps)("[FAILED] - No rendertarget support\n");
3713                     return WINED3DERR_NOTAVAILABLE;
3714                 }
3715                 UsageCaps |= WINED3DUSAGE_RENDERTARGET;
3716             }
3717
3718             if (Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING)
3719             {
3720                 if (!CheckPostPixelShaderBlendingCapability(adapter, format))
3721                 {
3722                     TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
3723                     return WINED3DERR_NOTAVAILABLE;
3724                 }
3725                 UsageCaps |= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
3726             }
3727             break;
3728
3729         case WINED3DRTYPE_TEXTURE:
3730             /* Texture allows:
3731              *      - WINED3DUSAGE_AUTOGENMIPMAP
3732              *      - WINED3DUSAGE_DEPTHSTENCIL
3733              *      - WINED3DUSAGE_DMAP
3734              *      - WINED3DUSAGE_DYNAMIC
3735              *      - WINED3DUSAGE_NONSECURE (d3d9ex)
3736              *      - WINED3DUSAGE_RENDERTARGET
3737              *      - WINED3DUSAGE_SOFTWAREPROCESSING
3738              *      - WINED3DUSAGE_TEXTAPI (d3d9ex)
3739              *      - WINED3DUSAGE_QUERY_WRAPANDMIP
3740              */
3741             if (SurfaceType != SURFACE_OPENGL)
3742             {
3743                 TRACE_(d3d_caps)("[FAILED]\n");
3744                 return WINED3DERR_NOTAVAILABLE;
3745             }
3746
3747             if (!CheckTextureCapability(adapter, format))
3748             {
3749                 TRACE_(d3d_caps)("[FAILED] - Texture format not supported\n");
3750                 return WINED3DERR_NOTAVAILABLE;
3751             }
3752
3753             if (Usage & WINED3DUSAGE_AUTOGENMIPMAP)
3754             {
3755                 if (!gl_info->supported[SGIS_GENERATE_MIPMAP])
3756                     /* When autogenmipmap isn't around continue and return
3757                      * WINED3DOK_NOAUTOGEN instead of D3D_OK. */
3758                     TRACE_(d3d_caps)("[FAILED] - No autogenmipmap support, but continuing\n");
3759                 else
3760                     UsageCaps |= WINED3DUSAGE_AUTOGENMIPMAP;
3761             }
3762
3763             /* Always report dynamic locking. */
3764             if (Usage & WINED3DUSAGE_DYNAMIC)
3765                 UsageCaps |= WINED3DUSAGE_DYNAMIC;
3766
3767             if (Usage & WINED3DUSAGE_RENDERTARGET)
3768             {
3769                 if (!CheckRenderTargetCapability(adapter, adapter_format, format))
3770                 {
3771                     TRACE_(d3d_caps)("[FAILED] - No rendertarget support\n");
3772                     return WINED3DERR_NOTAVAILABLE;
3773                 }
3774                 UsageCaps |= WINED3DUSAGE_RENDERTARGET;
3775             }
3776
3777             /* Always report software processing. */
3778             if (Usage & WINED3DUSAGE_SOFTWAREPROCESSING)
3779                 UsageCaps |= WINED3DUSAGE_SOFTWAREPROCESSING;
3780
3781             if (Usage & WINED3DUSAGE_QUERY_FILTER)
3782             {
3783                 if (!CheckFilterCapability(adapter, format))
3784                 {
3785                     TRACE_(d3d_caps)("[FAILED] - No query filter support\n");
3786                     return WINED3DERR_NOTAVAILABLE;
3787                 }
3788                 UsageCaps |= WINED3DUSAGE_QUERY_FILTER;
3789             }
3790
3791             if (Usage & WINED3DUSAGE_QUERY_LEGACYBUMPMAP)
3792             {
3793                 if (!CheckBumpMapCapability(adapter, format))
3794                 {
3795                     TRACE_(d3d_caps)("[FAILED] - No legacy bumpmap support\n");
3796                     return WINED3DERR_NOTAVAILABLE;
3797                 }
3798                 UsageCaps |= WINED3DUSAGE_QUERY_LEGACYBUMPMAP;
3799             }
3800
3801             if (Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING)
3802             {
3803                 if (!CheckPostPixelShaderBlendingCapability(adapter, format))
3804                 {
3805                     TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
3806                     return WINED3DERR_NOTAVAILABLE;
3807                 }
3808                 UsageCaps |= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
3809             }
3810
3811             if (Usage & WINED3DUSAGE_QUERY_SRGBREAD)
3812             {
3813                 if (!CheckSrgbReadCapability(adapter, format))
3814                 {
3815                     TRACE_(d3d_caps)("[FAILED] - No query srgbread support\n");
3816                     return WINED3DERR_NOTAVAILABLE;
3817                 }
3818                 UsageCaps |= WINED3DUSAGE_QUERY_SRGBREAD;
3819             }
3820
3821             if (Usage & WINED3DUSAGE_QUERY_SRGBWRITE)
3822             {
3823                 if (!CheckSrgbWriteCapability(adapter, format))
3824                 {
3825                     TRACE_(d3d_caps)("[FAILED] - No query srgbwrite support\n");
3826                     return WINED3DERR_NOTAVAILABLE;
3827                 }
3828                 UsageCaps |= WINED3DUSAGE_QUERY_SRGBWRITE;
3829             }
3830
3831             if (Usage & WINED3DUSAGE_QUERY_VERTEXTEXTURE)
3832             {
3833                 if (!CheckVertexTextureCapability(adapter, format))
3834                 {
3835                     TRACE_(d3d_caps)("[FAILED] - No query vertextexture support\n");
3836                     return WINED3DERR_NOTAVAILABLE;
3837                 }
3838                 UsageCaps |= WINED3DUSAGE_QUERY_VERTEXTEXTURE;
3839             }
3840
3841             if (Usage & WINED3DUSAGE_QUERY_WRAPANDMIP)
3842             {
3843                 if (!CheckWrapAndMipCapability(adapter, format))
3844                 {
3845                     TRACE_(d3d_caps)("[FAILED] - No wrapping and mipmapping support\n");
3846                     return WINED3DERR_NOTAVAILABLE;
3847                 }
3848                 UsageCaps |= WINED3DUSAGE_QUERY_WRAPANDMIP;
3849             }
3850
3851             if (Usage & WINED3DUSAGE_DEPTHSTENCIL)
3852             {
3853                 if (!CheckDepthStencilCapability(adapter, adapter_format, format))
3854                 {
3855                     TRACE_(d3d_caps)("[FAILED] - No depth stencil support\n");
3856                     return WINED3DERR_NOTAVAILABLE;
3857                 }
3858                 if ((format->flags & WINED3DFMT_FLAG_SHADOW) && !gl_info->supported[ARB_SHADOW])
3859                 {
3860                     TRACE_(d3d_caps)("[FAILED] - No shadow sampler support.\n");
3861                     return WINED3DERR_NOTAVAILABLE;
3862                 }
3863                 UsageCaps |= WINED3DUSAGE_DEPTHSTENCIL;
3864             }
3865             break;
3866
3867         case WINED3DRTYPE_VOLUMETEXTURE:
3868         case WINED3DRTYPE_VOLUME:
3869             /* Volume is to VolumeTexture what Surface is to Texture, but its
3870              * usage caps are not documented. Most driver seem to offer
3871              * (nearly) the same on Volume and VolumeTexture, so do that too.
3872              *
3873              * Volumetexture allows:
3874              *      - D3DUSAGE_DYNAMIC
3875              *      - D3DUSAGE_NONSECURE (d3d9ex)
3876              *      - D3DUSAGE_SOFTWAREPROCESSING
3877              *      - D3DUSAGE_QUERY_WRAPANDMIP
3878              */
3879             if (SurfaceType != SURFACE_OPENGL)
3880             {
3881                 TRACE_(d3d_caps)("[FAILED]\n");
3882                 return WINED3DERR_NOTAVAILABLE;
3883             }
3884
3885             if (!gl_info->supported[EXT_TEXTURE3D])
3886             {
3887                 TRACE_(d3d_caps)("[FAILED] - No volume texture support\n");
3888                 return WINED3DERR_NOTAVAILABLE;
3889             }
3890
3891             if (!CheckTextureCapability(adapter, format))
3892             {
3893                 TRACE_(d3d_caps)("[FAILED] - Format not supported\n");
3894                 return WINED3DERR_NOTAVAILABLE;
3895             }
3896
3897             /* Filter formats that need conversion; For one part, this
3898              * conversion is unimplemented, and volume textures are huge, so
3899              * it would be a big performance hit. Unless we hit an application
3900              * needing one of those formats, don't advertize them to avoid
3901              * leading applications into temptation. The windows drivers don't
3902              * support most of those formats on volumes anyway, except for
3903              * WINED3DFMT_R32_FLOAT. */
3904             switch (CheckFormat)
3905             {
3906                 case WINED3DFMT_P8_UINT:
3907                 case WINED3DFMT_L4A4_UNORM:
3908                 case WINED3DFMT_R32_FLOAT:
3909                 case WINED3DFMT_R16_FLOAT:
3910                 case WINED3DFMT_R8G8_SNORM_L8X8_UNORM:
3911                 case WINED3DFMT_R5G5_SNORM_L6_UNORM:
3912                 case WINED3DFMT_R16G16_UNORM:
3913                     TRACE_(d3d_caps)("[FAILED] - No converted formats on volumes\n");
3914                     return WINED3DERR_NOTAVAILABLE;
3915
3916                 case WINED3DFMT_R8G8B8A8_SNORM:
3917                 case WINED3DFMT_R16G16_SNORM:
3918                     if (!gl_info->supported[NV_TEXTURE_SHADER])
3919                     {
3920                         TRACE_(d3d_caps)("[FAILED] - No converted formats on volumes\n");
3921                         return WINED3DERR_NOTAVAILABLE;
3922                     }
3923                     break;
3924
3925                 case WINED3DFMT_R8G8_SNORM:
3926                     if (!gl_info->supported[NV_TEXTURE_SHADER])
3927                     {
3928                         TRACE_(d3d_caps)("[FAILED] - No converted formats on volumes\n");
3929                         return WINED3DERR_NOTAVAILABLE;
3930                     }
3931                     break;
3932
3933                 case WINED3DFMT_DXT1:
3934                 case WINED3DFMT_DXT2:
3935                 case WINED3DFMT_DXT3:
3936                 case WINED3DFMT_DXT4:
3937                 case WINED3DFMT_DXT5:
3938                     /* The GL_EXT_texture_compression_s3tc spec requires that
3939                      * loading an s3tc compressed texture results in an error.
3940                      * While the D3D refrast does support s3tc volumes, at
3941                      * least the nvidia windows driver does not, so we're free
3942                      * not to support this format. */
3943                     TRACE_(d3d_caps)("[FAILED] - DXTn does not support 3D textures\n");
3944                     return WINED3DERR_NOTAVAILABLE;
3945
3946                 default:
3947                     /* Do nothing, continue with checking the format below */
3948                     break;
3949             }
3950
3951             /* Always report dynamic locking. */
3952             if (Usage & WINED3DUSAGE_DYNAMIC)
3953                 UsageCaps |= WINED3DUSAGE_DYNAMIC;
3954
3955             /* Always report software processing. */
3956             if (Usage & WINED3DUSAGE_SOFTWAREPROCESSING)
3957                 UsageCaps |= WINED3DUSAGE_SOFTWAREPROCESSING;
3958
3959             if (Usage & WINED3DUSAGE_QUERY_FILTER)
3960             {
3961                 if (!CheckFilterCapability(adapter, format))
3962                 {
3963                     TRACE_(d3d_caps)("[FAILED] - No query filter support\n");
3964                     return WINED3DERR_NOTAVAILABLE;
3965                 }
3966                 UsageCaps |= WINED3DUSAGE_QUERY_FILTER;
3967             }
3968
3969             if (Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING)
3970             {
3971                 if (!CheckPostPixelShaderBlendingCapability(adapter, format))
3972                 {
3973                     TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
3974                     return WINED3DERR_NOTAVAILABLE;
3975                 }
3976                 UsageCaps |= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
3977             }
3978
3979             if (Usage & WINED3DUSAGE_QUERY_SRGBREAD)
3980             {
3981                 if (!CheckSrgbReadCapability(adapter, format))
3982                 {
3983                     TRACE_(d3d_caps)("[FAILED] - No query srgbread support\n");
3984                     return WINED3DERR_NOTAVAILABLE;
3985                 }
3986                 UsageCaps |= WINED3DUSAGE_QUERY_SRGBREAD;
3987             }
3988
3989             if (Usage & WINED3DUSAGE_QUERY_SRGBWRITE)
3990             {
3991                 if (!CheckSrgbWriteCapability(adapter, format))
3992                 {
3993                     TRACE_(d3d_caps)("[FAILED] - No query srgbwrite support\n");
3994                     return WINED3DERR_NOTAVAILABLE;
3995                 }
3996                 UsageCaps |= WINED3DUSAGE_QUERY_SRGBWRITE;
3997             }
3998
3999             if (Usage & WINED3DUSAGE_QUERY_VERTEXTEXTURE)
4000             {
4001                 if (!CheckVertexTextureCapability(adapter, format))
4002                 {
4003                     TRACE_(d3d_caps)("[FAILED] - No query vertextexture support\n");
4004                     return WINED3DERR_NOTAVAILABLE;
4005                 }
4006                 UsageCaps |= WINED3DUSAGE_QUERY_VERTEXTEXTURE;
4007             }
4008
4009             if (Usage & WINED3DUSAGE_QUERY_WRAPANDMIP)
4010             {
4011                 if (!CheckWrapAndMipCapability(adapter, format))
4012                 {
4013                     TRACE_(d3d_caps)("[FAILED] - No wrapping and mipmapping support\n");
4014                     return WINED3DERR_NOTAVAILABLE;
4015                 }
4016                 UsageCaps |= WINED3DUSAGE_QUERY_WRAPANDMIP;
4017             }
4018             break;
4019
4020         default:
4021             FIXME_(d3d_caps)("Unhandled resource type %s.\n", debug_d3dresourcetype(RType));
4022             return WINED3DERR_NOTAVAILABLE;
4023     }
4024
4025     /* When the UsageCaps exactly matches Usage return WINED3D_OK except for
4026      * the situation in which WINED3DUSAGE_AUTOGENMIPMAP isn't around, then
4027      * WINED3DOK_NOAUTOGEN is returned if all the other usage flags match. */
4028     if (UsageCaps == Usage)
4029         return WINED3D_OK;
4030     if (UsageCaps == (Usage & ~WINED3DUSAGE_AUTOGENMIPMAP))
4031         return WINED3DOK_NOAUTOGEN;
4032
4033     TRACE_(d3d_caps)("[FAILED] - Usage %#x requested for CheckFormat %s and RType %s but only %#x is available\n",
4034             Usage, debug_d3dformat(CheckFormat), debug_d3dresourcetype(RType), UsageCaps);
4035
4036     return WINED3DERR_NOTAVAILABLE;
4037 }
4038
4039 static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormatConversion(IWineD3D *iface, UINT adapter_idx,
4040         WINED3DDEVTYPE device_type, enum wined3d_format_id src_format, enum wined3d_format_id dst_format)
4041 {
4042     FIXME("iface %p, adapter_idx %u, device_type %s, src_format %s, dst_format %s stub!\n",
4043             iface, adapter_idx, debug_d3ddevicetype(device_type), debug_d3dformat(src_format),
4044             debug_d3dformat(dst_format));
4045
4046     return WINED3D_OK;
4047 }
4048
4049 static HRESULT WINAPI IWineD3DImpl_CheckDeviceType(IWineD3D *iface, UINT adapter_idx, WINED3DDEVTYPE device_type,
4050         enum wined3d_format_id display_format, enum wined3d_format_id backbuffer_format, BOOL windowed)
4051 {
4052     UINT mode_count;
4053     HRESULT hr;
4054
4055     TRACE("iface %p, adapter_idx %u, device_type %s, display_format %s, backbuffer_format %s, windowed %#x.\n",
4056             iface, adapter_idx, debug_d3ddevicetype(device_type), debug_d3dformat(display_format),
4057             debug_d3dformat(backbuffer_format), windowed);
4058
4059     if (adapter_idx >= IWineD3D_GetAdapterCount(iface))
4060     {
4061         WARN_(d3d_caps)("adapter_idx >= IWineD3D_GetAdapterCount(iface), returning WINED3DERR_INVALIDCALL\n");
4062         return WINED3DERR_INVALIDCALL;
4063     }
4064
4065     /* The task of this function is to check whether a certain display / backbuffer format
4066      * combination is available on the given adapter. In fullscreen mode microsoft specified
4067      * that the display format shouldn't provide alpha and that ignoring alpha the backbuffer
4068      * and display format should match exactly.
4069      * In windowed mode format conversion can occur and this depends on the driver. When format
4070      * conversion is done, this function should nevertheless fail and applications need to use
4071      * CheckDeviceFormatConversion.
4072      * At the moment we assume that fullscreen and windowed have the same capabilities. */
4073
4074     /* There are only 4 display formats. */
4075     if (!(display_format == WINED3DFMT_B5G6R5_UNORM
4076             || display_format == WINED3DFMT_B5G5R5X1_UNORM
4077             || display_format == WINED3DFMT_B8G8R8X8_UNORM
4078             || display_format == WINED3DFMT_B10G10R10A2_UNORM))
4079     {
4080         TRACE_(d3d_caps)("Format %s is not supported as display format.\n", debug_d3dformat(display_format));
4081         return WINED3DERR_NOTAVAILABLE;
4082     }
4083
4084     /* If the requested display format is not available, don't continue. */
4085     mode_count = IWineD3DImpl_GetAdapterModeCount(iface, adapter_idx, display_format);
4086     if (!mode_count)
4087     {
4088         TRACE_(d3d_caps)("No available modes for display format %s.\n", debug_d3dformat(display_format));
4089         return WINED3DERR_NOTAVAILABLE;
4090     }
4091
4092     /* Windowed mode allows you to specify WINED3DFMT_UNKNOWN for the backbuffer format,
4093      * it means 'reuse' the display format for the backbuffer. */
4094     if (!windowed && backbuffer_format == WINED3DFMT_UNKNOWN)
4095     {
4096         TRACE_(d3d_caps)("backbuffer_format WINED3FMT_UNKNOWN only available in windowed mode.\n");
4097         return WINED3DERR_NOTAVAILABLE;
4098     }
4099
4100     /* In FULLSCREEN mode WINED3DFMT_B5G6R5_UNORM can only be mixed with
4101      * backbuffer format WINED3DFMT_B5G6R5_UNORM. */
4102     if (display_format == WINED3DFMT_B5G6R5_UNORM && backbuffer_format != WINED3DFMT_B5G6R5_UNORM)
4103     {
4104         TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s / %s.\n",
4105                 debug_d3dformat(display_format), debug_d3dformat(backbuffer_format));
4106         return WINED3DERR_NOTAVAILABLE;
4107     }
4108
4109     /* In FULLSCREEN mode WINED3DFMT_B5G5R5X1_UNORM can only be mixed with
4110      * backbuffer formats WINED3DFMT_B5G5R5X1_UNORM and
4111      * WINED3DFMT_B5G5R5A1_UNORM. */
4112     if (display_format == WINED3DFMT_B5G5R5X1_UNORM
4113             && !(backbuffer_format == WINED3DFMT_B5G5R5X1_UNORM || backbuffer_format == WINED3DFMT_B5G5R5A1_UNORM))
4114     {
4115         TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s / %s.\n",
4116                 debug_d3dformat(display_format), debug_d3dformat(backbuffer_format));
4117         return WINED3DERR_NOTAVAILABLE;
4118     }
4119
4120     /* In FULLSCREEN mode WINED3DFMT_B8G8R8X8_UNORM can only be mixed with
4121      * backbuffer formats WINED3DFMT_B8G8R8X8_UNORM and
4122      * WINED3DFMT_B8G8R8A8_UNORM. */
4123     if (display_format == WINED3DFMT_B8G8R8X8_UNORM
4124             && !(backbuffer_format == WINED3DFMT_B8G8R8X8_UNORM || backbuffer_format == WINED3DFMT_B8G8R8A8_UNORM))
4125     {
4126         TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s / %s.\n",
4127                 debug_d3dformat(display_format), debug_d3dformat(backbuffer_format));
4128         return WINED3DERR_NOTAVAILABLE;
4129     }
4130
4131     /* WINED3DFMT_B10G10R10A2_UNORM is only allowed in fullscreen mode and it
4132      * can only be mixed with backbuffer format WINED3DFMT_B10G10R10A2_UNORM. */
4133     if (display_format == WINED3DFMT_B10G10R10A2_UNORM
4134             && (backbuffer_format != WINED3DFMT_B10G10R10A2_UNORM || windowed))
4135     {
4136         TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s / %s.\n",
4137                 debug_d3dformat(display_format), debug_d3dformat(backbuffer_format));
4138         return WINED3DERR_NOTAVAILABLE;
4139     }
4140
4141     /* Use CheckDeviceFormat to see if the backbuffer_format is usable with the given display_format */
4142     hr = IWineD3DImpl_CheckDeviceFormat(iface, adapter_idx, device_type, display_format,
4143             WINED3DUSAGE_RENDERTARGET, WINED3DRTYPE_SURFACE, backbuffer_format, SURFACE_OPENGL);
4144     if (FAILED(hr))
4145         TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s / %s.\n",
4146                 debug_d3dformat(display_format), debug_d3dformat(backbuffer_format));
4147
4148     return hr;
4149 }
4150
4151 /* Note: d3d8 passes in a pointer to a D3DCAPS8 structure, which is a true
4152       subset of a D3DCAPS9 structure. However, it has to come via a void *
4153       as the d3d8 interface cannot import the d3d9 header                  */
4154 static HRESULT WINAPI IWineD3DImpl_GetDeviceCaps(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType, WINED3DCAPS* pCaps) {
4155
4156     IWineD3DImpl    *This = (IWineD3DImpl *)iface;
4157     struct wined3d_adapter *adapter = &This->adapters[Adapter];
4158     const struct wined3d_gl_info *gl_info = &adapter->gl_info;
4159     int vs_selected_mode;
4160     int ps_selected_mode;
4161     struct shader_caps shader_caps;
4162     struct fragment_caps fragment_caps;
4163     DWORD ckey_caps, blit_caps, fx_caps, pal_caps;
4164
4165     TRACE_(d3d_caps)("(%p)->(Adptr:%d, DevType: %x, pCaps: %p)\n", This, Adapter, DeviceType, pCaps);
4166
4167     if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
4168         return WINED3DERR_INVALIDCALL;
4169     }
4170
4171     select_shader_mode(&adapter->gl_info, &ps_selected_mode, &vs_selected_mode);
4172
4173     /* ------------------------------------------------
4174        The following fields apply to both d3d8 and d3d9
4175        ------------------------------------------------ */
4176     pCaps->DeviceType              = (DeviceType == WINED3DDEVTYPE_HAL) ? WINED3DDEVTYPE_HAL : WINED3DDEVTYPE_REF;  /* Not quite true, but use h/w supported by opengl I suppose */
4177     pCaps->AdapterOrdinal          = Adapter;
4178
4179     pCaps->Caps                    = 0;
4180     pCaps->Caps2                   = WINED3DCAPS2_CANRENDERWINDOWED |
4181                                      WINED3DCAPS2_FULLSCREENGAMMA |
4182                                      WINED3DCAPS2_DYNAMICTEXTURES;
4183     if (gl_info->supported[SGIS_GENERATE_MIPMAP])
4184     {
4185         pCaps->Caps2 |= WINED3DCAPS2_CANAUTOGENMIPMAP;
4186     }
4187
4188     pCaps->Caps3                   = WINED3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD |
4189                                      WINED3DCAPS3_COPY_TO_VIDMEM                   |
4190                                      WINED3DCAPS3_COPY_TO_SYSTEMMEM;
4191
4192     pCaps->PresentationIntervals   = WINED3DPRESENT_INTERVAL_IMMEDIATE  |
4193                                      WINED3DPRESENT_INTERVAL_ONE;
4194
4195     pCaps->CursorCaps              = WINED3DCURSORCAPS_COLOR            |
4196                                      WINED3DCURSORCAPS_LOWRES;
4197
4198     pCaps->DevCaps                 = WINED3DDEVCAPS_FLOATTLVERTEX       |
4199                                      WINED3DDEVCAPS_EXECUTESYSTEMMEMORY |
4200                                      WINED3DDEVCAPS_TLVERTEXSYSTEMMEMORY|
4201                                      WINED3DDEVCAPS_TLVERTEXVIDEOMEMORY |
4202                                      WINED3DDEVCAPS_DRAWPRIMTLVERTEX    |
4203                                      WINED3DDEVCAPS_HWTRANSFORMANDLIGHT |
4204                                      WINED3DDEVCAPS_EXECUTEVIDEOMEMORY  |
4205                                      WINED3DDEVCAPS_PUREDEVICE          |
4206                                      WINED3DDEVCAPS_HWRASTERIZATION     |
4207                                      WINED3DDEVCAPS_TEXTUREVIDEOMEMORY  |
4208                                      WINED3DDEVCAPS_TEXTURESYSTEMMEMORY |
4209                                      WINED3DDEVCAPS_CANRENDERAFTERFLIP  |
4210                                      WINED3DDEVCAPS_DRAWPRIMITIVES2     |
4211                                      WINED3DDEVCAPS_DRAWPRIMITIVES2EX   |
4212                                      WINED3DDEVCAPS_RTPATCHES;
4213
4214     pCaps->PrimitiveMiscCaps       = WINED3DPMISCCAPS_CULLNONE              |
4215                                      WINED3DPMISCCAPS_CULLCCW               |
4216                                      WINED3DPMISCCAPS_CULLCW                |
4217                                      WINED3DPMISCCAPS_COLORWRITEENABLE      |
4218                                      WINED3DPMISCCAPS_CLIPTLVERTS           |
4219                                      WINED3DPMISCCAPS_CLIPPLANESCALEDPOINTS |
4220                                      WINED3DPMISCCAPS_MASKZ                 |
4221                                      WINED3DPMISCCAPS_BLENDOP               |
4222                                      WINED3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING;
4223                                     /* TODO:
4224                                         WINED3DPMISCCAPS_NULLREFERENCE
4225                                         WINED3DPMISCCAPS_FOGANDSPECULARALPHA
4226                                         WINED3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS
4227                                         WINED3DPMISCCAPS_FOGVERTEXCLAMPED */
4228
4229     if (gl_info->supported[EXT_BLEND_EQUATION_SEPARATE] && gl_info->supported[EXT_BLEND_FUNC_SEPARATE])
4230         pCaps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_SEPARATEALPHABLEND;
4231     if (gl_info->supported[EXT_DRAW_BUFFERS2])
4232         pCaps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_INDEPENDENTWRITEMASKS;
4233
4234     pCaps->RasterCaps              = WINED3DPRASTERCAPS_DITHER    |
4235                                      WINED3DPRASTERCAPS_PAT       |
4236                                      WINED3DPRASTERCAPS_WFOG      |
4237                                      WINED3DPRASTERCAPS_ZFOG      |
4238                                      WINED3DPRASTERCAPS_FOGVERTEX |
4239                                      WINED3DPRASTERCAPS_FOGTABLE  |
4240                                      WINED3DPRASTERCAPS_STIPPLE   |
4241                                      WINED3DPRASTERCAPS_SUBPIXEL  |
4242                                      WINED3DPRASTERCAPS_ZTEST     |
4243                                      WINED3DPRASTERCAPS_SCISSORTEST   |
4244                                      WINED3DPRASTERCAPS_SLOPESCALEDEPTHBIAS |
4245                                      WINED3DPRASTERCAPS_DEPTHBIAS;
4246
4247     if (gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC])
4248     {
4249         pCaps->RasterCaps |= WINED3DPRASTERCAPS_ANISOTROPY    |
4250                              WINED3DPRASTERCAPS_ZBIAS         |
4251                              WINED3DPRASTERCAPS_MIPMAPLODBIAS;
4252     }
4253     if (gl_info->supported[NV_FOG_DISTANCE])
4254     {
4255         pCaps->RasterCaps         |= WINED3DPRASTERCAPS_FOGRANGE;
4256     }
4257                         /* FIXME Add:
4258                            WINED3DPRASTERCAPS_COLORPERSPECTIVE
4259                            WINED3DPRASTERCAPS_STRETCHBLTMULTISAMPLE
4260                            WINED3DPRASTERCAPS_ANTIALIASEDGES
4261                            WINED3DPRASTERCAPS_ZBUFFERLESSHSR
4262                            WINED3DPRASTERCAPS_WBUFFER */
4263
4264     pCaps->ZCmpCaps = WINED3DPCMPCAPS_ALWAYS       |
4265                       WINED3DPCMPCAPS_EQUAL        |
4266                       WINED3DPCMPCAPS_GREATER      |
4267                       WINED3DPCMPCAPS_GREATEREQUAL |
4268                       WINED3DPCMPCAPS_LESS         |
4269                       WINED3DPCMPCAPS_LESSEQUAL    |
4270                       WINED3DPCMPCAPS_NEVER        |
4271                       WINED3DPCMPCAPS_NOTEQUAL;
4272
4273     pCaps->SrcBlendCaps  = WINED3DPBLENDCAPS_BOTHINVSRCALPHA |
4274                            WINED3DPBLENDCAPS_BOTHSRCALPHA    |
4275                            WINED3DPBLENDCAPS_DESTALPHA       |
4276                            WINED3DPBLENDCAPS_DESTCOLOR       |
4277                            WINED3DPBLENDCAPS_INVDESTALPHA    |
4278                            WINED3DPBLENDCAPS_INVDESTCOLOR    |
4279                            WINED3DPBLENDCAPS_INVSRCALPHA     |
4280                            WINED3DPBLENDCAPS_INVSRCCOLOR     |
4281                            WINED3DPBLENDCAPS_ONE             |
4282                            WINED3DPBLENDCAPS_SRCALPHA        |
4283                            WINED3DPBLENDCAPS_SRCALPHASAT     |
4284                            WINED3DPBLENDCAPS_SRCCOLOR        |
4285                            WINED3DPBLENDCAPS_ZERO;
4286
4287     pCaps->DestBlendCaps = WINED3DPBLENDCAPS_DESTALPHA       |
4288                            WINED3DPBLENDCAPS_DESTCOLOR       |
4289                            WINED3DPBLENDCAPS_INVDESTALPHA    |
4290                            WINED3DPBLENDCAPS_INVDESTCOLOR    |
4291                            WINED3DPBLENDCAPS_INVSRCALPHA     |
4292                            WINED3DPBLENDCAPS_INVSRCCOLOR     |
4293                            WINED3DPBLENDCAPS_ONE             |
4294                            WINED3DPBLENDCAPS_SRCALPHA        |
4295                            WINED3DPBLENDCAPS_SRCCOLOR        |
4296                            WINED3DPBLENDCAPS_ZERO;
4297     /* NOTE: WINED3DPBLENDCAPS_SRCALPHASAT is not supported as dest blend factor,
4298      * according to the glBlendFunc manpage
4299      *
4300      * WINED3DPBLENDCAPS_BOTHINVSRCALPHA and WINED3DPBLENDCAPS_BOTHSRCALPHA are
4301      * legacy settings for srcblend only
4302      */
4303
4304     if (gl_info->supported[EXT_BLEND_COLOR])
4305     {
4306         pCaps->SrcBlendCaps |= WINED3DPBLENDCAPS_BLENDFACTOR;
4307         pCaps->DestBlendCaps |= WINED3DPBLENDCAPS_BLENDFACTOR;
4308     }
4309
4310
4311     pCaps->AlphaCmpCaps = WINED3DPCMPCAPS_ALWAYS       |
4312                           WINED3DPCMPCAPS_EQUAL        |
4313                           WINED3DPCMPCAPS_GREATER      |
4314                           WINED3DPCMPCAPS_GREATEREQUAL |
4315                           WINED3DPCMPCAPS_LESS         |
4316                           WINED3DPCMPCAPS_LESSEQUAL    |
4317                           WINED3DPCMPCAPS_NEVER        |
4318                           WINED3DPCMPCAPS_NOTEQUAL;
4319
4320     pCaps->ShadeCaps     = WINED3DPSHADECAPS_SPECULARGOURAUDRGB |
4321                            WINED3DPSHADECAPS_COLORGOURAUDRGB    |
4322                            WINED3DPSHADECAPS_ALPHAFLATBLEND     |
4323                            WINED3DPSHADECAPS_ALPHAGOURAUDBLEND  |
4324                            WINED3DPSHADECAPS_COLORFLATRGB       |
4325                            WINED3DPSHADECAPS_FOGFLAT            |
4326                            WINED3DPSHADECAPS_FOGGOURAUD         |
4327                            WINED3DPSHADECAPS_SPECULARFLATRGB;
4328
4329     pCaps->TextureCaps =  WINED3DPTEXTURECAPS_ALPHA              |
4330                           WINED3DPTEXTURECAPS_ALPHAPALETTE       |
4331                           WINED3DPTEXTURECAPS_TRANSPARENCY       |
4332                           WINED3DPTEXTURECAPS_BORDER             |
4333                           WINED3DPTEXTURECAPS_MIPMAP             |
4334                           WINED3DPTEXTURECAPS_PROJECTED          |
4335                           WINED3DPTEXTURECAPS_PERSPECTIVE;
4336
4337     if (!gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO])
4338     {
4339         pCaps->TextureCaps |= WINED3DPTEXTURECAPS_POW2 |
4340                               WINED3DPTEXTURECAPS_NONPOW2CONDITIONAL;
4341     }
4342
4343     if (gl_info->supported[EXT_TEXTURE3D])
4344     {
4345         pCaps->TextureCaps |=  WINED3DPTEXTURECAPS_VOLUMEMAP      |
4346                                WINED3DPTEXTURECAPS_MIPVOLUMEMAP   |
4347                                WINED3DPTEXTURECAPS_VOLUMEMAP_POW2;
4348     }
4349
4350     if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
4351     {
4352         pCaps->TextureCaps |= WINED3DPTEXTURECAPS_CUBEMAP     |
4353                               WINED3DPTEXTURECAPS_MIPCUBEMAP    |
4354                               WINED3DPTEXTURECAPS_CUBEMAP_POW2;
4355
4356     }
4357
4358     pCaps->TextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR       |
4359                                WINED3DPTFILTERCAPS_MAGFPOINT        |
4360                                WINED3DPTFILTERCAPS_MINFLINEAR       |
4361                                WINED3DPTFILTERCAPS_MINFPOINT        |
4362                                WINED3DPTFILTERCAPS_MIPFLINEAR       |
4363                                WINED3DPTFILTERCAPS_MIPFPOINT        |
4364                                WINED3DPTFILTERCAPS_LINEAR           |
4365                                WINED3DPTFILTERCAPS_LINEARMIPLINEAR  |
4366                                WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
4367                                WINED3DPTFILTERCAPS_MIPLINEAR        |
4368                                WINED3DPTFILTERCAPS_MIPNEAREST       |
4369                                WINED3DPTFILTERCAPS_NEAREST;
4370
4371     if (gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC])
4372     {
4373         pCaps->TextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC |
4374                                     WINED3DPTFILTERCAPS_MINFANISOTROPIC;
4375     }
4376
4377     if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
4378     {
4379         pCaps->CubeTextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR       |
4380                                        WINED3DPTFILTERCAPS_MAGFPOINT        |
4381                                        WINED3DPTFILTERCAPS_MINFLINEAR       |
4382                                        WINED3DPTFILTERCAPS_MINFPOINT        |
4383                                        WINED3DPTFILTERCAPS_MIPFLINEAR       |
4384                                        WINED3DPTFILTERCAPS_MIPFPOINT        |
4385                                        WINED3DPTFILTERCAPS_LINEAR           |
4386                                        WINED3DPTFILTERCAPS_LINEARMIPLINEAR  |
4387                                        WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
4388                                        WINED3DPTFILTERCAPS_MIPLINEAR        |
4389                                        WINED3DPTFILTERCAPS_MIPNEAREST       |
4390                                        WINED3DPTFILTERCAPS_NEAREST;
4391
4392         if (gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC])
4393         {
4394             pCaps->CubeTextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC |
4395                                             WINED3DPTFILTERCAPS_MINFANISOTROPIC;
4396         }
4397     } else
4398         pCaps->CubeTextureFilterCaps = 0;
4399
4400     if (gl_info->supported[EXT_TEXTURE3D])
4401     {
4402         pCaps->VolumeTextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR       |
4403                                          WINED3DPTFILTERCAPS_MAGFPOINT        |
4404                                          WINED3DPTFILTERCAPS_MINFLINEAR       |
4405                                          WINED3DPTFILTERCAPS_MINFPOINT        |
4406                                          WINED3DPTFILTERCAPS_MIPFLINEAR       |
4407                                          WINED3DPTFILTERCAPS_MIPFPOINT        |
4408                                          WINED3DPTFILTERCAPS_LINEAR           |
4409                                          WINED3DPTFILTERCAPS_LINEARMIPLINEAR  |
4410                                          WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
4411                                          WINED3DPTFILTERCAPS_MIPLINEAR        |
4412                                          WINED3DPTFILTERCAPS_MIPNEAREST       |
4413                                          WINED3DPTFILTERCAPS_NEAREST;
4414     } else
4415         pCaps->VolumeTextureFilterCaps = 0;
4416
4417     pCaps->TextureAddressCaps =  WINED3DPTADDRESSCAPS_INDEPENDENTUV |
4418                                  WINED3DPTADDRESSCAPS_CLAMP  |
4419                                  WINED3DPTADDRESSCAPS_WRAP;
4420
4421     if (gl_info->supported[ARB_TEXTURE_BORDER_CLAMP])
4422     {
4423         pCaps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_BORDER;
4424     }
4425     if (gl_info->supported[ARB_TEXTURE_MIRRORED_REPEAT])
4426     {
4427         pCaps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRROR;
4428     }
4429     if (gl_info->supported[ATI_TEXTURE_MIRROR_ONCE])
4430     {
4431         pCaps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRRORONCE;
4432     }
4433
4434     if (gl_info->supported[EXT_TEXTURE3D])
4435     {
4436         pCaps->VolumeTextureAddressCaps =  WINED3DPTADDRESSCAPS_INDEPENDENTUV |
4437                                            WINED3DPTADDRESSCAPS_CLAMP  |
4438                                            WINED3DPTADDRESSCAPS_WRAP;
4439         if (gl_info->supported[ARB_TEXTURE_BORDER_CLAMP])
4440         {
4441             pCaps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_BORDER;
4442         }
4443         if (gl_info->supported[ARB_TEXTURE_MIRRORED_REPEAT])
4444         {
4445             pCaps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRROR;
4446         }
4447         if (gl_info->supported[ATI_TEXTURE_MIRROR_ONCE])
4448         {
4449             pCaps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRRORONCE;
4450         }
4451     } else
4452         pCaps->VolumeTextureAddressCaps = 0;
4453
4454     pCaps->LineCaps = WINED3DLINECAPS_TEXTURE       |
4455                       WINED3DLINECAPS_ZTEST         |
4456                       WINED3DLINECAPS_BLEND         |
4457                       WINED3DLINECAPS_ALPHACMP      |
4458                       WINED3DLINECAPS_FOG;
4459     /* WINED3DLINECAPS_ANTIALIAS is not supported on Windows, and dx and gl seem to have a different
4460      * idea how generating the smoothing alpha values works; the result is different
4461      */
4462
4463     pCaps->MaxTextureWidth = gl_info->limits.texture_size;
4464     pCaps->MaxTextureHeight = gl_info->limits.texture_size;
4465
4466     if (gl_info->supported[EXT_TEXTURE3D])
4467         pCaps->MaxVolumeExtent = gl_info->limits.texture3d_size;
4468     else
4469         pCaps->MaxVolumeExtent = 0;
4470
4471     pCaps->MaxTextureRepeat = 32768;
4472     pCaps->MaxTextureAspectRatio = gl_info->limits.texture_size;
4473     pCaps->MaxVertexW = 1.0f;
4474
4475     pCaps->GuardBandLeft = 0.0f;
4476     pCaps->GuardBandTop = 0.0f;
4477     pCaps->GuardBandRight = 0.0f;
4478     pCaps->GuardBandBottom = 0.0f;
4479
4480     pCaps->ExtentsAdjust = 0.0f;
4481
4482     pCaps->StencilCaps =  WINED3DSTENCILCAPS_DECRSAT |
4483                           WINED3DSTENCILCAPS_INCRSAT |
4484                           WINED3DSTENCILCAPS_INVERT  |
4485                           WINED3DSTENCILCAPS_KEEP    |
4486                           WINED3DSTENCILCAPS_REPLACE |
4487                           WINED3DSTENCILCAPS_ZERO;
4488     if (gl_info->supported[EXT_STENCIL_WRAP])
4489     {
4490         pCaps->StencilCaps |= WINED3DSTENCILCAPS_DECR  |
4491                               WINED3DSTENCILCAPS_INCR;
4492     }
4493     if (gl_info->supported[EXT_STENCIL_TWO_SIDE] || gl_info->supported[ATI_SEPARATE_STENCIL])
4494     {
4495         pCaps->StencilCaps |= WINED3DSTENCILCAPS_TWOSIDED;
4496     }
4497
4498     pCaps->FVFCaps = WINED3DFVFCAPS_PSIZE | 0x0008; /* 8 texture coords */
4499
4500     pCaps->MaxUserClipPlanes = gl_info->limits.clipplanes;
4501     pCaps->MaxActiveLights = gl_info->limits.lights;
4502
4503     pCaps->MaxVertexBlendMatrices = gl_info->limits.blends;
4504     pCaps->MaxVertexBlendMatrixIndex   = 0;
4505
4506     pCaps->MaxAnisotropy = gl_info->limits.anisotropy;
4507     pCaps->MaxPointSize = gl_info->limits.pointsize_max;
4508
4509
4510     /* FIXME: Add D3DVTXPCAPS_TWEENING, D3DVTXPCAPS_TEXGEN_SPHEREMAP */
4511     pCaps->VertexProcessingCaps = WINED3DVTXPCAPS_DIRECTIONALLIGHTS |
4512                                   WINED3DVTXPCAPS_MATERIALSOURCE7   |
4513                                   WINED3DVTXPCAPS_POSITIONALLIGHTS  |
4514                                   WINED3DVTXPCAPS_LOCALVIEWER       |
4515                                   WINED3DVTXPCAPS_VERTEXFOG         |
4516                                   WINED3DVTXPCAPS_TEXGEN;
4517
4518     pCaps->MaxPrimitiveCount   = 0xFFFFF; /* For now set 2^20-1 which is used by most >=Geforce3/Radeon8500 cards */
4519     pCaps->MaxVertexIndex      = 0xFFFFF;
4520     pCaps->MaxStreams          = MAX_STREAMS;
4521     pCaps->MaxStreamStride     = 1024;
4522
4523     /* d3d9.dll sets D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES here because StretchRects is implemented in d3d9 */
4524     pCaps->DevCaps2                          = WINED3DDEVCAPS2_STREAMOFFSET |
4525                                                WINED3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET;
4526     pCaps->MaxNpatchTessellationLevel        = 0;
4527     pCaps->MasterAdapterOrdinal              = 0;
4528     pCaps->AdapterOrdinalInGroup             = 0;
4529     pCaps->NumberOfAdaptersInGroup           = 1;
4530
4531     pCaps->NumSimultaneousRTs = gl_info->limits.buffers;
4532
4533     pCaps->StretchRectFilterCaps             = WINED3DPTFILTERCAPS_MINFPOINT  |
4534                                                 WINED3DPTFILTERCAPS_MAGFPOINT  |
4535                                                 WINED3DPTFILTERCAPS_MINFLINEAR |
4536                                                 WINED3DPTFILTERCAPS_MAGFLINEAR;
4537     pCaps->VertexTextureFilterCaps           = 0;
4538
4539     adapter->shader_backend->shader_get_caps(&adapter->gl_info, &shader_caps);
4540     adapter->fragment_pipe->get_caps(&adapter->gl_info, &fragment_caps);
4541
4542     /* Add shader misc caps. Only some of them belong to the shader parts of the pipeline */
4543     pCaps->PrimitiveMiscCaps |= fragment_caps.PrimitiveMiscCaps;
4544
4545     /* This takes care for disabling vertex shader or pixel shader caps while leaving the other one enabled.
4546      * Ignore shader model capabilities if disabled in config
4547      */
4548     if(vs_selected_mode == SHADER_NONE) {
4549         TRACE_(d3d_caps)("Vertex shader disabled in config, reporting version 0.0\n");
4550         pCaps->VertexShaderVersion          = WINED3DVS_VERSION(0,0);
4551         pCaps->MaxVertexShaderConst         = 0;
4552     } else {
4553         pCaps->VertexShaderVersion          = shader_caps.VertexShaderVersion;
4554         pCaps->MaxVertexShaderConst         = shader_caps.MaxVertexShaderConst;
4555     }
4556
4557     if(ps_selected_mode == SHADER_NONE) {
4558         TRACE_(d3d_caps)("Pixel shader disabled in config, reporting version 0.0\n");
4559         pCaps->PixelShaderVersion           = WINED3DPS_VERSION(0,0);
4560         pCaps->PixelShader1xMaxValue        = 0.0f;
4561     } else {
4562         pCaps->PixelShaderVersion           = shader_caps.PixelShaderVersion;
4563         pCaps->PixelShader1xMaxValue        = shader_caps.PixelShader1xMaxValue;
4564     }
4565
4566     pCaps->TextureOpCaps                    = fragment_caps.TextureOpCaps;
4567     pCaps->MaxTextureBlendStages            = fragment_caps.MaxTextureBlendStages;
4568     pCaps->MaxSimultaneousTextures          = fragment_caps.MaxSimultaneousTextures;
4569
4570     /* The following caps are shader specific, but they are things we cannot detect, or which
4571      * are the same among all shader models. So to avoid code duplication set the shader version
4572      * specific, but otherwise constant caps here
4573      */
4574     if(pCaps->VertexShaderVersion == WINED3DVS_VERSION(3,0)) {
4575         /* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering)
4576         use the VS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum VS3.0 value. */
4577         pCaps->VS20Caps.Caps                     = WINED3DVS20CAPS_PREDICATION;
4578         pCaps->VS20Caps.DynamicFlowControlDepth  = WINED3DVS20_MAX_DYNAMICFLOWCONTROLDEPTH; /* VS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
4579         pCaps->VS20Caps.NumTemps = max(32, adapter->gl_info.limits.arb_vs_temps);
4580         pCaps->VS20Caps.StaticFlowControlDepth   = WINED3DVS20_MAX_STATICFLOWCONTROLDEPTH ; /* level of nesting in loops / if-statements; VS 3.0 requires MAX (4) */
4581
4582         pCaps->MaxVShaderInstructionsExecuted    = 65535; /* VS 3.0 needs at least 65535, some cards even use 2^32-1 */
4583         pCaps->MaxVertexShader30InstructionSlots = max(512, adapter->gl_info.limits.arb_vs_instructions);
4584     }
4585     else if (pCaps->VertexShaderVersion == WINED3DVS_VERSION(2,0))
4586     {
4587         pCaps->VS20Caps.Caps                     = 0;
4588         pCaps->VS20Caps.DynamicFlowControlDepth  = WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH;
4589         pCaps->VS20Caps.NumTemps = max(12, adapter->gl_info.limits.arb_vs_temps);
4590         pCaps->VS20Caps.StaticFlowControlDepth   = 1;
4591
4592         pCaps->MaxVShaderInstructionsExecuted    = 65535;
4593         pCaps->MaxVertexShader30InstructionSlots = 0;
4594     } else { /* VS 1.x */
4595         pCaps->VS20Caps.Caps                     = 0;
4596         pCaps->VS20Caps.DynamicFlowControlDepth  = 0;
4597         pCaps->VS20Caps.NumTemps                 = 0;
4598         pCaps->VS20Caps.StaticFlowControlDepth   = 0;
4599
4600         pCaps->MaxVShaderInstructionsExecuted    = 0;
4601         pCaps->MaxVertexShader30InstructionSlots = 0;
4602     }
4603
4604     if(pCaps->PixelShaderVersion == WINED3DPS_VERSION(3,0)) {
4605         /* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering)
4606         use the PS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum PS 3.0 value. */
4607
4608         /* 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 */
4609         pCaps->PS20Caps.Caps                     = WINED3DPS20CAPS_ARBITRARYSWIZZLE     |
4610                 WINED3DPS20CAPS_GRADIENTINSTRUCTIONS |
4611                 WINED3DPS20CAPS_PREDICATION          |
4612                 WINED3DPS20CAPS_NODEPENDENTREADLIMIT |
4613                 WINED3DPS20CAPS_NOTEXINSTRUCTIONLIMIT;
4614         pCaps->PS20Caps.DynamicFlowControlDepth  = WINED3DPS20_MAX_DYNAMICFLOWCONTROLDEPTH; /* PS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
4615         pCaps->PS20Caps.NumTemps = max(32, adapter->gl_info.limits.arb_ps_temps);
4616         pCaps->PS20Caps.StaticFlowControlDepth   = WINED3DPS20_MAX_STATICFLOWCONTROLDEPTH; /* PS 3.0 requires MAX_STATICFLOWCONTROLDEPTH (4) */
4617         pCaps->PS20Caps.NumInstructionSlots      = WINED3DPS20_MAX_NUMINSTRUCTIONSLOTS; /* PS 3.0 requires MAX_NUMINSTRUCTIONSLOTS (512) */
4618
4619         pCaps->MaxPShaderInstructionsExecuted    = 65535;
4620         pCaps->MaxPixelShader30InstructionSlots = max(WINED3DMIN30SHADERINSTRUCTIONS,
4621                 adapter->gl_info.limits.arb_ps_instructions);
4622     }
4623     else if(pCaps->PixelShaderVersion == WINED3DPS_VERSION(2,0))
4624     {
4625         /* Below we assume PS2.0 specs, not extended 2.0a(GeforceFX)/2.0b(Radeon R3xx) ones */
4626         pCaps->PS20Caps.Caps                     = 0;
4627         pCaps->PS20Caps.DynamicFlowControlDepth  = 0; /* WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH = 0 */
4628         pCaps->PS20Caps.NumTemps = max(12, adapter->gl_info.limits.arb_ps_temps);
4629         pCaps->PS20Caps.StaticFlowControlDepth   = WINED3DPS20_MIN_STATICFLOWCONTROLDEPTH; /* Minimum: 1 */
4630         pCaps->PS20Caps.NumInstructionSlots      = WINED3DPS20_MIN_NUMINSTRUCTIONSLOTS; /* Minimum number (64 ALU + 32 Texture), a GeforceFX uses 512 */
4631
4632         pCaps->MaxPShaderInstructionsExecuted    = 512; /* Minimum value, a GeforceFX uses 1024 */
4633         pCaps->MaxPixelShader30InstructionSlots  = 0;
4634     } else { /* PS 1.x */
4635         pCaps->PS20Caps.Caps                     = 0;
4636         pCaps->PS20Caps.DynamicFlowControlDepth  = 0;
4637         pCaps->PS20Caps.NumTemps                 = 0;
4638         pCaps->PS20Caps.StaticFlowControlDepth   = 0;
4639         pCaps->PS20Caps.NumInstructionSlots      = 0;
4640
4641         pCaps->MaxPShaderInstructionsExecuted    = 0;
4642         pCaps->MaxPixelShader30InstructionSlots  = 0;
4643     }
4644
4645     if(pCaps->VertexShaderVersion >= WINED3DVS_VERSION(2,0)) {
4646         /* OpenGL supports all the formats below, perhaps not always
4647          * without conversion, but it supports them.
4648          * Further GLSL doesn't seem to have an official unsigned type so
4649          * don't advertise it yet as I'm not sure how we handle it.
4650          * We might need to add some clamping in the shader engine to
4651          * support it.
4652          * TODO: WINED3DDTCAPS_USHORT2N, WINED3DDTCAPS_USHORT4N, WINED3DDTCAPS_UDEC3, WINED3DDTCAPS_DEC3N */
4653         pCaps->DeclTypes = WINED3DDTCAPS_UBYTE4    |
4654                            WINED3DDTCAPS_UBYTE4N   |
4655                            WINED3DDTCAPS_SHORT2N   |
4656                            WINED3DDTCAPS_SHORT4N;
4657         if (gl_info->supported[ARB_HALF_FLOAT_VERTEX])
4658         {
4659             pCaps->DeclTypes |= WINED3DDTCAPS_FLOAT16_2 |
4660                                 WINED3DDTCAPS_FLOAT16_4;
4661         }
4662     } else
4663         pCaps->DeclTypes                         = 0;
4664
4665     /* Set DirectDraw helper Caps */
4666     ckey_caps =                         WINEDDCKEYCAPS_DESTBLT              |
4667                                         WINEDDCKEYCAPS_SRCBLT;
4668     fx_caps =                           WINEDDFXCAPS_BLTALPHA               |
4669                                         WINEDDFXCAPS_BLTMIRRORLEFTRIGHT     |
4670                                         WINEDDFXCAPS_BLTMIRRORUPDOWN        |
4671                                         WINEDDFXCAPS_BLTROTATION90          |
4672                                         WINEDDFXCAPS_BLTSHRINKX             |
4673                                         WINEDDFXCAPS_BLTSHRINKXN            |
4674                                         WINEDDFXCAPS_BLTSHRINKY             |
4675                                         WINEDDFXCAPS_BLTSHRINKXN            |
4676                                         WINEDDFXCAPS_BLTSTRETCHX            |
4677                                         WINEDDFXCAPS_BLTSTRETCHXN           |
4678                                         WINEDDFXCAPS_BLTSTRETCHY            |
4679                                         WINEDDFXCAPS_BLTSTRETCHYN;
4680     blit_caps =                         WINEDDCAPS_BLT                      |
4681                                         WINEDDCAPS_BLTCOLORFILL             |
4682                                         WINEDDCAPS_BLTDEPTHFILL             |
4683                                         WINEDDCAPS_BLTSTRETCH               |
4684                                         WINEDDCAPS_CANBLTSYSMEM             |
4685                                         WINEDDCAPS_CANCLIP                  |
4686                                         WINEDDCAPS_CANCLIPSTRETCHED         |
4687                                         WINEDDCAPS_COLORKEY                 |
4688                                         WINEDDCAPS_COLORKEYHWASSIST         |
4689                                         WINEDDCAPS_ALIGNBOUNDARYSRC;
4690     pal_caps =                          WINEDDPCAPS_8BIT                    |
4691                                         WINEDDPCAPS_PRIMARYSURFACE;
4692
4693     /* Fill the ddraw caps structure */
4694     pCaps->DirectDrawCaps.Caps =        WINEDDCAPS_GDI                      |
4695                                         WINEDDCAPS_PALETTE                  |
4696                                         blit_caps;
4697     pCaps->DirectDrawCaps.Caps2 =       WINEDDCAPS2_CERTIFIED                |
4698                                         WINEDDCAPS2_NOPAGELOCKREQUIRED       |
4699                                         WINEDDCAPS2_PRIMARYGAMMA             |
4700                                         WINEDDCAPS2_WIDESURFACES             |
4701                                         WINEDDCAPS2_CANRENDERWINDOWED;
4702     pCaps->DirectDrawCaps.CKeyCaps =    ckey_caps;
4703     pCaps->DirectDrawCaps.FXCaps =      fx_caps;
4704     pCaps->DirectDrawCaps.PalCaps =     pal_caps;
4705     pCaps->DirectDrawCaps.SVBCaps =     blit_caps;
4706     pCaps->DirectDrawCaps.SVBCKeyCaps = ckey_caps;
4707     pCaps->DirectDrawCaps.SVBFXCaps =   fx_caps;
4708     pCaps->DirectDrawCaps.VSBCaps =     blit_caps;
4709     pCaps->DirectDrawCaps.VSBCKeyCaps = ckey_caps;
4710     pCaps->DirectDrawCaps.VSBFXCaps =   fx_caps;
4711     pCaps->DirectDrawCaps.SSBCaps =     blit_caps;
4712     pCaps->DirectDrawCaps.SSBCKeyCaps = ckey_caps;
4713     pCaps->DirectDrawCaps.SSBFXCaps =   fx_caps;
4714
4715     pCaps->DirectDrawCaps.ddsCaps =     WINEDDSCAPS_ALPHA                   |
4716                                         WINEDDSCAPS_BACKBUFFER              |
4717                                         WINEDDSCAPS_FLIP                    |
4718                                         WINEDDSCAPS_FRONTBUFFER             |
4719                                         WINEDDSCAPS_OFFSCREENPLAIN          |
4720                                         WINEDDSCAPS_PALETTE                 |
4721                                         WINEDDSCAPS_PRIMARYSURFACE          |
4722                                         WINEDDSCAPS_SYSTEMMEMORY            |
4723                                         WINEDDSCAPS_VIDEOMEMORY             |
4724                                         WINEDDSCAPS_VISIBLE;
4725     pCaps->DirectDrawCaps.StrideAlign = DDRAW_PITCH_ALIGNMENT;
4726
4727     /* Set D3D caps if OpenGL is available. */
4728     if (adapter->opengl)
4729     {
4730         pCaps->DirectDrawCaps.ddsCaps |=WINEDDSCAPS_3DDEVICE                |
4731                                         WINEDDSCAPS_MIPMAP                  |
4732                                         WINEDDSCAPS_TEXTURE                 |
4733                                         WINEDDSCAPS_ZBUFFER;
4734         pCaps->DirectDrawCaps.Caps |=   WINEDDCAPS_3D;
4735     }
4736
4737     return WINED3D_OK;
4738 }
4739
4740 static HRESULT WINAPI IWineD3DImpl_CreateDevice(IWineD3D *iface, UINT adapter_idx, WINED3DDEVTYPE device_type,
4741         HWND focus_window, DWORD flags, IWineD3DDeviceParent *device_parent, IWineD3DDevice **device)
4742 {
4743     IWineD3DImpl *This = (IWineD3DImpl *)iface;
4744     IWineD3DDeviceImpl *object;
4745     HRESULT hr;
4746
4747     TRACE("iface %p, adapter_idx %u, device_type %#x, focus_window %p, flags %#x, device_parent %p, device %p.\n",
4748             iface, adapter_idx, device_type, focus_window, flags, device_parent, device);
4749
4750     /* Validate the adapter number. If no adapters are available(no GL), ignore the adapter
4751      * number and create a device without a 3D adapter for 2D only operation. */
4752     if (IWineD3D_GetAdapterCount(iface) && adapter_idx >= IWineD3D_GetAdapterCount(iface))
4753     {
4754         return WINED3DERR_INVALIDCALL;
4755     }
4756
4757     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
4758     if (!object)
4759     {
4760         ERR("Failed to allocate device memory.\n");
4761         return E_OUTOFMEMORY;
4762     }
4763
4764     hr = device_init(object, This, adapter_idx, device_type, focus_window, flags, device_parent);
4765     if (FAILED(hr))
4766     {
4767         WARN("Failed to initialize device, hr %#x.\n", hr);
4768         HeapFree(GetProcessHeap(), 0, object);
4769         return hr;
4770     }
4771
4772     TRACE("Created device %p.\n", object);
4773     *device = (IWineD3DDevice *)object;
4774
4775     IWineD3DDeviceParent_WineD3DDeviceCreated(device_parent, *device);
4776
4777     return WINED3D_OK;
4778 }
4779
4780 static void * WINAPI IWineD3DImpl_GetParent(IWineD3D *iface)
4781 {
4782     TRACE("iface %p.\n", iface);
4783
4784     return ((IWineD3DImpl *)iface)->parent;
4785 }
4786
4787 static void WINE_GLAPI invalid_func(const void *data)
4788 {
4789     ERR("Invalid vertex attribute function called\n");
4790     DebugBreak();
4791 }
4792
4793 static void WINE_GLAPI invalid_texcoord_func(GLenum unit, const void *data)
4794 {
4795     ERR("Invalid texcoord function called\n");
4796     DebugBreak();
4797 }
4798
4799 /* Helper functions for providing vertex data to opengl. The arrays are initialized based on
4800  * the extension detection and are used in drawStridedSlow
4801  */
4802 static void WINE_GLAPI position_d3dcolor(const void *data)
4803 {
4804     DWORD pos = *((const DWORD *)data);
4805
4806     FIXME("Add a test for fixed function position from d3dcolor type\n");
4807     glVertex4s(D3DCOLOR_B_R(pos),
4808                D3DCOLOR_B_G(pos),
4809                D3DCOLOR_B_B(pos),
4810                D3DCOLOR_B_A(pos));
4811 }
4812
4813 static void WINE_GLAPI position_float4(const void *data)
4814 {
4815     const GLfloat *pos = data;
4816
4817     if (pos[3] != 0.0f && pos[3] != 1.0f)
4818     {
4819         float w = 1.0f / pos[3];
4820
4821         glVertex4f(pos[0] * w, pos[1] * w, pos[2] * w, w);
4822     }
4823     else
4824     {
4825         glVertex3fv(pos);
4826     }
4827 }
4828
4829 static void WINE_GLAPI diffuse_d3dcolor(const void *data)
4830 {
4831     DWORD diffuseColor = *((const DWORD *)data);
4832
4833     glColor4ub(D3DCOLOR_B_R(diffuseColor),
4834                D3DCOLOR_B_G(diffuseColor),
4835                D3DCOLOR_B_B(diffuseColor),
4836                D3DCOLOR_B_A(diffuseColor));
4837 }
4838
4839 static void WINE_GLAPI specular_d3dcolor(const void *data)
4840 {
4841     DWORD specularColor = *((const DWORD *)data);
4842     GLbyte d[] = {D3DCOLOR_B_R(specularColor),
4843             D3DCOLOR_B_G(specularColor),
4844             D3DCOLOR_B_B(specularColor)};
4845
4846     specular_func_3ubv(d);
4847 }
4848
4849 static void WINE_GLAPI warn_no_specular_func(const void *data)
4850 {
4851     WARN("GL_EXT_secondary_color not supported\n");
4852 }
4853
4854 static void fillGLAttribFuncs(const struct wined3d_gl_info *gl_info)
4855 {
4856     position_funcs[WINED3D_FFP_EMIT_FLOAT1]      = invalid_func;
4857     position_funcs[WINED3D_FFP_EMIT_FLOAT2]      = invalid_func;
4858     position_funcs[WINED3D_FFP_EMIT_FLOAT3]      = (glAttribFunc)glVertex3fv;
4859     position_funcs[WINED3D_FFP_EMIT_FLOAT4]      = position_float4;
4860     position_funcs[WINED3D_FFP_EMIT_D3DCOLOR]    = position_d3dcolor;
4861     position_funcs[WINED3D_FFP_EMIT_UBYTE4]      = invalid_func;
4862     position_funcs[WINED3D_FFP_EMIT_SHORT2]      = invalid_func;
4863     position_funcs[WINED3D_FFP_EMIT_SHORT4]      = (glAttribFunc)glVertex2sv;
4864     position_funcs[WINED3D_FFP_EMIT_UBYTE4N]     = invalid_func;
4865     position_funcs[WINED3D_FFP_EMIT_SHORT2N]     = invalid_func;
4866     position_funcs[WINED3D_FFP_EMIT_SHORT4N]     = invalid_func;
4867     position_funcs[WINED3D_FFP_EMIT_USHORT2N]    = invalid_func;
4868     position_funcs[WINED3D_FFP_EMIT_USHORT4N]    = invalid_func;
4869     position_funcs[WINED3D_FFP_EMIT_UDEC3]       = invalid_func;
4870     position_funcs[WINED3D_FFP_EMIT_DEC3N]       = invalid_func;
4871     position_funcs[WINED3D_FFP_EMIT_FLOAT16_2]   = invalid_func;
4872     position_funcs[WINED3D_FFP_EMIT_FLOAT16_4]   = invalid_func;
4873
4874     diffuse_funcs[WINED3D_FFP_EMIT_FLOAT1]       = invalid_func;
4875     diffuse_funcs[WINED3D_FFP_EMIT_FLOAT2]       = invalid_func;
4876     diffuse_funcs[WINED3D_FFP_EMIT_FLOAT3]       = (glAttribFunc)glColor3fv;
4877     diffuse_funcs[WINED3D_FFP_EMIT_FLOAT4]       = (glAttribFunc)glColor4fv;
4878     diffuse_funcs[WINED3D_FFP_EMIT_D3DCOLOR]     = diffuse_d3dcolor;
4879     diffuse_funcs[WINED3D_FFP_EMIT_UBYTE4]       = invalid_func;
4880     diffuse_funcs[WINED3D_FFP_EMIT_SHORT2]       = invalid_func;
4881     diffuse_funcs[WINED3D_FFP_EMIT_SHORT4]       = invalid_func;
4882     diffuse_funcs[WINED3D_FFP_EMIT_UBYTE4N]      = (glAttribFunc)glColor4ubv;
4883     diffuse_funcs[WINED3D_FFP_EMIT_SHORT2N]      = invalid_func;
4884     diffuse_funcs[WINED3D_FFP_EMIT_SHORT4N]      = (glAttribFunc)glColor4sv;
4885     diffuse_funcs[WINED3D_FFP_EMIT_USHORT2N]     = invalid_func;
4886     diffuse_funcs[WINED3D_FFP_EMIT_USHORT4N]     = (glAttribFunc)glColor4usv;
4887     diffuse_funcs[WINED3D_FFP_EMIT_UDEC3]        = invalid_func;
4888     diffuse_funcs[WINED3D_FFP_EMIT_DEC3N]        = invalid_func;
4889     diffuse_funcs[WINED3D_FFP_EMIT_FLOAT16_2]    = invalid_func;
4890     diffuse_funcs[WINED3D_FFP_EMIT_FLOAT16_4]    = invalid_func;
4891
4892     /* No 4 component entry points here */
4893     specular_funcs[WINED3D_FFP_EMIT_FLOAT1]      = invalid_func;
4894     specular_funcs[WINED3D_FFP_EMIT_FLOAT2]      = invalid_func;
4895     if (gl_info->supported[EXT_SECONDARY_COLOR])
4896     {
4897         specular_funcs[WINED3D_FFP_EMIT_FLOAT3]  = (glAttribFunc)GL_EXTCALL(glSecondaryColor3fvEXT);
4898     }
4899     else
4900     {
4901         specular_funcs[WINED3D_FFP_EMIT_FLOAT3]  = warn_no_specular_func;
4902     }
4903     specular_funcs[WINED3D_FFP_EMIT_FLOAT4]      = invalid_func;
4904     if (gl_info->supported[EXT_SECONDARY_COLOR])
4905     {
4906         specular_func_3ubv = (glAttribFunc)GL_EXTCALL(glSecondaryColor3ubvEXT);
4907         specular_funcs[WINED3D_FFP_EMIT_D3DCOLOR] = specular_d3dcolor;
4908     }
4909     else
4910     {
4911         specular_funcs[WINED3D_FFP_EMIT_D3DCOLOR] = warn_no_specular_func;
4912     }
4913     specular_funcs[WINED3D_FFP_EMIT_UBYTE4]      = invalid_func;
4914     specular_funcs[WINED3D_FFP_EMIT_SHORT2]      = invalid_func;
4915     specular_funcs[WINED3D_FFP_EMIT_SHORT4]      = invalid_func;
4916     specular_funcs[WINED3D_FFP_EMIT_UBYTE4N]     = invalid_func;
4917     specular_funcs[WINED3D_FFP_EMIT_SHORT2N]     = invalid_func;
4918     specular_funcs[WINED3D_FFP_EMIT_SHORT4N]     = invalid_func;
4919     specular_funcs[WINED3D_FFP_EMIT_USHORT2N]    = invalid_func;
4920     specular_funcs[WINED3D_FFP_EMIT_USHORT4N]    = invalid_func;
4921     specular_funcs[WINED3D_FFP_EMIT_UDEC3]       = invalid_func;
4922     specular_funcs[WINED3D_FFP_EMIT_DEC3N]       = invalid_func;
4923     specular_funcs[WINED3D_FFP_EMIT_FLOAT16_2]   = invalid_func;
4924     specular_funcs[WINED3D_FFP_EMIT_FLOAT16_4]   = invalid_func;
4925
4926     /* Only 3 component entry points here. Test how others behave. Float4 normals are used
4927      * by one of our tests, trying to pass it to the pixel shader, which fails on Windows.
4928      */
4929     normal_funcs[WINED3D_FFP_EMIT_FLOAT1]         = invalid_func;
4930     normal_funcs[WINED3D_FFP_EMIT_FLOAT2]         = invalid_func;
4931     normal_funcs[WINED3D_FFP_EMIT_FLOAT3]         = (glAttribFunc)glNormal3fv;
4932     normal_funcs[WINED3D_FFP_EMIT_FLOAT4]         = (glAttribFunc)glNormal3fv; /* Just ignore the 4th value */
4933     normal_funcs[WINED3D_FFP_EMIT_D3DCOLOR]       = invalid_func;
4934     normal_funcs[WINED3D_FFP_EMIT_UBYTE4]         = invalid_func;
4935     normal_funcs[WINED3D_FFP_EMIT_SHORT2]         = invalid_func;
4936     normal_funcs[WINED3D_FFP_EMIT_SHORT4]         = invalid_func;
4937     normal_funcs[WINED3D_FFP_EMIT_UBYTE4N]        = invalid_func;
4938     normal_funcs[WINED3D_FFP_EMIT_SHORT2N]        = invalid_func;
4939     normal_funcs[WINED3D_FFP_EMIT_SHORT4N]        = invalid_func;
4940     normal_funcs[WINED3D_FFP_EMIT_USHORT2N]       = invalid_func;
4941     normal_funcs[WINED3D_FFP_EMIT_USHORT4N]       = invalid_func;
4942     normal_funcs[WINED3D_FFP_EMIT_UDEC3]          = invalid_func;
4943     normal_funcs[WINED3D_FFP_EMIT_DEC3N]          = invalid_func;
4944     normal_funcs[WINED3D_FFP_EMIT_FLOAT16_2]      = invalid_func;
4945     normal_funcs[WINED3D_FFP_EMIT_FLOAT16_4]      = invalid_func;
4946
4947     multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT1]    = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord1fvARB);
4948     multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT2]    = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord2fvARB);
4949     multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT3]    = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord3fvARB);
4950     multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT4]    = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord4fvARB);
4951     multi_texcoord_funcs[WINED3D_FFP_EMIT_D3DCOLOR]  = invalid_texcoord_func;
4952     multi_texcoord_funcs[WINED3D_FFP_EMIT_UBYTE4]    = invalid_texcoord_func;
4953     multi_texcoord_funcs[WINED3D_FFP_EMIT_SHORT2]    = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord2svARB);
4954     multi_texcoord_funcs[WINED3D_FFP_EMIT_SHORT4]    = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord4svARB);
4955     multi_texcoord_funcs[WINED3D_FFP_EMIT_UBYTE4N]   = invalid_texcoord_func;
4956     multi_texcoord_funcs[WINED3D_FFP_EMIT_SHORT2N]   = invalid_texcoord_func;
4957     multi_texcoord_funcs[WINED3D_FFP_EMIT_SHORT4N]   = invalid_texcoord_func;
4958     multi_texcoord_funcs[WINED3D_FFP_EMIT_USHORT2N]  = invalid_texcoord_func;
4959     multi_texcoord_funcs[WINED3D_FFP_EMIT_USHORT4N]  = invalid_texcoord_func;
4960     multi_texcoord_funcs[WINED3D_FFP_EMIT_UDEC3]     = invalid_texcoord_func;
4961     multi_texcoord_funcs[WINED3D_FFP_EMIT_DEC3N]     = invalid_texcoord_func;
4962     if (gl_info->supported[NV_HALF_FLOAT])
4963     {
4964         /* Not supported by ARB_HALF_FLOAT_VERTEX, so check for NV_HALF_FLOAT */
4965         multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT16_2] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord2hvNV);
4966         multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT16_4] = (glMultiTexCoordFunc)GL_EXTCALL(glMultiTexCoord4hvNV);
4967     } else {
4968         multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT16_2] = invalid_texcoord_func;
4969         multi_texcoord_funcs[WINED3D_FFP_EMIT_FLOAT16_4] = invalid_texcoord_func;
4970     }
4971 }
4972
4973 /* Do not call while under the GL lock. */
4974 static BOOL InitAdapters(IWineD3DImpl *This)
4975 {
4976     static HMODULE mod_gl;
4977     BOOL ret;
4978     int ps_selected_mode, vs_selected_mode;
4979
4980     /* No need to hold any lock. The calling library makes sure only one thread calls
4981      * wined3d simultaneously
4982      */
4983
4984     TRACE("Initializing adapters\n");
4985
4986     if(!mod_gl) {
4987 #ifdef USE_WIN32_OPENGL
4988 #define USE_GL_FUNC(pfn) pfn = (void*)GetProcAddress(mod_gl, #pfn);
4989         mod_gl = LoadLibraryA("opengl32.dll");
4990         if(!mod_gl) {
4991             ERR("Can't load opengl32.dll!\n");
4992             goto nogl_adapter;
4993         }
4994 #else
4995 #define USE_GL_FUNC(pfn) pfn = (void*)pwglGetProcAddress(#pfn);
4996         /* To bypass the opengl32 thunks load wglGetProcAddress from gdi32 (glXGetProcAddress wrapper) instead of opengl32's */
4997         mod_gl = GetModuleHandleA("gdi32.dll");
4998 #endif
4999     }
5000
5001 /* Load WGL core functions from opengl32.dll */
5002 #define USE_WGL_FUNC(pfn) p##pfn = (void*)GetProcAddress(mod_gl, #pfn);
5003     WGL_FUNCS_GEN;
5004 #undef USE_WGL_FUNC
5005
5006     if(!pwglGetProcAddress) {
5007         ERR("Unable to load wglGetProcAddress!\n");
5008         goto nogl_adapter;
5009     }
5010
5011 /* Dynamically load all GL core functions */
5012     GL_FUNCS_GEN;
5013 #undef USE_GL_FUNC
5014
5015     /* Load glFinish and glFlush from opengl32.dll even if we're not using WIN32 opengl
5016      * otherwise because we have to use winex11.drv's override
5017      */
5018 #ifdef USE_WIN32_OPENGL
5019     wglFinish = (void*)GetProcAddress(mod_gl, "glFinish");
5020     wglFlush = (void*)GetProcAddress(mod_gl, "glFlush");
5021 #else
5022     wglFinish = (void*)pwglGetProcAddress("wglFinish");
5023     wglFlush = (void*)pwglGetProcAddress("wglFlush");
5024 #endif
5025
5026     glEnableWINE = glEnable;
5027     glDisableWINE = glDisable;
5028
5029     /* For now only one default adapter */
5030     {
5031         struct wined3d_adapter *adapter = &This->adapters[0];
5032         const struct wined3d_gl_info *gl_info = &adapter->gl_info;
5033         struct wined3d_fake_gl_ctx fake_gl_ctx = {0};
5034         int iPixelFormat;
5035         int res;
5036         int i;
5037         WineD3D_PixelFormat *cfgs;
5038         DISPLAY_DEVICEW DisplayDevice;
5039         HDC hdc;
5040
5041         TRACE("Initializing default adapter\n");
5042         adapter->ordinal = 0;
5043         adapter->monitorPoint.x = -1;
5044         adapter->monitorPoint.y = -1;
5045
5046         if (!AllocateLocallyUniqueId(&adapter->luid))
5047         {
5048             DWORD err = GetLastError();
5049             ERR("Failed to set adapter LUID (%#x).\n", err);
5050             goto nogl_adapter;
5051         }
5052         TRACE("Allocated LUID %08x:%08x for adapter.\n",
5053                 adapter->luid.HighPart, adapter->luid.LowPart);
5054
5055         if (!WineD3D_CreateFakeGLContext(&fake_gl_ctx))
5056         {
5057             ERR("Failed to get a gl context for default adapter\n");
5058             goto nogl_adapter;
5059         }
5060
5061         ret = IWineD3DImpl_FillGLCaps(adapter);
5062         if(!ret) {
5063             ERR("Failed to initialize gl caps for default adapter\n");
5064             WineD3D_ReleaseFakeGLContext(&fake_gl_ctx);
5065             goto nogl_adapter;
5066         }
5067         ret = initPixelFormats(&adapter->gl_info, adapter->driver_info.vendor);
5068         if(!ret) {
5069             ERR("Failed to init gl formats\n");
5070             WineD3D_ReleaseFakeGLContext(&fake_gl_ctx);
5071             goto nogl_adapter;
5072         }
5073
5074         hdc = fake_gl_ctx.dc;
5075
5076         adapter->TextureRam = adapter->driver_info.vidmem;
5077         adapter->UsedTextureRam = 0;
5078         TRACE("Emulating %dMB of texture ram\n", adapter->TextureRam/(1024*1024));
5079
5080         /* Initialize the Adapter's DeviceName which is required for ChangeDisplaySettings and friends */
5081         DisplayDevice.cb = sizeof(DisplayDevice);
5082         EnumDisplayDevicesW(NULL, 0 /* Adapter 0 = iDevNum 0 */, &DisplayDevice, 0);
5083         TRACE("DeviceName: %s\n", debugstr_w(DisplayDevice.DeviceName));
5084         strcpyW(adapter->DeviceName, DisplayDevice.DeviceName);
5085
5086         if (gl_info->supported[WGL_ARB_PIXEL_FORMAT])
5087         {
5088             int attribute;
5089             int attribs[11];
5090             int values[11];
5091             int nAttribs = 0;
5092
5093             attribute = WGL_NUMBER_PIXEL_FORMATS_ARB;
5094             GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc, 0, 0, 1, &attribute, &adapter->nCfgs));
5095
5096             adapter->cfgs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, adapter->nCfgs *sizeof(WineD3D_PixelFormat));
5097             cfgs = adapter->cfgs;
5098             attribs[nAttribs++] = WGL_RED_BITS_ARB;
5099             attribs[nAttribs++] = WGL_GREEN_BITS_ARB;
5100             attribs[nAttribs++] = WGL_BLUE_BITS_ARB;
5101             attribs[nAttribs++] = WGL_ALPHA_BITS_ARB;
5102             attribs[nAttribs++] = WGL_COLOR_BITS_ARB;
5103             attribs[nAttribs++] = WGL_DEPTH_BITS_ARB;
5104             attribs[nAttribs++] = WGL_STENCIL_BITS_ARB;
5105             attribs[nAttribs++] = WGL_DRAW_TO_WINDOW_ARB;
5106             attribs[nAttribs++] = WGL_PIXEL_TYPE_ARB;
5107             attribs[nAttribs++] = WGL_DOUBLE_BUFFER_ARB;
5108             attribs[nAttribs++] = WGL_AUX_BUFFERS_ARB;
5109
5110             for (iPixelFormat=1; iPixelFormat <= adapter->nCfgs; ++iPixelFormat)
5111             {
5112                 res = GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc, iPixelFormat, 0, nAttribs, attribs, values));
5113
5114                 if(!res)
5115                     continue;
5116
5117                 /* Cache the pixel format */
5118                 cfgs->iPixelFormat = iPixelFormat;
5119                 cfgs->redSize = values[0];
5120                 cfgs->greenSize = values[1];
5121                 cfgs->blueSize = values[2];
5122                 cfgs->alphaSize = values[3];
5123                 cfgs->colorSize = values[4];
5124                 cfgs->depthSize = values[5];
5125                 cfgs->stencilSize = values[6];
5126                 cfgs->windowDrawable = values[7];
5127                 cfgs->iPixelType = values[8];
5128                 cfgs->doubleBuffer = values[9];
5129                 cfgs->auxBuffers = values[10];
5130
5131                 cfgs->numSamples = 0;
5132                 /* Check multisample support */
5133                 if (gl_info->supported[ARB_MULTISAMPLE])
5134                 {
5135                     int attrib[2] = {WGL_SAMPLE_BUFFERS_ARB, WGL_SAMPLES_ARB};
5136                     int value[2];
5137                     if(GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc, iPixelFormat, 0, 2, attrib, value))) {
5138                         /* value[0] = WGL_SAMPLE_BUFFERS_ARB which tells whether multisampling is supported.
5139                         * value[1] = number of multi sample buffers*/
5140                         if(value[0])
5141                             cfgs->numSamples = value[1];
5142                     }
5143                 }
5144
5145                 TRACE("iPixelFormat=%d, iPixelType=%#x, doubleBuffer=%d, RGBA=%d/%d/%d/%d, "
5146                         "depth=%d, stencil=%d, samples=%d, windowDrawable=%d\n",
5147                         cfgs->iPixelFormat, cfgs->iPixelType, cfgs->doubleBuffer,
5148                         cfgs->redSize, cfgs->greenSize, cfgs->blueSize, cfgs->alphaSize,
5149                         cfgs->depthSize, cfgs->stencilSize, cfgs->numSamples, cfgs->windowDrawable);
5150                 cfgs++;
5151             }
5152         }
5153         else
5154         {
5155             int nCfgs = DescribePixelFormat(hdc, 0, 0, 0);
5156             adapter->cfgs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, nCfgs*sizeof(WineD3D_PixelFormat));
5157             adapter->nCfgs = 0; /* We won't accept all formats e.g. software accelerated ones will be skipped */
5158
5159             cfgs = adapter->cfgs;
5160             for(iPixelFormat=1; iPixelFormat<=nCfgs; iPixelFormat++)
5161             {
5162                 PIXELFORMATDESCRIPTOR ppfd;
5163
5164                 res = DescribePixelFormat(hdc, iPixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &ppfd);
5165                 if(!res)
5166                     continue;
5167
5168                 /* We only want HW acceleration using an OpenGL ICD driver.
5169                  * PFD_GENERIC_FORMAT = slow opengl 1.1 gdi software rendering
5170                  * PFD_GENERIC_ACCELERATED = partial hw acceleration using a MCD driver (e.g. 3dfx minigl)
5171                  */
5172                 if(ppfd.dwFlags & (PFD_GENERIC_FORMAT | PFD_GENERIC_ACCELERATED))
5173                 {
5174                     TRACE("Skipping iPixelFormat=%d because it isn't ICD accelerated\n", iPixelFormat);
5175                     continue;
5176                 }
5177
5178                 cfgs->iPixelFormat = iPixelFormat;
5179                 cfgs->redSize = ppfd.cRedBits;
5180                 cfgs->greenSize = ppfd.cGreenBits;
5181                 cfgs->blueSize = ppfd.cBlueBits;
5182                 cfgs->alphaSize = ppfd.cAlphaBits;
5183                 cfgs->colorSize = ppfd.cColorBits;
5184                 cfgs->depthSize = ppfd.cDepthBits;
5185                 cfgs->stencilSize = ppfd.cStencilBits;
5186                 cfgs->windowDrawable = (ppfd.dwFlags & PFD_DRAW_TO_WINDOW) ? 1 : 0;
5187                 cfgs->iPixelType = (ppfd.iPixelType == PFD_TYPE_RGBA) ? WGL_TYPE_RGBA_ARB : WGL_TYPE_COLORINDEX_ARB;
5188                 cfgs->doubleBuffer = (ppfd.dwFlags & PFD_DOUBLEBUFFER) ? 1 : 0;
5189                 cfgs->auxBuffers = ppfd.cAuxBuffers;
5190                 cfgs->numSamples = 0;
5191
5192                 TRACE("iPixelFormat=%d, iPixelType=%#x, doubleBuffer=%d, RGBA=%d/%d/%d/%d, "
5193                         "depth=%d, stencil=%d, windowDrawable=%d\n",
5194                         cfgs->iPixelFormat, cfgs->iPixelType, cfgs->doubleBuffer,
5195                         cfgs->redSize, cfgs->greenSize, cfgs->blueSize, cfgs->alphaSize,
5196                         cfgs->depthSize, cfgs->stencilSize, cfgs->windowDrawable);
5197                 cfgs++;
5198                 adapter->nCfgs++;
5199             }
5200
5201             /* 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 */
5202             if(!adapter->nCfgs)
5203             {
5204                 ERR("Disabling Direct3D because no hardware accelerated pixel formats have been found!\n");
5205
5206                 WineD3D_ReleaseFakeGLContext(&fake_gl_ctx);
5207                 HeapFree(GetProcessHeap(), 0, adapter->cfgs);
5208                 goto nogl_adapter;
5209             }
5210         }
5211
5212         /* D16, D24X8 and D24S8 are common depth / depth+stencil formats. All drivers support them though this doesn't
5213          * mean that the format is offered in hardware. For instance Geforce8 cards don't have offer D16 in hardware
5214          * but just fake it using D24(X8?) which is fine. D3D also allows that.
5215          * Some display drivers (i915 on Linux) only report mixed depth+stencil formats like D24S8. MSDN clearly mentions
5216          * that only on lockable formats (e.g. D16_locked) the bit order is guaranteed and that on other formats the
5217          * driver is allowed to consume more bits EXCEPT for stencil bits.
5218          *
5219          * Mark an adapter with this broken stencil behavior.
5220          */
5221         adapter->brokenStencil = TRUE;
5222         for (i = 0, cfgs = adapter->cfgs; i < adapter->nCfgs; ++i)
5223         {
5224             /* Nearly all drivers offer depth formats without stencil, only on i915 this if-statement won't be entered. */
5225             if(cfgs[i].depthSize && !cfgs[i].stencilSize) {
5226                 adapter->brokenStencil = FALSE;
5227                 break;
5228             }
5229         }
5230
5231         WineD3D_ReleaseFakeGLContext(&fake_gl_ctx);
5232
5233         select_shader_mode(&adapter->gl_info, &ps_selected_mode, &vs_selected_mode);
5234         fillGLAttribFuncs(&adapter->gl_info);
5235         adapter->opengl = TRUE;
5236     }
5237     This->adapter_count = 1;
5238     TRACE("%u adapters successfully initialized\n", This->adapter_count);
5239
5240     return TRUE;
5241
5242 nogl_adapter:
5243     /* Initialize an adapter for ddraw-only memory counting */
5244     memset(This->adapters, 0, sizeof(This->adapters));
5245     This->adapters[0].ordinal = 0;
5246     This->adapters[0].opengl = FALSE;
5247     This->adapters[0].monitorPoint.x = -1;
5248     This->adapters[0].monitorPoint.y = -1;
5249
5250     This->adapters[0].driver_info.name = "Display";
5251     This->adapters[0].driver_info.description = "WineD3D DirectDraw Emulation";
5252     if(wined3d_settings.emulated_textureram) {
5253         This->adapters[0].TextureRam = wined3d_settings.emulated_textureram;
5254     } else {
5255         This->adapters[0].TextureRam = 8 * 1024 * 1024; /* This is plenty for a DDraw-only card */
5256     }
5257
5258     initPixelFormatsNoGL(&This->adapters[0].gl_info);
5259
5260     This->adapter_count = 1;
5261     return FALSE;
5262 }
5263
5264 /**********************************************************
5265  * IWineD3D VTbl follows
5266  **********************************************************/
5267
5268 static const struct IWineD3DVtbl IWineD3D_Vtbl =
5269 {
5270     /* IUnknown */
5271     IWineD3DImpl_QueryInterface,
5272     IWineD3DImpl_AddRef,
5273     IWineD3DImpl_Release,
5274     /* IWineD3D */
5275     IWineD3DImpl_GetParent,
5276     IWineD3DImpl_GetAdapterCount,
5277     IWineD3DImpl_RegisterSoftwareDevice,
5278     IWineD3DImpl_GetAdapterMonitor,
5279     IWineD3DImpl_GetAdapterModeCount,
5280     IWineD3DImpl_EnumAdapterModes,
5281     IWineD3DImpl_GetAdapterDisplayMode,
5282     IWineD3DImpl_GetAdapterIdentifier,
5283     IWineD3DImpl_CheckDeviceMultiSampleType,
5284     IWineD3DImpl_CheckDepthStencilMatch,
5285     IWineD3DImpl_CheckDeviceType,
5286     IWineD3DImpl_CheckDeviceFormat,
5287     IWineD3DImpl_CheckDeviceFormatConversion,
5288     IWineD3DImpl_GetDeviceCaps,
5289     IWineD3DImpl_CreateDevice
5290 };
5291
5292 static void STDMETHODCALLTYPE wined3d_null_wined3d_object_destroyed(void *parent) {}
5293
5294 const struct wined3d_parent_ops wined3d_null_parent_ops =
5295 {
5296     wined3d_null_wined3d_object_destroyed,
5297 };
5298
5299 /* Do not call while under the GL lock. */
5300 HRESULT wined3d_init(IWineD3DImpl *wined3d, UINT version, void *parent)
5301 {
5302     wined3d->lpVtbl = &IWineD3D_Vtbl;
5303     wined3d->dxVersion = version;
5304     wined3d->ref = 1;
5305     wined3d->parent = parent;
5306
5307     if (!InitAdapters(wined3d))
5308     {
5309         WARN("Failed to initialize adapters.\n");
5310         if (version > 7)
5311         {
5312             MESSAGE("Direct3D%u is not available without OpenGL.\n", version);
5313             return E_FAIL;
5314         }
5315     }
5316
5317     return WINED3D_OK;
5318 }