git.oblomov.eu Git - wine/blob - dlls/wined3d/directx.c

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