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