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

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