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