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