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  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  23  */
  24
  25 /* Compile time diagnostics: */
  26
  27 #ifndef DEBUG_SINGLE_MODE
  28 /* Set to 1 to force only a single display mode to be exposed: */
  29 #define DEBUG_SINGLE_MODE 0
  30 #endif
  31
  32
  33 #include "config.h"
  34 #include <assert.h>
  35 #include "wined3d_private.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
  38 WINE_DECLARE_DEBUG_CHANNEL(d3d_caps);
  39
  40 /* The d3d device ID */
  41 static const GUID IID_D3DDEVICE_D3DUID = { 0xaeb2cdd4, 0x6e41, 0x43ea, { 0x94,0x1c,0x83,0x61,0xcc,0x76,0x07,0x81 } };
  42
  43 /* Extension detection */
  44 static const struct {
  45     const char *extension_string;
  46     GL_SupportedExt extension;
  47     DWORD version;
  48 } EXTENSION_MAP[] = {
  49     /* APPLE */
  50     {"GL_APPLE_client_storage",             APPLE_CLIENT_STORAGE,           0                           },
  51     {"GL_APPLE_fence",                      APPLE_FENCE,                    0                           },
  52     {"GL_APPLE_flush_render",               APPLE_FLUSH_RENDER,             0                           },
  53     {"GL_APPLE_ycbcr_422",                  APPLE_YCBCR_422,                0                           },
  54     {"GL_APPLE_float_pixels",               APPLE_FLOAT_PIXELS,             0                           },
  55
  56     /* ATI */
  57     {"GL_ATI_separate_stencil",             ATI_SEPARATE_STENCIL,           0                           },
  58     {"GL_ATI_texture_env_combine3",         ATI_TEXTURE_ENV_COMBINE3,       0                           },
  59     {"GL_ATI_texture_mirror_once",          ATI_TEXTURE_MIRROR_ONCE,        0                           },
  60     {"GL_ATI_envmap_bumpmap",               ATI_ENVMAP_BUMPMAP,             0                           },
  61     {"GL_ATI_fragment_shader",              ATI_FRAGMENT_SHADER,            0                           },
  62
  63     /* ARB */
  64     {"GL_ARB_color_buffer_float",           ARB_COLOR_BUFFER_FLOAT,         0                           },
  65     {"GL_ARB_draw_buffers",                 ARB_DRAW_BUFFERS,               0                           },
  66     {"GL_ARB_fragment_program",             ARB_FRAGMENT_PROGRAM,           0                           },
  67     {"GL_ARB_fragment_shader",              ARB_FRAGMENT_SHADER,            0                           },
  68     {"GL_ARB_half_float_pixel",             ARB_HALF_FLOAT_PIXEL,           0                           },
  69     {"GL_ARB_imaging",                      ARB_IMAGING,                    0                           },
  70     {"GL_ARB_multisample",                  ARB_MULTISAMPLE,                0                           }, /* needs GLX_ARB_MULTISAMPLE as well */
  71     {"GL_ARB_multitexture",                 ARB_MULTITEXTURE,               0                           },
  72     {"GL_ARB_occlusion_query",              ARB_OCCLUSION_QUERY,            0                           },
  73     {"GL_ARB_pixel_buffer_object",          ARB_PIXEL_BUFFER_OBJECT,        0                           },
  74     {"GL_ARB_point_parameters",             ARB_POINT_PARAMETERS,           0                           },
  75     {"GL_ARB_point_sprite",                 ARB_POINT_SPRITE,               0                           },
  76     {"GL_ARB_texture_border_clamp",         ARB_TEXTURE_BORDER_CLAMP,       0                           },
  77     {"GL_ARB_texture_compression",          ARB_TEXTURE_COMPRESSION,        0                           },
  78     {"GL_ARB_texture_cube_map",             ARB_TEXTURE_CUBE_MAP,           0                           },
  79     {"GL_ARB_texture_env_add",              ARB_TEXTURE_ENV_ADD,            0                           },
  80     {"GL_ARB_texture_env_combine",          ARB_TEXTURE_ENV_COMBINE,        0                           },
  81     {"GL_ARB_texture_env_dot3",             ARB_TEXTURE_ENV_DOT3,           0                           },
  82     {"GL_ARB_texture_float",                ARB_TEXTURE_FLOAT,              0                           },
  83     {"GL_ARB_texture_mirrored_repeat",      ARB_TEXTURE_MIRRORED_REPEAT,    0                           },
  84     {"GL_ARB_texture_non_power_of_two",     ARB_TEXTURE_NON_POWER_OF_TWO,   MAKEDWORD_VERSION(2, 0)     },
  85     {"GL_ARB_texture_rectangle",            ARB_TEXTURE_RECTANGLE,          0                           },
  86     {"GL_ARB_vertex_blend",                 ARB_VERTEX_BLEND,               0                           },
  87     {"GL_ARB_vertex_buffer_object",         ARB_VERTEX_BUFFER_OBJECT,       0                           },
  88     {"GL_ARB_vertex_program",               ARB_VERTEX_PROGRAM,             0                           },
  89     {"GL_ARB_vertex_shader",                ARB_VERTEX_SHADER,              0                           },
  90     {"GL_ARB_shader_objects",               ARB_SHADER_OBJECTS,             0                           },
  91
  92     /* EXT */
  93     {"GL_EXT_blend_color",                  EXT_BLEND_COLOR,                0                           },
  94     {"GL_EXT_blend_minmax",                 EXT_BLEND_MINMAX,               0                           },
  95     {"GL_EXT_blend_equation_separate",      EXT_BLEND_EQUATION_SEPARATE,    0                           },
  96     {"GL_EXT_blend_func_separate",          EXT_BLEND_FUNC_SEPARATE,        0                           },
  97     {"GL_EXT_fog_coord",                    EXT_FOG_COORD,                  0                           },
  98     {"GL_EXT_framebuffer_blit",             EXT_FRAMEBUFFER_BLIT,           0                           },
  99     {"GL_EXT_framebuffer_object",           EXT_FRAMEBUFFER_OBJECT,         0                           },
 100     {"GL_EXT_paletted_texture",             EXT_PALETTED_TEXTURE,           0                           },
 101     {"GL_EXT_point_parameters",             EXT_POINT_PARAMETERS,           0                           },
 102     {"GL_EXT_secondary_color",              EXT_SECONDARY_COLOR,            0                           },
 103     {"GL_EXT_stencil_two_side",             EXT_STENCIL_TWO_SIDE,           0                           },
 104     {"GL_EXT_stencil_wrap",                 EXT_STENCIL_WRAP,               0                           },
 105     {"GL_EXT_texture3D",                    EXT_TEXTURE3D,                  MAKEDWORD_VERSION(1, 2)     },
 106     {"GL_EXT_texture_compression_s3tc",     EXT_TEXTURE_COMPRESSION_S3TC,   0                           },
 107     {"GL_EXT_texture_env_add",              EXT_TEXTURE_ENV_ADD,            0                           },
 108     {"GL_EXT_texture_env_combine",          EXT_TEXTURE_ENV_COMBINE,        0                           },
 109     {"GL_EXT_texture_env_dot3",             EXT_TEXTURE_ENV_DOT3,           0                           },
 110     {"GL_EXT_texture_sRGB",                 EXT_TEXTURE_SRGB,               0                           },
 111     {"GL_EXT_texture_filter_anisotropic",   EXT_TEXTURE_FILTER_ANISOTROPIC, 0                           },
 112     {"GL_EXT_texture_lod",                  EXT_TEXTURE_LOD,                0                           },
 113     {"GL_EXT_texture_lod_bias",             EXT_TEXTURE_LOD_BIAS,           0                           },
 114     {"GL_EXT_vertex_shader",                EXT_VERTEX_SHADER,              0                           },
 115     {"GL_EXT_gpu_program_parameters",       EXT_GPU_PROGRAM_PARAMETERS,     0                           },
 116
 117     /* NV */
 118     {"GL_NV_half_float",                    NV_HALF_FLOAT,                  0                           },
 119     {"GL_NV_fence",                         NV_FENCE,                       0                           },
 120     {"GL_NV_fog_distance",                  NV_FOG_DISTANCE,                0                           },
 121     {"GL_NV_fragment_program",              NV_FRAGMENT_PROGRAM,            0                           },
 122     {"GL_NV_fragment_program2",             NV_FRAGMENT_PROGRAM2,           0                           },
 123     {"GL_NV_register_combiners",            NV_REGISTER_COMBINERS,          0                           },
 124     {"GL_NV_register_combiners2",           NV_REGISTER_COMBINERS2,         0                           },
 125     {"GL_NV_texgen_reflection",             NV_TEXGEN_REFLECTION,           0                           },
 126     {"GL_NV_texture_env_combine4",          NV_TEXTURE_ENV_COMBINE4,        0                           },
 127     {"GL_NV_texture_shader",                NV_TEXTURE_SHADER,              0                           },
 128     {"GL_NV_texture_shader2",               NV_TEXTURE_SHADER2,             0                           },
 129     {"GL_NV_texture_shader3",               NV_TEXTURE_SHADER3,             0                           },
 130     {"GL_NV_occlusion_query",               NV_OCCLUSION_QUERY,             0                           },
 131     {"GL_NV_vertex_program",                NV_VERTEX_PROGRAM,              0                           },
 132     {"GL_NV_vertex_program1_1",             NV_VERTEX_PROGRAM1_1,           0                           },
 133     {"GL_NV_vertex_program2",               NV_VERTEX_PROGRAM2,             0                           },
 134     {"GL_NV_vertex_program3",               NV_VERTEX_PROGRAM3,             0                           },
 135     {"GL_NV_depth_clamp",                   NV_DEPTH_CLAMP,                 0                           },
 136     {"GL_NV_light_max_exponent",            NV_LIGHT_MAX_EXPONENT,          0                           },
 137
 138     /* SGI */
 139     {"GL_SGIS_generate_mipmap",             SGIS_GENERATE_MIPMAP,           0                           },
 140 };
 141
 142 /**********************************************************
 143  * Utility functions follow
 144  **********************************************************/
 145
 146 /* Adapters */
 147 static int numAdapters = 0;
 148 static struct WineD3DAdapter Adapters[1];
 149
 150 static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType, WINED3DFORMAT AdapterFormat, DWORD Usage, WINED3DRESOURCETYPE RType, WINED3DFORMAT CheckFormat);
 151
 152 /* lookup tables */
 153 int minLookup[MAX_LOOKUPS];
 154 int maxLookup[MAX_LOOKUPS];
 155 DWORD *stateLookup[MAX_LOOKUPS];
 156
 157 DWORD minMipLookup[WINED3DTEXF_ANISOTROPIC + 1][WINED3DTEXF_LINEAR + 1];
 158 DWORD minMipLookup_noFilter[WINED3DTEXF_ANISOTROPIC + 1][WINED3DTEXF_LINEAR + 1] = {
 159     {GL_NEAREST, GL_NEAREST, GL_NEAREST},
 160     {GL_NEAREST, GL_NEAREST, GL_NEAREST},
 161     {GL_NEAREST, GL_NEAREST, GL_NEAREST},
 162     {GL_NEAREST, GL_NEAREST, GL_NEAREST},
 163 };
 164
 165 DWORD magLookup[WINED3DTEXF_ANISOTROPIC + 1];
 166 DWORD magLookup_noFilter[WINED3DTEXF_ANISOTROPIC + 1] = {
 167     GL_NEAREST, GL_NEAREST, GL_NEAREST, GL_NEAREST
 168 };
 169
 170 /* drawStridedSlow attributes */
 171 glAttribFunc position_funcs[WINED3DDECLTYPE_UNUSED];
 172 glAttribFunc diffuse_funcs[WINED3DDECLTYPE_UNUSED];
 173 glAttribFunc specular_funcs[WINED3DDECLTYPE_UNUSED];
 174 glAttribFunc normal_funcs[WINED3DDECLTYPE_UNUSED];
 175 glTexAttribFunc texcoord_funcs[WINED3DDECLTYPE_UNUSED];
 176
 177 /**
 178  * Note: GL seems to trap if GetDeviceCaps is called before any HWND's created,
 179  * i.e., there is no GL Context - Get a default rendering context to enable the
 180  * function query some info from GL.
 181  */
 182
 183 static int             wined3d_fake_gl_context_ref = 0;
 184 static BOOL            wined3d_fake_gl_context_foreign;
 185 static BOOL            wined3d_fake_gl_context_available = FALSE;
 186 static HDC             wined3d_fake_gl_context_hdc = NULL;
 187 static HWND            wined3d_fake_gl_context_hwnd = NULL;
 188
 189 static CRITICAL_SECTION wined3d_fake_gl_context_cs;
 190 static CRITICAL_SECTION_DEBUG wined3d_fake_gl_context_cs_debug =
 191 {
 192     0, 0, &wined3d_fake_gl_context_cs,
 193     { &wined3d_fake_gl_context_cs_debug.ProcessLocksList,
 194       &wined3d_fake_gl_context_cs_debug.ProcessLocksList },
 195     0, 0, { (DWORD_PTR)(__FILE__ ": wined3d_fake_gl_context_cs") }
 196 };
 197 static CRITICAL_SECTION wined3d_fake_gl_context_cs = { &wined3d_fake_gl_context_cs_debug, -1, 0, 0, 0, 0 };
 198
 199 static void WineD3D_ReleaseFakeGLContext(void) {
 200     HGLRC glCtx;
 201
 202     EnterCriticalSection(&wined3d_fake_gl_context_cs);
 203
 204     if(!wined3d_fake_gl_context_available) {
 205         TRACE_(d3d_caps)("context not available\n");
 206         LeaveCriticalSection(&wined3d_fake_gl_context_cs);
 207         return;
 208     }
 209
 210     glCtx = pwglGetCurrentContext();
 211
 212     TRACE_(d3d_caps)("decrementing ref from %i\n", wined3d_fake_gl_context_ref);
 213     if (0 == (--wined3d_fake_gl_context_ref) ) {
 214         if(!wined3d_fake_gl_context_foreign && glCtx) {
 215             TRACE_(d3d_caps)("destroying fake GL context\n");
 216             pwglMakeCurrent(NULL, NULL);
 217             pwglDeleteContext(glCtx);
 218         }
 219         if(wined3d_fake_gl_context_hdc)
 220             ReleaseDC(wined3d_fake_gl_context_hwnd, wined3d_fake_gl_context_hdc);
 221         wined3d_fake_gl_context_hdc = NULL; /* Make sure we don't think that it is still around */
 222         if(wined3d_fake_gl_context_hwnd)
 223             DestroyWindow(wined3d_fake_gl_context_hwnd);
 224         wined3d_fake_gl_context_hwnd = NULL;
 225         wined3d_fake_gl_context_available = FALSE;
 226     }
 227     assert(wined3d_fake_gl_context_ref >= 0);
 228
 229     LeaveCriticalSection(&wined3d_fake_gl_context_cs);
 230 }
 231
 232 static BOOL WineD3D_CreateFakeGLContext(void) {
 233     HGLRC glCtx = NULL;
 234
 235     EnterCriticalSection(&wined3d_fake_gl_context_cs);
 236
 237     TRACE("getting context...\n");
 238     if(wined3d_fake_gl_context_ref > 0) goto ret;
 239     assert(0 == wined3d_fake_gl_context_ref);
 240
 241     wined3d_fake_gl_context_foreign = TRUE;
 242
 243     glCtx = pwglGetCurrentContext();
 244     if (!glCtx) {
 245         PIXELFORMATDESCRIPTOR pfd;
 246         int iPixelFormat;
 247
 248         wined3d_fake_gl_context_foreign = FALSE;
 249
 250         /* We need a fake window as a hdc retrieved using GetDC(0) can't be used for much GL purposes */
 251         wined3d_fake_gl_context_hwnd = CreateWindowA("WineD3D_OpenGL", "WineD3D fake window", WS_OVERLAPPEDWINDOW,        10, 10, 10, 10, NULL, NULL, NULL, NULL);
 252         if(!wined3d_fake_gl_context_hwnd) {
 253             ERR("HWND creation failed!\n");
 254             goto fail;
 255         }
 256         wined3d_fake_gl_context_hdc = GetDC(wined3d_fake_gl_context_hwnd);
 257         if(!wined3d_fake_gl_context_hdc) {
 258             ERR("GetDC failed!\n");
 259             goto fail;
 260         }
 261
 262         /* PixelFormat selection */
 263         ZeroMemory(&pfd, sizeof(pfd));
 264         pfd.nSize      = sizeof(pfd);
 265         pfd.nVersion   = 1;
 266         pfd.dwFlags    = PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER | PFD_DRAW_TO_WINDOW;/*PFD_GENERIC_ACCELERATED*/
 267         pfd.iPixelType = PFD_TYPE_RGBA;
 268         pfd.cColorBits = 32;
 269         pfd.iLayerType = PFD_MAIN_PLANE;
 270
 271         iPixelFormat = ChoosePixelFormat(wined3d_fake_gl_context_hdc, &pfd);
 272         if(!iPixelFormat) {
 273             /* If this happens something is very wrong as ChoosePixelFormat barely fails */
 274             ERR("Can't find a suitable iPixelFormat\n");
 275             goto fail;
 276         }
 277         DescribePixelFormat(wined3d_fake_gl_context_hdc, iPixelFormat, sizeof(pfd), &pfd);
 278         SetPixelFormat(wined3d_fake_gl_context_hdc, iPixelFormat, &pfd);
 279
 280         /* Create a GL context */
 281         glCtx = pwglCreateContext(wined3d_fake_gl_context_hdc);
 282         if (!glCtx) {
 283             WARN_(d3d_caps)("Error creating default context for capabilities initialization\n");
 284             goto fail;
 285         }
 286
 287         /* Make it the current GL context */
 288         if (!pwglMakeCurrent(wined3d_fake_gl_context_hdc, glCtx)) {
 289             WARN_(d3d_caps)("Error setting default context as current for capabilities initialization\n");
 290             goto fail;
 291         }
 292     }
 293
 294   ret:
 295     TRACE("incrementing ref from %i\n", wined3d_fake_gl_context_ref);
 296     wined3d_fake_gl_context_ref++;
 297     wined3d_fake_gl_context_available = TRUE;
 298     LeaveCriticalSection(&wined3d_fake_gl_context_cs);
 299     return TRUE;
 300   fail:
 301     if(wined3d_fake_gl_context_hdc)
 302         ReleaseDC(wined3d_fake_gl_context_hwnd, wined3d_fake_gl_context_hdc);
 303     wined3d_fake_gl_context_hdc = NULL;
 304     if(wined3d_fake_gl_context_hwnd)
 305         DestroyWindow(wined3d_fake_gl_context_hwnd);
 306     wined3d_fake_gl_context_hwnd = NULL;
 307     if(glCtx) pwglDeleteContext(glCtx);
 308     LeaveCriticalSection(&wined3d_fake_gl_context_cs);
 309     return FALSE;
 310 }
 311
 312 /* Adjust the amount of used texture memory */
 313 long WineD3DAdapterChangeGLRam(IWineD3DDeviceImpl *D3DDevice, long glram){
 314     UINT Adapter = D3DDevice->adapterNo;
 315
 316     Adapters[Adapter].UsedTextureRam += glram;
 317     TRACE("Adjusted gl ram by %ld to %d\n", glram, Adapters[Adapter].UsedTextureRam);
 318     return Adapters[Adapter].UsedTextureRam;
 319 }
 320
 321 /**********************************************************
 322  * IUnknown parts follows
 323  **********************************************************/
 324
 325 static HRESULT WINAPI IWineD3DImpl_QueryInterface(IWineD3D *iface,REFIID riid,LPVOID *ppobj)
 326 {
 327     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
 328
 329     TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppobj);
 330     if (IsEqualGUID(riid, &IID_IUnknown)
 331         || IsEqualGUID(riid, &IID_IWineD3DBase)
 332         || IsEqualGUID(riid, &IID_IWineD3DDevice)) {
 333         IUnknown_AddRef(iface);
 334         *ppobj = This;
 335         return S_OK;
 336     }
 337     *ppobj = NULL;
 338     return E_NOINTERFACE;
 339 }
 340
 341 static ULONG WINAPI IWineD3DImpl_AddRef(IWineD3D *iface) {
 342     IWineD3DImpl *This = (IWineD3DImpl *)iface;
 343     ULONG refCount = InterlockedIncrement(&This->ref);
 344
 345     TRACE("(%p) : AddRef increasing from %d\n", This, refCount - 1);
 346     return refCount;
 347 }
 348
 349 static ULONG WINAPI IWineD3DImpl_Release(IWineD3D *iface) {
 350     IWineD3DImpl *This = (IWineD3DImpl *)iface;
 351     ULONG ref;
 352     TRACE("(%p) : Releasing from %d\n", This, This->ref);
 353     ref = InterlockedDecrement(&This->ref);
 354     if (ref == 0) {
 355         HeapFree(GetProcessHeap(), 0, This);
 356     }
 357
 358     return ref;
 359 }
 360
 361 /* Set the shader type for this device, depending on the given capabilities,
 362  * the device type, and the user preferences in wined3d_settings */
 363
 364 void select_shader_mode(
 365     WineD3D_GL_Info *gl_info,
 366     WINED3DDEVTYPE DeviceType,
 367     int* ps_selected,
 368     int* vs_selected) {
 369
 370     if (wined3d_settings.vs_mode == VS_NONE) {
 371         *vs_selected = SHADER_NONE;
 372     } else if (gl_info->supported[ARB_VERTEX_SHADER] && wined3d_settings.glslRequested) {
 373         /* Geforce4 cards support GLSL but for vertex shaders only. Further its reported GLSL caps are
 374          * wrong. This combined with the fact that glsl won't offer more features or performance, use ARB
 375          * shaders only on this card. */
 376         if(gl_info->vs_nv_version && gl_info->vs_nv_version < VS_VERSION_20)
 377             *vs_selected = SHADER_ARB;
 378         else
 379             *vs_selected = SHADER_GLSL;
 380     } else if (gl_info->supported[ARB_VERTEX_PROGRAM]) {
 381         *vs_selected = SHADER_ARB;
 382     } else {
 383         *vs_selected = SHADER_NONE;
 384     }
 385
 386     if (wined3d_settings.ps_mode == PS_NONE) {
 387         *ps_selected = SHADER_NONE;
 388     } else if (gl_info->supported[ARB_FRAGMENT_SHADER] && wined3d_settings.glslRequested) {
 389         *ps_selected = SHADER_GLSL;
 390     } else if (gl_info->supported[ARB_FRAGMENT_PROGRAM]) {
 391         *ps_selected = SHADER_ARB;
 392     } else if (gl_info->supported[ATI_FRAGMENT_SHADER]) {
 393         *ps_selected = SHADER_ATI;
 394     } else {
 395         *ps_selected = SHADER_NONE;
 396     }
 397 }
 398
 399 /** Select the number of report maximum shader constants based on the selected shader modes */
 400 static void select_shader_max_constants(
 401     int ps_selected_mode,
 402     int vs_selected_mode,
 403     WineD3D_GL_Info *gl_info) {
 404
 405     switch (vs_selected_mode) {
 406         case SHADER_GLSL:
 407             /* Subtract the other potential uniforms from the max available (bools, ints, and 1 row of projection matrix) */
 408             gl_info->max_vshader_constantsF = gl_info->vs_glsl_constantsF - (MAX_CONST_B / 4) - MAX_CONST_I - 1;
 409             break;
 410         case SHADER_ARB:
 411             /* We have to subtract any other PARAMs that we might use in our shader programs.
 412              * ATI seems to count 2 implicit PARAMs when we use fog and NVIDIA counts 1,
 413              * and we reference one row of the PROJECTION matrix which counts as 1 PARAM. */
 414             gl_info->max_vshader_constantsF = gl_info->vs_arb_constantsF - 3;
 415             break;
 416         default:
 417             gl_info->max_vshader_constantsF = 0;
 418             break;
 419     }
 420
 421     switch (ps_selected_mode) {
 422         case SHADER_GLSL:
 423             /* Subtract the other potential uniforms from the max available (bools & ints), and 2 states for fog.
 424              * In theory the texbem instruction may need one more shader constant too. But lets assume
 425              * that a sm <= 1.3 shader does not need all the uniforms provided by a glsl-capable card,
 426              * and lets not take away a uniform needlessly from all other shaders.
 427              */
 428             gl_info->max_pshader_constantsF = gl_info->ps_glsl_constantsF - (MAX_CONST_B / 4) - MAX_CONST_I - 2;
 429             break;
 430         case SHADER_ARB:
 431             /* The arb shader only loads the bump mapping environment matrix into the shader if it finds
 432              * a free constant to do that, so only reduce the number of available constants by 2 for the fog states.
 433              */
 434             gl_info->max_pshader_constantsF = gl_info->ps_arb_constantsF - 2;
 435             break;
 436         default:
 437             gl_info->max_pshader_constantsF = 0;
 438             break;
 439     }
 440 }
 441
 442 /**********************************************************
 443  * IWineD3D parts follows
 444  **********************************************************/
 445
 446 #define GLINFO_LOCATION (*gl_info)
 447 static inline BOOL test_arb_vs_offset_limit(WineD3D_GL_Info *gl_info) {
 448     GLuint prog;
 449     BOOL ret = FALSE;
 450     const char *testcode =
 451         "!!ARBvp1.0\n"
 452         "PARAM C[66] = { program.env[0..65] };\n"
 453         "ADDRESS A0;"
 454         "PARAM zero = {0.0, 0.0, 0.0, 0.0};\n"
 455         "ARL A0.x, zero.x;\n"
 456         "MOV result.position, C[A0.x + 65];\n"
 457         "END\n";
 458
 459     while(glGetError());
 460     GL_EXTCALL(glGenProgramsARB(1, &prog));
 461     if(!prog) {
 462         ERR("Failed to create an ARB offset limit test program\n");
 463     }
 464     GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, prog));
 465     GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
 466                                   strlen(testcode), testcode));
 467     if(glGetError() != 0) {
 468         TRACE("OpenGL implementation does not allow indirect addressing offsets > 63\n");
 469         TRACE("error: %s\n", debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
 470         ret = TRUE;
 471     } else TRACE("OpenGL implementation allows offsets > 63\n");
 472
 473     GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, 0));
 474     GL_EXTCALL(glDeleteProgramsARB(1, &prog));
 475     checkGLcall("ARB vp offset limit test cleanup\n");
 476
 477     return ret;
 478 }
 479
 480 static DWORD ver_for_ext(GL_SupportedExt ext)
 481 {
 482     unsigned int i;
 483     for (i = 0; i < (sizeof(EXTENSION_MAP) / sizeof(*EXTENSION_MAP)); ++i) {
 484         if(EXTENSION_MAP[i].extension == ext) {
 485             return EXTENSION_MAP[i].version;
 486         }
 487     }
 488     return 0;
 489 }
 490
 491 BOOL IWineD3DImpl_FillGLCaps(WineD3D_GL_Info *gl_info) {
 492     const char *GL_Extensions    = NULL;
 493     const char *WGL_Extensions   = NULL;
 494     const char *gl_string        = NULL;
 495     const char *gl_string_cursor = NULL;
 496     GLint       gl_max;
 497     GLfloat     gl_floatv[2];
 498     int         major = 1, minor = 0;
 499     BOOL        return_value = TRUE;
 500     unsigned    i;
 501     HDC         hdc;
 502     unsigned int vidmem=0;
 503
 504     TRACE_(d3d_caps)("(%p)\n", gl_info);
 505
 506     ENTER_GL();
 507
 508     gl_string = (const char *) glGetString(GL_RENDERER);
 509     if (NULL == gl_string)
 510         gl_string = "None";
 511     strcpy(gl_info->gl_renderer, gl_string);
 512
 513     gl_string = (const char *) glGetString(GL_VENDOR);
 514     TRACE_(d3d_caps)("Filling vendor string %s\n", gl_string);
 515     if (gl_string != NULL) {
 516         /* Fill in the GL vendor */
 517         if (strstr(gl_string, "NVIDIA")) {
 518             gl_info->gl_vendor = VENDOR_NVIDIA;
 519         } else if (strstr(gl_string, "ATI")) {
 520             gl_info->gl_vendor = VENDOR_ATI;
 521         } else if (strstr(gl_string, "Intel(R)") ||
 522                    strstr(gl_info->gl_renderer, "Intel(R)") ||
 523                    strstr(gl_string, "Intel Inc.")) {
 524             gl_info->gl_vendor = VENDOR_INTEL;
 525         } else if (strstr(gl_string, "Mesa")) {
 526             gl_info->gl_vendor = VENDOR_MESA;
 527         } else {
 528             gl_info->gl_vendor = VENDOR_WINE;
 529         }
 530     } else {
 531         gl_info->gl_vendor = VENDOR_WINE;
 532     }
 533
 534
 535     TRACE_(d3d_caps)("found GL_VENDOR (%s)->(0x%04x)\n", debugstr_a(gl_string), gl_info->gl_vendor);
 536
 537     /* Parse the GL_VERSION field into major and minor information */
 538     gl_string = (const char *) glGetString(GL_VERSION);
 539     if (gl_string != NULL) {
 540
 541         /* First, parse the generic opengl version. This is supposed not to be convoluted with
 542          * driver specific information
 543          */
 544         gl_string_cursor = gl_string;
 545         major = atoi(gl_string_cursor);
 546         if(major <= 0) {
 547             ERR("Invalid opengl major version: %d\n", major);
 548         }
 549         while (*gl_string_cursor <= '9' && *gl_string_cursor >= '0') {
 550             ++gl_string_cursor;
 551         }
 552         if (*gl_string_cursor++ != '.') {
 553             ERR_(d3d_caps)("Invalid opengl version string: %s\n", debugstr_a(gl_string));
 554         }
 555         minor = atoi(gl_string_cursor);
 556         TRACE_(d3d_caps)("Found OpenGL version: %d.%d\n", major, minor);
 557         gl_info->gl_version = MAKEDWORD_VERSION(major, minor);
 558
 559         /* Now parse the driver specific string which we'll report to the app */
 560         switch (gl_info->gl_vendor) {
 561         case VENDOR_NVIDIA:
 562             gl_string_cursor = strstr(gl_string, "NVIDIA");
 563             if (!gl_string_cursor) {
 564                 ERR_(d3d_caps)("Invalid nVidia version string: %s\n", debugstr_a(gl_string));
 565                 break;
 566             }
 567
 568             gl_string_cursor = strstr(gl_string_cursor, " ");
 569             if (!gl_string_cursor) {
 570                 ERR_(d3d_caps)("Invalid nVidia version string: %s\n", debugstr_a(gl_string));
 571                 break;
 572             }
 573
 574             while (*gl_string_cursor == ' ') {
 575                 ++gl_string_cursor;
 576             }
 577
 578             if (!*gl_string_cursor) {
 579                 ERR_(d3d_caps)("Invalid nVidia version string: %s\n", debugstr_a(gl_string));
 580                 break;
 581             }
 582
 583             major = atoi(gl_string_cursor);
 584             while (*gl_string_cursor <= '9' && *gl_string_cursor >= '0') {
 585                 ++gl_string_cursor;
 586             }
 587
 588             if (*gl_string_cursor++ != '.') {
 589                 ERR_(d3d_caps)("Invalid nVidia version string: %s\n", debugstr_a(gl_string));
 590                 break;
 591             }
 592
 593             minor = atoi(gl_string_cursor);
 594             minor = major*100+minor;
 595             major = 10;
 596
 597             break;
 598
 599         case VENDOR_ATI:
 600             major = minor = 0;
 601             gl_string_cursor = strchr(gl_string, '-');
 602             if (gl_string_cursor) {
 603                 int error = 0;
 604                 gl_string_cursor++;
 605
 606                 /* Check if version number is of the form x.y.z */
 607                 if (*gl_string_cursor > '9' && *gl_string_cursor < '0')
 608                     error = 1;
 609                 if (!error && *(gl_string_cursor+2) > '9' && *(gl_string_cursor+2) < '0')
 610                     error = 1;
 611                 if (!error && *(gl_string_cursor+4) > '9' && *(gl_string_cursor+4) < '0')
 612                     error = 1;
 613                 if (!error && *(gl_string_cursor+1) != '.' && *(gl_string_cursor+3) != '.')
 614                     error = 1;
 615
 616                 /* Mark version number as malformed */
 617                 if (error)
 618                     gl_string_cursor = 0;
 619             }
 620
 621             if (!gl_string_cursor)
 622                 WARN_(d3d_caps)("malformed GL_VERSION (%s)\n", debugstr_a(gl_string));
 623             else {
 624                 major = *gl_string_cursor - '0';
 625                 minor = (*(gl_string_cursor+2) - '0') * 256 + (*(gl_string_cursor+4) - '0');
 626             }
 627             break;
 628
 629         case VENDOR_INTEL:
 630             /* Apple and Mesa version strings look differently, but both provide intel drivers */
 631             if(strstr(gl_string, "APPLE")) {
 632                 /* [0-9]+.[0-9]+ APPLE-[0-9]+.[0.9]+.[0.9]+
 633                  * We only need the first part, and use the APPLE as identification
 634                  * "1.2 APPLE-1.4.56"
 635                  */
 636                 gl_string_cursor = gl_string;
 637                 major = atoi(gl_string_cursor);
 638                 while (*gl_string_cursor <= '9' && *gl_string_cursor >= '0') {
 639                     ++gl_string_cursor;
 640                 }
 641
 642                 if (*gl_string_cursor++ != '.') {
 643                     ERR_(d3d_caps)("Invalid MacOS-Intel version string: %s\n", debugstr_a(gl_string));
 644                     break;
 645                 }
 646
 647                 minor = atoi(gl_string_cursor);
 648                 break;
 649             }
 650
 651         case VENDOR_MESA:
 652             gl_string_cursor = strstr(gl_string, "Mesa");
 653             gl_string_cursor = strstr(gl_string_cursor, " ");
 654             while (*gl_string_cursor && ' ' == *gl_string_cursor) ++gl_string_cursor;
 655             if (*gl_string_cursor) {
 656                 char tmp[16];
 657                 int cursor = 0;
 658
 659                 while (*gl_string_cursor <= '9' && *gl_string_cursor >= '0') {
 660                     tmp[cursor++] = *gl_string_cursor;
 661                     ++gl_string_cursor;
 662                 }
 663                 tmp[cursor] = 0;
 664                 major = atoi(tmp);
 665
 666                 if (*gl_string_cursor != '.') WARN_(d3d_caps)("malformed GL_VERSION (%s)\n", debugstr_a(gl_string));
 667                 ++gl_string_cursor;
 668
 669                 cursor = 0;
 670                 while (*gl_string_cursor <= '9' && *gl_string_cursor >= '0') {
 671                     tmp[cursor++] = *gl_string_cursor;
 672                     ++gl_string_cursor;
 673                 }
 674                 tmp[cursor] = 0;
 675                 minor = atoi(tmp);
 676             }
 677             break;
 678
 679         default:
 680             major = 0;
 681             minor = 9;
 682         }
 683         gl_info->driver_version = MAKEDWORD_VERSION(major, minor);
 684         TRACE_(d3d_caps)("found driver version (%s)->%i.%i->(0x%08x)\n", debugstr_a(gl_string), major, minor, gl_info->driver_version);
 685         /* Current Windows drivers have versions like 6.14.... (some older have an earlier version) */
 686         gl_info->driver_version_hipart = MAKEDWORD_VERSION(6, 14);
 687     } else {
 688         FIXME("OpenGL driver did not return version information\n");
 689         gl_info->driver_version = MAKEDWORD_VERSION(0, 0);
 690         gl_info->driver_version_hipart = MAKEDWORD_VERSION(6, 14);
 691     }
 692
 693     TRACE_(d3d_caps)("found GL_RENDERER (%s)->(0x%04x)\n", debugstr_a(gl_info->gl_renderer), gl_info->gl_card);
 694
 695     /*
 696      * Initialize openGL extension related variables
 697      *  with Default values
 698      */
 699     memset(gl_info->supported, 0, sizeof(gl_info->supported));
 700     gl_info->max_buffers        = 1;
 701     gl_info->max_textures       = 1;
 702     gl_info->max_texture_stages = 1;
 703     gl_info->max_fragment_samplers = 1;
 704     gl_info->max_vertex_samplers = 0;
 705     gl_info->max_combined_samplers = 0;
 706     gl_info->max_sampler_stages = 1;
 707     gl_info->ps_arb_version = PS_VERSION_NOT_SUPPORTED;
 708     gl_info->ps_arb_max_temps = 0;
 709     gl_info->ps_arb_max_instructions = 0;
 710     gl_info->vs_arb_version = VS_VERSION_NOT_SUPPORTED;
 711     gl_info->vs_arb_max_temps = 0;
 712     gl_info->vs_arb_max_instructions = 0;
 713     gl_info->vs_nv_version  = VS_VERSION_NOT_SUPPORTED;
 714     gl_info->vs_ati_version = VS_VERSION_NOT_SUPPORTED;
 715     gl_info->vs_glsl_constantsF = 0;
 716     gl_info->ps_glsl_constantsF = 0;
 717     gl_info->vs_arb_constantsF = 0;
 718     gl_info->ps_arb_constantsF = 0;
 719
 720     /* Retrieve opengl defaults */
 721     glGetIntegerv(GL_MAX_CLIP_PLANES, &gl_max);
 722     gl_info->max_clipplanes = min(WINED3DMAXUSERCLIPPLANES, gl_max);
 723     TRACE_(d3d_caps)("ClipPlanes support - num Planes=%d\n", gl_max);
 724
 725     glGetIntegerv(GL_MAX_LIGHTS, &gl_max);
 726     gl_info->max_lights = gl_max;
 727     TRACE_(d3d_caps)("Lights support - max lights=%d\n", gl_max);
 728
 729     glGetIntegerv(GL_MAX_TEXTURE_SIZE, &gl_max);
 730     gl_info->max_texture_size = gl_max;
 731     TRACE_(d3d_caps)("Maximum texture size support - max texture size=%d\n", gl_max);
 732
 733     glGetFloatv(GL_POINT_SIZE_RANGE, gl_floatv);
 734     gl_info->max_pointsizemin = gl_floatv[0];
 735     gl_info->max_pointsize = gl_floatv[1];
 736     TRACE_(d3d_caps)("Maximum point size support - max point size=%f\n", gl_floatv[1]);
 737
 738     /* Parse the gl supported features, in theory enabling parts of our code appropriately */
 739     GL_Extensions = (const char *) glGetString(GL_EXTENSIONS);
 740     TRACE_(d3d_caps)("GL_Extensions reported:\n");
 741
 742     if (NULL == GL_Extensions) {
 743         ERR("   GL_Extensions returns NULL\n");
 744     } else {
 745         while (*GL_Extensions != 0x00) {
 746             const char *Start;
 747             char        ThisExtn[256];
 748             size_t      len;
 749
 750             while (isspace(*GL_Extensions)) GL_Extensions++;
 751             Start = GL_Extensions;
 752             while (!isspace(*GL_Extensions) && *GL_Extensions != 0x00) {
 753                 GL_Extensions++;
 754             }
 755
 756             len = GL_Extensions - Start;
 757             if (len == 0 || len >= sizeof(ThisExtn))
 758                 continue;
 759
 760             memcpy(ThisExtn, Start, len);
 761             ThisExtn[len] = '\0';
 762             TRACE_(d3d_caps)("- %s\n", ThisExtn);
 763
 764             for (i = 0; i < (sizeof(EXTENSION_MAP) / sizeof(*EXTENSION_MAP)); ++i) {
 765                 if (!strcmp(ThisExtn, EXTENSION_MAP[i].extension_string)) {
 766                     TRACE_(d3d_caps)(" FOUND: %s support\n", EXTENSION_MAP[i].extension_string);
 767                     gl_info->supported[EXTENSION_MAP[i].extension] = TRUE;
 768                     break;
 769                 }
 770             }
 771         }
 772
 773         LEAVE_GL();
 774
 775         /* Now work out what GL support this card really has */
 776 #define USE_GL_FUNC(type, pfn, ext, replace) { \
 777             DWORD ver = ver_for_ext(ext); \
 778             if(gl_info->supported[ext]) gl_info->pfn = (type) pwglGetProcAddress(#pfn); \
 779             else if(ver && ver <= gl_info->gl_version) gl_info->pfn = (type) pwglGetProcAddress(#replace); \
 780             else gl_info->pfn = NULL; \
 781         }
 782         GL_EXT_FUNCS_GEN;
 783 #undef USE_GL_FUNC
 784
 785 #define USE_GL_FUNC(type, pfn, ext, replace) gl_info->pfn = (type) pwglGetProcAddress(#pfn);
 786         WGL_EXT_FUNCS_GEN;
 787 #undef USE_GL_FUNC
 788
 789         ENTER_GL();
 790         /* Now mark all the extensions supported which are included in the opengl core version. Do this *after*
 791          * loading the functions, otherwise the code above will load the extension entry points instead of the
 792          * core functions, which may not work
 793          */
 794         for (i = 0; i < (sizeof(EXTENSION_MAP) / sizeof(*EXTENSION_MAP)); ++i) {
 795             if (gl_info->supported[EXTENSION_MAP[i].extension] == FALSE &&
 796                 EXTENSION_MAP[i].version <= gl_info->gl_version && EXTENSION_MAP[i].version) {
 797                 TRACE_(d3d_caps)(" GL CORE: %s support\n", EXTENSION_MAP[i].extension_string);
 798                 gl_info->supported[EXTENSION_MAP[i].extension] = TRUE;
 799             }
 800         }
 801
 802         if (gl_info->supported[APPLE_FENCE]) {
 803             /* GL_NV_fence and GL_APPLE_fence provide the same functionality basically.
 804              * The apple extension interacts with some other apple exts. Disable the NV
 805              * extension if the apple one is support to prevent confusion in other parts
 806              * of the code
 807              */
 808             gl_info->supported[NV_FENCE] = FALSE;
 809         }
 810         if (gl_info->supported[APPLE_FLOAT_PIXELS]) {
 811             /* GL_APPLE_float_pixels == GL_ARB_texture_float + GL_ARB_half_float_pixel
 812              *
 813              * The enums are the same:
 814              * GL_RGBA16F_ARB     = GL_RGBA_FLOAT16_APPLE = 0x881A
 815              * GL_RGB16F_ARB      = GL_RGB_FLOAT16_APPLE  = 0x881B
 816              * GL_RGBA32F_ARB     = GL_RGBA_FLOAT32_APPLE = 0x8814
 817              * GL_RGB32F_ARB      = GL_RGB_FLOAT32_APPLE  = 0x8815
 818              * GL_HALF_FLOAT_ARB  = GL_HALF_APPLE         =  0x140B
 819              */
 820             if(!gl_info->supported[ARB_TEXTURE_FLOAT]) {
 821                 TRACE_(d3d_caps)(" IMPLIED: GL_ARB_texture_float support(from GL_APPLE_float_pixels\n");
 822                 gl_info->supported[ARB_TEXTURE_FLOAT] = TRUE;
 823             }
 824             if(!gl_info->supported[ARB_HALF_FLOAT_PIXEL]) {
 825                 TRACE_(d3d_caps)(" IMPLIED: GL_ARB_half_float_pixel support(from GL_APPLE_float_pixels\n");
 826                 gl_info->supported[ARB_HALF_FLOAT_PIXEL] = TRUE;
 827             }
 828         }
 829         if (gl_info->supported[ARB_TEXTURE_CUBE_MAP]) {
 830             TRACE_(d3d_caps)(" IMPLIED: NVIDIA (NV) Texture Gen Reflection support\n");
 831             gl_info->supported[NV_TEXGEN_REFLECTION] = TRUE;
 832         }
 833         if (gl_info->supported[NV_TEXTURE_SHADER2]) {
 834             /* GL_ATI_envmap_bumpmap won't play nice with texture shaders, so disable it
 835              * Won't occur in any real world situation though
 836              */
 837             gl_info->supported[ATI_ENVMAP_BUMPMAP] = FALSE;
 838             if(gl_info->supported[NV_REGISTER_COMBINERS]) {
 839                 /* Also disable ATI_FRAGMENT_SHADER if register combiners and texture_shader2
 840                  * are supported. The nv extensions provide the same functionality as the
 841                  * ATI one, and a bit more(signed pixelformats)
 842                  */
 843                 gl_info->supported[ATI_FRAGMENT_SHADER] = FALSE;
 844             }
 845         }
 846         if (gl_info->supported[ARB_DRAW_BUFFERS]) {
 847             glGetIntegerv(GL_MAX_DRAW_BUFFERS_ARB, &gl_max);
 848             gl_info->max_buffers = gl_max;
 849             TRACE_(d3d_caps)("Max draw buffers: %u\n", gl_max);
 850         }
 851         if (gl_info->supported[ARB_MULTITEXTURE]) {
 852             glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &gl_max);
 853             gl_info->max_textures = min(MAX_TEXTURES, gl_max);
 854             TRACE_(d3d_caps)("Max textures: %d\n", gl_info->max_textures);
 855
 856             if (gl_info->supported[NV_REGISTER_COMBINERS]) {
 857                 GLint tmp;
 858                 glGetIntegerv(GL_MAX_GENERAL_COMBINERS_NV, &tmp);
 859                 gl_info->max_texture_stages = min(MAX_TEXTURES, tmp);
 860             } else {
 861                 gl_info->max_texture_stages = min(MAX_TEXTURES, gl_max);
 862             }
 863             TRACE_(d3d_caps)("Max texture stages: %d\n", gl_info->max_texture_stages);
 864
 865             if (gl_info->supported[ARB_FRAGMENT_PROGRAM]) {
 866                 GLint tmp;
 867                 glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS_ARB, &tmp);
 868                 gl_info->max_fragment_samplers = min(MAX_FRAGMENT_SAMPLERS, tmp);
 869             } else {
 870                 gl_info->max_fragment_samplers = max(gl_info->max_fragment_samplers, gl_max);
 871             }
 872             TRACE_(d3d_caps)("Max fragment samplers: %d\n", gl_info->max_fragment_samplers);
 873
 874             if (gl_info->supported[ARB_VERTEX_SHADER]) {
 875                 GLint tmp;
 876                 glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB, &tmp);
 877                 gl_info->max_vertex_samplers = tmp;
 878                 glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB, &tmp);
 879                 gl_info->max_combined_samplers = tmp;
 880
 881                 /* Loading GLSL sampler uniforms is much simpler if we can assume that the sampler setup
 882                  * is known at shader link time. In a vertex shader + pixel shader combination this isn't
 883                  * an issue because then the sampler setup only depends on the two shaders. If a pixel
 884                  * shader is used with fixed function vertex processing we're fine too because fixed function
 885                  * vertex processing doesn't use any samplers. If fixed function fragment processing is
 886                  * used we have to make sure that all vertex sampler setups are valid together with all
 887                  * possible fixed function fragment processing setups. This is true if vsamplers + MAX_TEXTURES
 888                  * <= max_samplers. This is true on all d3d9 cards that support vtf(gf 6 and gf7 cards).
 889                  * dx9 radeon cards do not support vertex texture fetch. DX10 cards have 128 samplers, and
 890                  * dx9 is limited to 8 fixed function texture stages and 4 vertex samplers. DX10 does not have
 891                  * a fixed function pipeline anymore.
 892                  *
 893                  * So this is just a check to check that our assumption holds true. If not, write a warning
 894                  * and reduce the number of vertex samplers or probably disable vertex texture fetch.
 895                  */
 896                 if(gl_info->max_vertex_samplers &&
 897                    MAX_TEXTURES + gl_info->max_vertex_samplers > gl_info->max_combined_samplers) {
 898                     FIXME("OpenGL implementation supports %u vertex samplers and %u total samplers\n",
 899                           gl_info->max_vertex_samplers, gl_info->max_combined_samplers);
 900                     FIXME("Expected vertex samplers + MAX_TEXTURES(=8) > combined_samplers\n");
 901                     if( gl_info->max_combined_samplers > MAX_TEXTURES )
 902                         gl_info->max_vertex_samplers =
 903                             gl_info->max_combined_samplers - MAX_TEXTURES;
 904                     else
 905                         gl_info->max_vertex_samplers = 0;
 906                 }
 907             } else {
 908                 gl_info->max_combined_samplers = gl_info->max_fragment_samplers;
 909             }
 910             TRACE_(d3d_caps)("Max vertex samplers: %u\n", gl_info->max_vertex_samplers);
 911             TRACE_(d3d_caps)("Max combined samplers: %u\n", gl_info->max_combined_samplers);
 912         }
 913         if (gl_info->supported[ARB_VERTEX_BLEND]) {
 914             glGetIntegerv(GL_MAX_VERTEX_UNITS_ARB, &gl_max);
 915             gl_info->max_blends = gl_max;
 916             TRACE_(d3d_caps)("Max blends: %u\n", gl_info->max_blends);
 917         }
 918         if (gl_info->supported[EXT_TEXTURE3D]) {
 919             glGetIntegerv(GL_MAX_3D_TEXTURE_SIZE_EXT, &gl_max);
 920             gl_info->max_texture3d_size = gl_max;
 921             TRACE_(d3d_caps)("Max texture3D size: %d\n", gl_info->max_texture3d_size);
 922         }
 923         if (gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC]) {
 924             glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &gl_max);
 925             gl_info->max_anisotropy = gl_max;
 926             TRACE_(d3d_caps)("Max anisotropy: %d\n", gl_info->max_anisotropy);
 927         }
 928         if (gl_info->supported[ARB_FRAGMENT_PROGRAM]) {
 929             gl_info->ps_arb_version = PS_VERSION_11;
 930             GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max));
 931             gl_info->ps_arb_constantsF = gl_max;
 932             TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM float constants: %d\n", gl_info->ps_arb_constantsF);
 933             GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, &gl_max));
 934             gl_info->ps_arb_max_temps = gl_max;
 935             TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM native temporaries: %d\n", gl_info->ps_arb_max_temps);
 936             GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, &gl_max));
 937             gl_info->ps_arb_max_instructions = gl_max;
 938             TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM native instructions: %d\n", gl_info->ps_arb_max_instructions);
 939         }
 940         if (gl_info->supported[ARB_VERTEX_PROGRAM]) {
 941             gl_info->vs_arb_version = VS_VERSION_11;
 942             GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max));
 943             gl_info->vs_arb_constantsF = gl_max;
 944             TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM float constants: %d\n", gl_info->vs_arb_constantsF);
 945             GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, &gl_max));
 946             gl_info->vs_arb_max_temps = gl_max;
 947             TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM native temporaries: %d\n", gl_info->vs_arb_max_temps);
 948             GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, &gl_max));
 949             gl_info->vs_arb_max_instructions = gl_max;
 950             TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM native instructions: %d\n", gl_info->vs_arb_max_instructions);
 951
 952             gl_info->arb_vs_offset_limit = test_arb_vs_offset_limit(gl_info);
 953         }
 954         if (gl_info->supported[ARB_VERTEX_SHADER]) {
 955             glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB, &gl_max);
 956             gl_info->vs_glsl_constantsF = gl_max / 4;
 957             TRACE_(d3d_caps)("Max ARB_VERTEX_SHADER float constants: %u\n", gl_info->vs_glsl_constantsF);
 958         }
 959         if (gl_info->supported[ARB_FRAGMENT_SHADER]) {
 960             glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB, &gl_max);
 961             gl_info->ps_glsl_constantsF = gl_max / 4;
 962             TRACE_(d3d_caps)("Max ARB_FRAGMENT_SHADER float constants: %u\n", gl_info->ps_glsl_constantsF);
 963             glGetIntegerv(GL_MAX_VARYING_FLOATS_ARB, &gl_max);
 964             gl_info->max_glsl_varyings = gl_max;
 965             TRACE_(d3d_caps)("Max GLSL varyings: %u (%u 4 component varyings)\n", gl_max, gl_max / 4);
 966         }
 967         if (gl_info->supported[EXT_VERTEX_SHADER]) {
 968             gl_info->vs_ati_version = VS_VERSION_11;
 969         }
 970         if (gl_info->supported[NV_VERTEX_PROGRAM3]) {
 971             gl_info->vs_nv_version = VS_VERSION_30;
 972         } else if (gl_info->supported[NV_VERTEX_PROGRAM2]) {
 973             gl_info->vs_nv_version = VS_VERSION_20;
 974         } else if (gl_info->supported[NV_VERTEX_PROGRAM1_1]) {
 975             gl_info->vs_nv_version = VS_VERSION_11;
 976         } else if (gl_info->supported[NV_VERTEX_PROGRAM]) {
 977             gl_info->vs_nv_version = VS_VERSION_10;
 978         }
 979         if (gl_info->supported[NV_FRAGMENT_PROGRAM2]) {
 980             gl_info->ps_nv_version = PS_VERSION_30;
 981         } else if (gl_info->supported[NV_FRAGMENT_PROGRAM]) {
 982             gl_info->ps_nv_version = PS_VERSION_20;
 983         }
 984         if (gl_info->supported[NV_LIGHT_MAX_EXPONENT]) {
 985             glGetFloatv(GL_MAX_SHININESS_NV, &gl_info->max_shininess);
 986         } else {
 987             gl_info->max_shininess = 128.0;
 988         }
 989         if (gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO]) {
 990             /* If we have full NP2 texture support, disable GL_ARB_texture_rectangle because we will never use it.
 991              * This saves a few redundant glDisable calls
 992              */
 993             gl_info->supported[ARB_TEXTURE_RECTANGLE] = FALSE;
 994         }
 995         if(gl_info->supported[ATI_FRAGMENT_SHADER]) {
 996             /* Disable NV_register_combiners and fragment shader if this is supported.
 997              * generally the NV extensions are preferred over the ATI ones, and this
 998              * extension is disabled if register_combiners and texture_shader2 are both
 999              * supported. So we reach this place only if we have incomplete NV dxlevel 8
1000              * fragment processing support
1001              */
1002             gl_info->supported[NV_REGISTER_COMBINERS] = FALSE;
1003             gl_info->supported[NV_REGISTER_COMBINERS2] = FALSE;
1004             gl_info->supported[NV_TEXTURE_SHADER] = FALSE;
1005             gl_info->supported[NV_TEXTURE_SHADER2] = FALSE;
1006             gl_info->supported[NV_TEXTURE_SHADER3] = FALSE;
1007         }
1008
1009     }
1010     checkGLcall("extension detection\n");
1011
1012     /* In some cases the number of texture stages can be larger than the number
1013      * of samplers. The GF4 for example can use only 2 samplers (no fragment
1014      * shaders), but 8 texture stages (register combiners). */
1015     gl_info->max_sampler_stages = max(gl_info->max_fragment_samplers, gl_info->max_texture_stages);
1016
1017     /* We can only use ORM_FBO when the hardware supports it. */
1018     if (wined3d_settings.offscreen_rendering_mode == ORM_FBO && !gl_info->supported[EXT_FRAMEBUFFER_OBJECT]) {
1019         WARN_(d3d_caps)("GL_EXT_framebuffer_object not supported, falling back to PBuffer offscreen rendering mode.\n");
1020         wined3d_settings.offscreen_rendering_mode = ORM_PBUFFER;
1021     }
1022
1023     /* MRTs are currently only supported when FBOs are used. */
1024     if (wined3d_settings.offscreen_rendering_mode != ORM_FBO) {
1025         gl_info->max_buffers = 1;
1026     }
1027
1028     /* Below is a list of Nvidia and ATI GPUs. Both vendors have dozens of different GPUs with roughly the same
1029      * features. In most cases GPUs from a certain family differ in clockspeeds, the amount of video memory and
1030      * in case of the latest videocards in the number of pixel/vertex pipelines.
1031      *
1032      * A Direct3D device object contains the PCI id (vendor + device) of the videocard which is used for
1033      * rendering. Various games use this information to get a rough estimation of the features of the card
1034      * and some might use it for enabling 3d effects only on certain types of videocards. In some cases
1035      * games might even use it to work around bugs which happen on certain videocards/driver combinations.
1036      * The problem is that OpenGL only exposes a rendering string containing the name of the videocard and
1037      * not the PCI id.
1038      *
1039      * Various games depend on the PCI id, so somehow we need to provide one. A simple option is to parse
1040      * the renderer string and translate this to the right PCI id. This is a lot of work because there are more
1041      * than 200 GPUs just for Nvidia. Various cards share the same renderer string, so the amount of code might
1042      * be 'small' but there are quite a number of exceptions which would make this a pain to maintain.
1043      * Another way would be to query the PCI id from the operating system (assuming this is the videocard which
1044      * is used for rendering which is not always the case). This would work but it is not very portable. Second
1045      * it would not work well in, let's say, a remote X situation in which the amount of 3d features which can be used
1046      * is limited.
1047      *
1048      * As said most games only use the PCI id to get an indication of the capabilities of the card.
1049      * It doesn't really matter if the given id is the correct one if we return the id of a card with
1050      * similar 3d features.
1051      *
1052      * The code below checks the OpenGL capabilities of a videocard and matches that to a certain level of
1053      * Direct3D functionality. Once a card passes the Direct3D9 check, we know that the card (in case of Nvidia)
1054      * is at least a GeforceFX. To give a better estimate we do a basic check on the renderer string but if that
1055      * won't pass we return a default card. This way is better than maintaining a full card database as even
1056      * without a full database we can return a card with similar features. Second the size of the database
1057      * can be made quite small because when you know what type of 3d functionality a card has, you know to which
1058      * GPU family the GPU must belong. Because of this you only have to check a small part of the renderer string
1059      * to distinguishes between different models from that family.
1060      *
1061      * The code also selects a default amount of video memory which we will use for an estimation of the amount
1062      * of free texture memory. In case of real D3D the amount of texture memory includes video memory and system
1063      * memory (to be specific AGP memory or in case of PCIE TurboCache/HyperMemory). We don't know how much
1064      * system memory can be addressed by the system but we can make a reasonable estimation about the amount of
1065      * video memory. If the value is slightly wrong it doesn't matter as we didn't include AGP-like memory which
1066      * makes the amount of addressable memory higher and second OpenGL isn't that critical it moves to system
1067      * memory behind our backs if really needed.
1068      * Note that the amount of video memory can be overruled using a registry setting.
1069      */
1070     switch (gl_info->gl_vendor) {
1071         case VENDOR_NVIDIA:
1072             /* Both the GeforceFX, 6xxx and 7xxx series support D3D9. The last two types have more
1073              * shader capabilities, so we use the shader capabilities to distinguish between FX and 6xxx/7xxx.
1074              */
1075             if(WINE_D3D9_CAPABLE(gl_info) && (gl_info->vs_nv_version == VS_VERSION_30)) {
1076                 /* Geforce9 - highend */
1077                 if(strstr(gl_info->gl_renderer, "9800")) {
1078                     gl_info->gl_card = CARD_NVIDIA_GEFORCE_9800GT;
1079                     vidmem = 512;
1080                 }
1081                 /* Geforce9 - midend */
1082                 else if(strstr(gl_info->gl_renderer, "9600")) {
1083                     gl_info->gl_card = CARD_NVIDIA_GEFORCE_9600GT;
1084                     vidmem = 384; /* The 9600GSO has 384MB, the 9600GT has 512-1024MB */
1085                 }
1086                 /* Geforce8 - highend */
1087                 if (strstr(gl_info->gl_renderer, "8800")) {
1088                     gl_info->gl_card = CARD_NVIDIA_GEFORCE_8800GTS;
1089                     vidmem = 320; /* The 8800GTS uses 320MB, a 8800GTX can have 768MB */
1090                 }
1091                 /* Geforce8 - midend mobile */
1092                 else if(strstr(gl_info->gl_renderer, "8600 M")) {
1093                     gl_info->gl_card = CARD_NVIDIA_GEFORCE_8600MGT;
1094                     vidmem = 512;
1095                 }
1096                 /* Geforce8 - midend */
1097                 else if(strstr(gl_info->gl_renderer, "8600") ||
1098                         strstr(gl_info->gl_renderer, "8700"))
1099                 {
1100                     gl_info->gl_card = CARD_NVIDIA_GEFORCE_8600GT;
1101                     vidmem = 256;
1102                 }
1103                 /* Geforce8 - lowend */
1104                 else if(strstr(gl_info->gl_renderer, "8300") ||
1105                         strstr(gl_info->gl_renderer, "8400") ||
1106                         strstr(gl_info->gl_renderer, "8500"))
1107                 {
1108                     gl_info->gl_card = CARD_NVIDIA_GEFORCE_8300GS;
1109                     vidmem = 128; /* 128-256MB for a 8300, 256-512MB for a 8400 */
1110                 }
1111                 /* Geforce7 - highend */
1112                 else if(strstr(gl_info->gl_renderer, "7800") ||
1113                         strstr(gl_info->gl_renderer, "7900") ||
1114                         strstr(gl_info->gl_renderer, "7950") ||
1115                         strstr(gl_info->gl_renderer, "Quadro FX 4") ||
1116                         strstr(gl_info->gl_renderer, "Quadro FX 5"))
1117                 {
1118                     gl_info->gl_card = CARD_NVIDIA_GEFORCE_7800GT;
1119                     vidmem = 256; /* A 7800GT uses 256MB while highend 7900 cards can use 512MB */
1120                 }
1121                 /* Geforce7 midend */
1122                 else if(strstr(gl_info->gl_renderer, "7600") ||
1123                         strstr(gl_info->gl_renderer, "7700")) {
1124                     gl_info->gl_card = CARD_NVIDIA_GEFORCE_7600;
1125                     vidmem = 256; /* The 7600 uses 256-512MB */
1126                 /* Geforce7 lower medium */
1127                 } else if(strstr(gl_info->gl_renderer, "7400")) {
1128                     gl_info->gl_card = CARD_NVIDIA_GEFORCE_7400;
1129                     vidmem = 256; /* The 7400 uses 256-512MB */
1130                 }
1131                 /* Geforce7 lowend */
1132                 else if(strstr(gl_info->gl_renderer, "7300")) {
1133                     gl_info->gl_card = CARD_NVIDIA_GEFORCE_7300;
1134                     vidmem = 256; /* Mac Pros with this card have 256 MB */
1135                 }
1136                 /* Geforce6 highend */
1137                 else if(strstr(gl_info->gl_renderer, "6800"))
1138                 {
1139                     gl_info->gl_card = CARD_NVIDIA_GEFORCE_6800;
1140                     vidmem = 128; /* The 6800 uses 128-256MB, the 7600 uses 256-512MB */
1141                 }
1142                 /* Geforce6 - midend */
1143                 else if(strstr(gl_info->gl_renderer, "6600") ||
1144                         strstr(gl_info->gl_renderer, "6610") ||
1145                         strstr(gl_info->gl_renderer, "6700"))
1146                 {
1147                     gl_info->gl_card = CARD_NVIDIA_GEFORCE_6600GT;
1148                     vidmem = 128; /* A 6600GT has 128-256MB */
1149                 }
1150                 /* Geforce6/7 lowend */
1151                 else {
1152                     gl_info->gl_card = CARD_NVIDIA_GEFORCE_6200; /* Geforce 6100/6150/6200/7300/7400/7500 */
1153                     vidmem = 64; /* */
1154                 }
1155             } else if(WINE_D3D9_CAPABLE(gl_info)) {
1156                 /* GeforceFX - highend */
1157                 if (strstr(gl_info->gl_renderer, "5800") ||
1158                     strstr(gl_info->gl_renderer, "5900") ||
1159                     strstr(gl_info->gl_renderer, "5950") ||
1160                     strstr(gl_info->gl_renderer, "Quadro FX"))
1161                 {
1162                     gl_info->gl_card = CARD_NVIDIA_GEFORCEFX_5800;
1163                     vidmem = 256; /* 5800-5900 cards use 256MB */
1164                 }
1165                 /* GeforceFX - midend */
1166                 else if(strstr(gl_info->gl_renderer, "5600") ||
1167                         strstr(gl_info->gl_renderer, "5650") ||
1168                         strstr(gl_info->gl_renderer, "5700") ||
1169                         strstr(gl_info->gl_renderer, "5750"))
1170                 {
1171                     gl_info->gl_card = CARD_NVIDIA_GEFORCEFX_5600;
1172                     vidmem = 128; /* A 5600 uses 128-256MB */
1173                 }
1174                 /* GeforceFX - lowend */
1175                 else {
1176                     gl_info->gl_card = CARD_NVIDIA_GEFORCEFX_5200; /* GeforceFX 5100/5200/5250/5300/5500 */
1177                     vidmem = 64; /* Normal FX5200 cards use 64-256MB; laptop (non-standard) can have less */
1178                 }
1179             } else if(WINE_D3D8_CAPABLE(gl_info)) {
1180                 if (strstr(gl_info->gl_renderer, "GeForce4 Ti") || strstr(gl_info->gl_renderer, "Quadro4")) {
1181                     gl_info->gl_card = CARD_NVIDIA_GEFORCE4_TI4200; /* Geforce4 Ti4200/Ti4400/Ti4600/Ti4800, Quadro4 */
1182                     vidmem = 64; /* Geforce4 Ti cards have 64-128MB */
1183                 }
1184                 else {
1185                     gl_info->gl_card = CARD_NVIDIA_GEFORCE3; /* Geforce3 standard/Ti200/Ti500, Quadro DCC */
1186                     vidmem = 64; /* Geforce3 cards have 64-128MB */
1187                 }
1188             } else if(WINE_D3D7_CAPABLE(gl_info)) {
1189                 if (strstr(gl_info->gl_renderer, "GeForce4 MX")) {
1190                     gl_info->gl_card = CARD_NVIDIA_GEFORCE4_MX; /* MX420/MX440/MX460/MX4000 */
1191                     vidmem = 64; /* Most Geforce4MX GPUs have at least 64MB of memory, some early models had 32MB but most have 64MB or even 128MB */
1192                 }
1193                 else if(strstr(gl_info->gl_renderer, "GeForce2 MX") || strstr(gl_info->gl_renderer, "Quadro2 MXR")) {
1194                     gl_info->gl_card = CARD_NVIDIA_GEFORCE2_MX; /* Geforce2 standard/MX100/MX200/MX400, Quadro2 MXR */
1195                     vidmem = 32; /* Geforce2MX GPUs have 32-64MB of video memory */
1196                 }
1197                 else if(strstr(gl_info->gl_renderer, "GeForce2") || strstr(gl_info->gl_renderer, "Quadro2")) {
1198                     gl_info->gl_card = CARD_NVIDIA_GEFORCE2; /* Geforce2 GTS/Pro/Ti/Ultra, Quadro2 */
1199                     vidmem = 32; /* Geforce2 GPUs have 32-64MB of video memory */
1200                 }
1201                 else {
1202                     gl_info->gl_card = CARD_NVIDIA_GEFORCE; /* Geforce 256/DDR, Quadro */
1203                     vidmem = 32; /* Most Geforce1 cards have 32MB, there are also some rare 16 and 64MB (Dell) models */
1204                 }
1205             } else {
1206                 if (strstr(gl_info->gl_renderer, "TNT2")) {
1207                     gl_info->gl_card = CARD_NVIDIA_RIVA_TNT2; /* Riva TNT2 standard/M64/Pro/Ultra */
1208                     vidmem = 32; /* Most TNT2 boards have 32MB, though there are 16MB boards too */
1209                 }
1210                 else {
1211                     gl_info->gl_card = CARD_NVIDIA_RIVA_TNT; /* Riva TNT, Vanta */
1212                     vidmem = 16; /* Most TNT boards have 16MB, some rare models have 8MB */
1213                 }
1214             }
1215             break;
1216         case VENDOR_ATI:
1217             if(WINE_D3D9_CAPABLE(gl_info)) {
1218                 /* Radeon R6xx HD2900/HD3800 - highend */
1219                 if (strstr(gl_info->gl_renderer, "HD 2900") ||
1220                     strstr(gl_info->gl_renderer, "HD 3870") ||
1221                     strstr(gl_info->gl_renderer, "HD 3850"))
1222                 {
1223                     gl_info->gl_card = CARD_ATI_RADEON_HD2900;
1224                     vidmem = 512; /* HD2900/HD3800 uses 256-1024MB */
1225                 }
1226                 /* Radeon R6xx HD2600/HD3600 - midend; HD3830 is China-only midend */
1227                 else if (strstr(gl_info->gl_renderer, "HD 2600") ||
1228                          strstr(gl_info->gl_renderer, "HD 3830") ||
1229                          strstr(gl_info->gl_renderer, "HD 3690") ||
1230                          strstr(gl_info->gl_renderer, "HD 3650"))
1231                 {
1232                     gl_info->gl_card = CARD_ATI_RADEON_HD2600;
1233                     vidmem = 256; /* HD2600/HD3600 uses 256-512MB */
1234                 }
1235                 /* Radeon R6xx HD2300/HD2400/HD3400 - lowend */
1236                 else if (strstr(gl_info->gl_renderer, "HD 2300") ||
1237                          strstr(gl_info->gl_renderer, "HD 2400") ||
1238                          strstr(gl_info->gl_renderer, "HD 3470") ||
1239                          strstr(gl_info->gl_renderer, "HD 3450") ||
1240                          strstr(gl_info->gl_renderer, "HD 3430"))
1241                 {
1242                     gl_info->gl_card = CARD_ATI_RADEON_HD2300;
1243                     vidmem = 128; /* HD2300 uses at least 128MB, HD2400 uses 256MB */
1244                 }
1245                 /* Radeon R6xx/R7xx integrated */
1246                 else if (strstr(gl_info->gl_renderer, "HD 3100") ||
1247                          strstr(gl_info->gl_renderer, "HD 3200") ||
1248                          strstr(gl_info->gl_renderer, "HD 3300"))
1249                 {
1250                     gl_info->gl_card = CARD_ATI_RADEON_HD3200;
1251                     vidmem = 128; /* 128MB */
1252                 }
1253                 /* Radeon R5xx */
1254                 else if (strstr(gl_info->gl_renderer, "X1600") ||
1255                          strstr(gl_info->gl_renderer, "X1650") ||
1256                          strstr(gl_info->gl_renderer, "X1800") ||
1257                          strstr(gl_info->gl_renderer, "X1900") ||
1258                          strstr(gl_info->gl_renderer, "X1950"))
1259                 {
1260                     gl_info->gl_card = CARD_ATI_RADEON_X1600;
1261                     vidmem = 128; /* X1600 uses 128-256MB, >=X1800 uses 256MB */
1262                 }
1263                 /* Radeon R4xx + X1300/X1400/X1450/X1550/X2300 (lowend R5xx) */
1264                 else if(strstr(gl_info->gl_renderer, "X700") ||
1265                         strstr(gl_info->gl_renderer, "X800") ||
1266                         strstr(gl_info->gl_renderer, "X850") ||
1267                         strstr(gl_info->gl_renderer, "X1300") ||
1268                         strstr(gl_info->gl_renderer, "X1400") ||
1269                         strstr(gl_info->gl_renderer, "X1450") ||
1270                         strstr(gl_info->gl_renderer, "X1550"))
1271                 {
1272                     gl_info->gl_card = CARD_ATI_RADEON_X700;
1273                     vidmem = 128; /* x700/x8*0 use 128-256MB, >=x1300 128-512MB */
1274                 }
1275                 /* Radeon R3xx */
1276                 else {
1277                     gl_info->gl_card = CARD_ATI_RADEON_9500; /* Radeon 9500/9550/9600/9700/9800/X300/X550/X600 */
1278                     vidmem = 64; /* Radeon 9500 uses 64MB, higher models use up to 256MB */
1279                 }
1280             } else if(WINE_D3D8_CAPABLE(gl_info)) {
1281                 gl_info->gl_card = CARD_ATI_RADEON_8500; /* Radeon 8500/9000/9100/9200/9300 */
1282                 vidmem = 64; /* 8500/9000 cards use mostly 64MB, though there are 32MB and 128MB models */
1283             } else if(WINE_D3D7_CAPABLE(gl_info)) {
1284                 gl_info->gl_card = CARD_ATI_RADEON_7200; /* Radeon 7000/7100/7200/7500 */
1285                 vidmem = 32; /* There are models with up to 64MB */
1286             } else {
1287                 gl_info->gl_card = CARD_ATI_RAGE_128PRO;
1288                 vidmem = 16; /* There are 16-32MB models */
1289             }
1290             break;
1291         case VENDOR_INTEL:
1292             if (strstr(gl_info->gl_renderer, "GMA 950")) {
1293                 /* MacOS calls the card GMA 950, but everywhere else the PCI ID is named 945GM */
1294                 gl_info->gl_card = CARD_INTEL_I945GM;
1295                 vidmem = 64;
1296             } else if (strstr(gl_info->gl_renderer, "915GM")) {
1297                 gl_info->gl_card = CARD_INTEL_I915GM;
1298             } else if (strstr(gl_info->gl_renderer, "915G")) {
1299                 gl_info->gl_card = CARD_INTEL_I915G;
1300             } else if (strstr(gl_info->gl_renderer, "865G")) {
1301                 gl_info->gl_card = CARD_INTEL_I865G;
1302             } else if (strstr(gl_info->gl_renderer, "855G")) {
1303                 gl_info->gl_card = CARD_INTEL_I855G;
1304             } else if (strstr(gl_info->gl_renderer, "830G")) {
1305                 gl_info->gl_card = CARD_INTEL_I830G;
1306             } else {
1307                 gl_info->gl_card = CARD_INTEL_I915G;
1308             }
1309             break;
1310         case VENDOR_MESA:
1311         case VENDOR_WINE:
1312         default:
1313             /* Default to generic Nvidia hardware based on the supported OpenGL extensions. The choice
1314              * for Nvidia was because the hardware and drivers they make are of good quality. This makes
1315              * them a good generic choice.
1316              */
1317             gl_info->gl_vendor = VENDOR_NVIDIA;
1318             if(WINE_D3D9_CAPABLE(gl_info))
1319                 gl_info->gl_card = CARD_NVIDIA_GEFORCEFX_5600;
1320             else if(WINE_D3D8_CAPABLE(gl_info))
1321                 gl_info->gl_card = CARD_NVIDIA_GEFORCE3;
1322             else if(WINE_D3D7_CAPABLE(gl_info))
1323                 gl_info->gl_card = CARD_NVIDIA_GEFORCE;
1324             else if(WINE_D3D6_CAPABLE(gl_info))
1325                 gl_info->gl_card = CARD_NVIDIA_RIVA_TNT;
1326             else
1327                 gl_info->gl_card = CARD_NVIDIA_RIVA_128;
1328     }
1329     TRACE_(d3d_caps)("FOUND (fake) card: 0x%x (vendor id), 0x%x (device id)\n", gl_info->gl_vendor, gl_info->gl_card);
1330
1331     /* If we have an estimate use it, else default to 64MB;  */
1332     if(vidmem)
1333         gl_info->vidmem = vidmem*1024*1024; /* convert from MBs to bytes */
1334     else
1335         gl_info->vidmem = WINE_DEFAULT_VIDMEM;
1336
1337     /* Load all the lookup tables
1338     TODO: It may be a good idea to make minLookup and maxLookup const and populate them in wined3d_private.h where they are declared */
1339     minLookup[WINELOOKUP_WARPPARAM] = WINED3DTADDRESS_WRAP;
1340     maxLookup[WINELOOKUP_WARPPARAM] = WINED3DTADDRESS_MIRRORONCE;
1341
1342     for (i = 0; i < MAX_LOOKUPS; i++) {
1343         stateLookup[i] = HeapAlloc(GetProcessHeap(), 0, sizeof(*stateLookup[i]) * (1 + maxLookup[i] - minLookup[i]) );
1344     }
1345
1346     stateLookup[WINELOOKUP_WARPPARAM][WINED3DTADDRESS_WRAP   - minLookup[WINELOOKUP_WARPPARAM]] = GL_REPEAT;
1347     stateLookup[WINELOOKUP_WARPPARAM][WINED3DTADDRESS_CLAMP  - minLookup[WINELOOKUP_WARPPARAM]] = GL_CLAMP_TO_EDGE;
1348     stateLookup[WINELOOKUP_WARPPARAM][WINED3DTADDRESS_BORDER - minLookup[WINELOOKUP_WARPPARAM]] =
1349              gl_info->supported[ARB_TEXTURE_BORDER_CLAMP] ? GL_CLAMP_TO_BORDER_ARB : GL_REPEAT;
1350     stateLookup[WINELOOKUP_WARPPARAM][WINED3DTADDRESS_BORDER - minLookup[WINELOOKUP_WARPPARAM]] =
1351              gl_info->supported[ARB_TEXTURE_BORDER_CLAMP] ? GL_CLAMP_TO_BORDER_ARB : GL_REPEAT;
1352     stateLookup[WINELOOKUP_WARPPARAM][WINED3DTADDRESS_MIRROR - minLookup[WINELOOKUP_WARPPARAM]] =
1353              gl_info->supported[ARB_TEXTURE_MIRRORED_REPEAT] ? GL_MIRRORED_REPEAT_ARB : GL_REPEAT;
1354     stateLookup[WINELOOKUP_WARPPARAM][WINED3DTADDRESS_MIRRORONCE - minLookup[WINELOOKUP_WARPPARAM]] =
1355              gl_info->supported[ATI_TEXTURE_MIRROR_ONCE] ? GL_MIRROR_CLAMP_TO_EDGE_ATI : GL_REPEAT;
1356
1357     magLookup[WINED3DTEXF_NONE        - WINED3DTEXF_NONE]  = GL_NEAREST;
1358     magLookup[WINED3DTEXF_POINT       - WINED3DTEXF_NONE] = GL_NEAREST;
1359     magLookup[WINED3DTEXF_LINEAR      - WINED3DTEXF_NONE] = GL_LINEAR;
1360     magLookup[WINED3DTEXF_ANISOTROPIC - WINED3DTEXF_NONE] =
1361              gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC] ? GL_LINEAR : GL_NEAREST;
1362
1363
1364     minMipLookup[WINED3DTEXF_NONE][WINED3DTEXF_NONE]     = GL_LINEAR;
1365     minMipLookup[WINED3DTEXF_NONE][WINED3DTEXF_POINT]    = GL_LINEAR;
1366     minMipLookup[WINED3DTEXF_NONE][WINED3DTEXF_LINEAR]   = GL_LINEAR;
1367     minMipLookup[WINED3DTEXF_POINT][WINED3DTEXF_NONE]    = GL_NEAREST;
1368     minMipLookup[WINED3DTEXF_POINT][WINED3DTEXF_POINT]   = GL_NEAREST_MIPMAP_NEAREST;
1369     minMipLookup[WINED3DTEXF_POINT][WINED3DTEXF_LINEAR]  = GL_NEAREST_MIPMAP_LINEAR;
1370     minMipLookup[WINED3DTEXF_LINEAR][WINED3DTEXF_NONE]   = GL_LINEAR;
1371     minMipLookup[WINED3DTEXF_LINEAR][WINED3DTEXF_POINT]  = GL_LINEAR_MIPMAP_NEAREST;
1372     minMipLookup[WINED3DTEXF_LINEAR][WINED3DTEXF_LINEAR] = GL_LINEAR_MIPMAP_LINEAR;
1373     minMipLookup[WINED3DTEXF_ANISOTROPIC][WINED3DTEXF_NONE]   = gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC] ?
1374     GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR;
1375     minMipLookup[WINED3DTEXF_ANISOTROPIC][WINED3DTEXF_POINT]  = gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC] ? GL_LINEAR_MIPMAP_NEAREST : GL_LINEAR;
1376     minMipLookup[WINED3DTEXF_ANISOTROPIC][WINED3DTEXF_LINEAR] = gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC] ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR;
1377
1378 /* TODO: config lookups */
1379
1380     /* Make sure there's an active HDC else the WGL extensions will fail */
1381     hdc = pwglGetCurrentDC();
1382     if (hdc) {
1383         WGL_Extensions = GL_EXTCALL(wglGetExtensionsStringARB(hdc));
1384         TRACE_(d3d_caps)("WGL_Extensions reported:\n");
1385
1386         if (NULL == WGL_Extensions) {
1387             ERR("   WGL_Extensions returns NULL\n");
1388         } else {
1389             while (*WGL_Extensions != 0x00) {
1390                 const char *Start;
1391                 char ThisExtn[256];
1392                 size_t len;
1393
1394                 while (isspace(*WGL_Extensions)) WGL_Extensions++;
1395                 Start = WGL_Extensions;
1396                 while (!isspace(*WGL_Extensions) && *WGL_Extensions != 0x00) {
1397                     WGL_Extensions++;
1398                 }
1399
1400                 len = WGL_Extensions - Start;
1401                 if (len == 0 || len >= sizeof(ThisExtn))
1402                     continue;
1403
1404                 memcpy(ThisExtn, Start, len);
1405                 ThisExtn[len] = '\0';
1406                 TRACE_(d3d_caps)("- %s\n", ThisExtn);
1407
1408                 if (!strcmp(ThisExtn, "WGL_ARB_pbuffer")) {
1409                     gl_info->supported[WGL_ARB_PBUFFER] = TRUE;
1410                     TRACE_(d3d_caps)("FOUND: WGL_ARB_pbuffer support\n");
1411                 }
1412                 if (!strcmp(ThisExtn, "WGL_WINE_pixel_format_passthrough")) {
1413                     gl_info->supported[WGL_WINE_PIXEL_FORMAT_PASSTHROUGH] = TRUE;
1414                     TRACE_(d3d_caps)("FOUND: WGL_WINE_pixel_format_passthrough support\n");
1415                 }
1416             }
1417         }
1418     }
1419     LEAVE_GL();
1420
1421     return return_value;
1422 }
1423 #undef GLINFO_LOCATION
1424
1425 /**********************************************************
1426  * IWineD3D implementation follows
1427  **********************************************************/
1428
1429 static UINT     WINAPI IWineD3DImpl_GetAdapterCount (IWineD3D *iface) {
1430     IWineD3DImpl *This = (IWineD3DImpl *)iface;
1431
1432     TRACE_(d3d_caps)("(%p): Reporting %d adapters\n", This, numAdapters);
1433     return numAdapters;
1434 }
1435
1436 static HRESULT  WINAPI IWineD3DImpl_RegisterSoftwareDevice(IWineD3D *iface, void* pInitializeFunction) {
1437     IWineD3DImpl *This = (IWineD3DImpl *)iface;
1438     FIXME("(%p)->(%p): stub\n", This, pInitializeFunction);
1439     return WINED3D_OK;
1440 }
1441
1442 static HMONITOR WINAPI IWineD3DImpl_GetAdapterMonitor(IWineD3D *iface, UINT Adapter) {
1443     IWineD3DImpl *This = (IWineD3DImpl *)iface;
1444
1445     if (Adapter >= IWineD3DImpl_GetAdapterCount(iface)) {
1446         return NULL;
1447     }
1448
1449     TRACE_(d3d_caps)("(%p)->(%d)\n", This, Adapter);
1450     return MonitorFromPoint(Adapters[Adapter].monitorPoint, MONITOR_DEFAULTTOPRIMARY);
1451 }
1452
1453 /* FIXME: GetAdapterModeCount and EnumAdapterModes currently only returns modes
1454      of the same bpp but different resolutions                                  */
1455
1456 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */
1457 static UINT     WINAPI IWineD3DImpl_GetAdapterModeCount(IWineD3D *iface, UINT Adapter, WINED3DFORMAT Format) {
1458     IWineD3DImpl *This = (IWineD3DImpl *)iface;
1459     TRACE_(d3d_caps)("(%p}->(Adapter: %d, Format: %s)\n", This, Adapter, debug_d3dformat(Format));
1460
1461     if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
1462         return 0;
1463     }
1464
1465     /* TODO: Store modes per adapter and read it from the adapter structure */
1466     if (Adapter == 0) { /* Display */
1467         int i = 0;
1468         int j = 0;
1469
1470         if (!DEBUG_SINGLE_MODE) {
1471             DEVMODEW DevModeW;
1472
1473             ZeroMemory(&DevModeW, sizeof(DevModeW));
1474             DevModeW.dmSize = sizeof(DevModeW);
1475             while (EnumDisplaySettingsExW(NULL, j, &DevModeW, 0)) {
1476                 j++;
1477                 switch (Format)
1478                 {
1479                     case WINED3DFMT_UNKNOWN:
1480                         /* This is for D3D8, do not enumerate P8 here */
1481                         if (DevModeW.dmBitsPerPel == 32 ||
1482                             DevModeW.dmBitsPerPel == 16) i++;
1483                         break;
1484                     case WINED3DFMT_X8R8G8B8:
1485                         if (DevModeW.dmBitsPerPel == 32) i++;
1486                         break;
1487                     case WINED3DFMT_R5G6B5:
1488                         if (DevModeW.dmBitsPerPel == 16) i++;
1489                         break;
1490                     case WINED3DFMT_P8:
1491                         if (DevModeW.dmBitsPerPel == 8) i++;
1492                         break;
1493                     default:
1494                         /* Skip other modes as they do not match the requested format */
1495                         break;
1496                 }
1497             }
1498         } else {
1499             i = 1;
1500             j = 1;
1501         }
1502
1503         TRACE_(d3d_caps)("(%p}->(Adapter: %d) => %d (out of %d)\n", This, Adapter, i, j);
1504         return i;
1505     } else {
1506         FIXME_(d3d_caps)("Adapter not primary display\n");
1507     }
1508     return 0;
1509 }
1510
1511 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */
1512 static HRESULT WINAPI IWineD3DImpl_EnumAdapterModes(IWineD3D *iface, UINT Adapter, WINED3DFORMAT Format, UINT Mode, WINED3DDISPLAYMODE* pMode) {
1513     IWineD3DImpl *This = (IWineD3DImpl *)iface;
1514     TRACE_(d3d_caps)("(%p}->(Adapter:%d, mode:%d, pMode:%p, format:%s)\n", This, Adapter, Mode, pMode, debug_d3dformat(Format));
1515
1516     /* Validate the parameters as much as possible */
1517     if (NULL == pMode ||
1518         Adapter >= IWineD3DImpl_GetAdapterCount(iface) ||
1519         Mode    >= IWineD3DImpl_GetAdapterModeCount(iface, Adapter, Format)) {
1520         return WINED3DERR_INVALIDCALL;
1521     }
1522
1523     /* TODO: Store modes per adapter and read it from the adapter structure */
1524     if (Adapter == 0 && !DEBUG_SINGLE_MODE) { /* Display */
1525         DEVMODEW DevModeW;
1526         int ModeIdx = 0;
1527         int i = 0;
1528         int j = 0;
1529
1530         ZeroMemory(&DevModeW, sizeof(DevModeW));
1531         DevModeW.dmSize = sizeof(DevModeW);
1532
1533         /* If we are filtering to a specific format (D3D9), then need to skip
1534            all unrelated modes, but if mode is irrelevant (D3D8), then we can
1535            just count through the ones with valid bit depths */
1536         while ((i<=Mode) && EnumDisplaySettingsExW(NULL, j++, &DevModeW, 0)) {
1537             switch (Format)
1538             {
1539                 case WINED3DFMT_UNKNOWN:
1540                     /* This is D3D8. Do not enumerate P8 here */
1541                     if (DevModeW.dmBitsPerPel == 32 ||
1542                         DevModeW.dmBitsPerPel == 16) i++;
1543                     break;
1544                 case WINED3DFMT_X8R8G8B8:
1545                     if (DevModeW.dmBitsPerPel == 32) i++;
1546                     break;
1547                 case WINED3DFMT_R5G6B5:
1548                     if (DevModeW.dmBitsPerPel == 16) i++;
1549                     break;
1550                 case WINED3DFMT_P8:
1551                     if (DevModeW.dmBitsPerPel == 8) i++;
1552                     break;
1553                 default:
1554                     /* Modes that don't match what we support can get an early-out */
1555                     TRACE_(d3d_caps)("Searching for %s, returning D3DERR_INVALIDCALL\n", debug_d3dformat(Format));
1556                     return WINED3DERR_INVALIDCALL;
1557             }
1558         }
1559
1560         if (i == 0) {
1561             TRACE_(d3d_caps)("No modes found for format (%x - %s)\n", Format, debug_d3dformat(Format));
1562             return WINED3DERR_INVALIDCALL;
1563         }
1564         ModeIdx = j - 1;
1565
1566         /* Now get the display mode via the calculated index */
1567         if (EnumDisplaySettingsExW(NULL, ModeIdx, &DevModeW, 0)) {
1568             pMode->Width        = DevModeW.dmPelsWidth;
1569             pMode->Height       = DevModeW.dmPelsHeight;
1570             pMode->RefreshRate  = WINED3DADAPTER_DEFAULT;
1571             if (DevModeW.dmFields & DM_DISPLAYFREQUENCY)
1572                 pMode->RefreshRate = DevModeW.dmDisplayFrequency;
1573
1574             if (Format == WINED3DFMT_UNKNOWN) {
1575                 pMode->Format = pixelformat_for_depth(DevModeW.dmBitsPerPel);
1576             } else {
1577                 pMode->Format = Format;
1578             }
1579         } else {
1580             TRACE_(d3d_caps)("Requested mode out of range %d\n", Mode);
1581             return WINED3DERR_INVALIDCALL;
1582         }
1583
1584         TRACE_(d3d_caps)("W %d H %d rr %d fmt (%x - %s) bpp %u\n", pMode->Width, pMode->Height,
1585                 pMode->RefreshRate, pMode->Format, debug_d3dformat(pMode->Format),
1586                 DevModeW.dmBitsPerPel);
1587
1588     } else if (DEBUG_SINGLE_MODE) {
1589         /* Return one setting of the format requested */
1590         if (Mode > 0) return WINED3DERR_INVALIDCALL;
1591         pMode->Width        = 800;
1592         pMode->Height       = 600;
1593         pMode->RefreshRate  = 60;
1594         pMode->Format       = (Format == WINED3DFMT_UNKNOWN) ? WINED3DFMT_X8R8G8B8 : Format;
1595     } else {
1596         FIXME_(d3d_caps)("Adapter not primary display\n");
1597     }
1598
1599     return WINED3D_OK;
1600 }
1601
1602 static HRESULT WINAPI IWineD3DImpl_GetAdapterDisplayMode(IWineD3D *iface, UINT Adapter, WINED3DDISPLAYMODE* pMode) {
1603     IWineD3DImpl *This = (IWineD3DImpl *)iface;
1604     TRACE_(d3d_caps)("(%p}->(Adapter: %d, pMode: %p)\n", This, Adapter, pMode);
1605
1606     if (NULL == pMode ||
1607         Adapter >= IWineD3D_GetAdapterCount(iface)) {
1608         return WINED3DERR_INVALIDCALL;
1609     }
1610
1611     if (Adapter == 0) { /* Display */
1612         int bpp = 0;
1613         DEVMODEW DevModeW;
1614
1615         ZeroMemory(&DevModeW, sizeof(DevModeW));
1616         DevModeW.dmSize = sizeof(DevModeW);
1617
1618         EnumDisplaySettingsExW(NULL, ENUM_CURRENT_SETTINGS, &DevModeW, 0);
1619         pMode->Width        = DevModeW.dmPelsWidth;
1620         pMode->Height       = DevModeW.dmPelsHeight;
1621         bpp                 = DevModeW.dmBitsPerPel;
1622         pMode->RefreshRate  = WINED3DADAPTER_DEFAULT;
1623         if (DevModeW.dmFields&DM_DISPLAYFREQUENCY)
1624         {
1625             pMode->RefreshRate = DevModeW.dmDisplayFrequency;
1626         }
1627
1628         pMode->Format = pixelformat_for_depth(bpp);
1629     } else {
1630         FIXME_(d3d_caps)("Adapter not primary display\n");
1631     }
1632
1633     TRACE_(d3d_caps)("returning w:%d, h:%d, ref:%d, fmt:%s\n", pMode->Width,
1634           pMode->Height, pMode->RefreshRate, debug_d3dformat(pMode->Format));
1635     return WINED3D_OK;
1636 }
1637
1638 /* NOTE: due to structure differences between dx8 and dx9 D3DADAPTER_IDENTIFIER,
1639    and fields being inserted in the middle, a new structure is used in place    */
1640 static HRESULT WINAPI IWineD3DImpl_GetAdapterIdentifier(IWineD3D *iface, UINT Adapter, DWORD Flags,
1641                                                    WINED3DADAPTER_IDENTIFIER* pIdentifier) {
1642     IWineD3DImpl *This = (IWineD3DImpl *)iface;
1643
1644     TRACE_(d3d_caps)("(%p}->(Adapter: %d, Flags: %x, pId=%p)\n", This, Adapter, Flags, pIdentifier);
1645
1646     if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
1647         return WINED3DERR_INVALIDCALL;
1648     }
1649
1650     /* Return the information requested */
1651     TRACE_(d3d_caps)("device/Vendor Name and Version detection using FillGLCaps\n");
1652     strcpy(pIdentifier->Driver, Adapters[Adapter].driver);
1653     strcpy(pIdentifier->Description, Adapters[Adapter].description);
1654
1655     /* Note dx8 doesn't supply a DeviceName */
1656     if (NULL != pIdentifier->DeviceName) strcpy(pIdentifier->DeviceName, "\\\\.\\DISPLAY"); /* FIXME: May depend on desktop? */
1657     pIdentifier->DriverVersion->u.HighPart = Adapters[Adapter].gl_info.driver_version_hipart;
1658     pIdentifier->DriverVersion->u.LowPart = Adapters[Adapter].gl_info.driver_version;
1659     *(pIdentifier->VendorId) = Adapters[Adapter].gl_info.gl_vendor;
1660     *(pIdentifier->DeviceId) = Adapters[Adapter].gl_info.gl_card;
1661     *(pIdentifier->SubSysId) = 0;
1662     *(pIdentifier->Revision) = 0;
1663     *pIdentifier->DeviceIdentifier = IID_D3DDEVICE_D3DUID;
1664
1665     if (Flags & WINED3DENUM_NO_WHQL_LEVEL) {
1666         *(pIdentifier->WHQLLevel) = 0;
1667     } else {
1668         *(pIdentifier->WHQLLevel) = 1;
1669     }
1670
1671     return WINED3D_OK;
1672 }
1673
1674 static BOOL IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(const WineD3D_PixelFormat *cfg, WINED3DFORMAT Format) {
1675     short redSize, greenSize, blueSize, alphaSize, colorBits;
1676
1677     if(!cfg)
1678         return FALSE;
1679
1680     if(cfg->iPixelType == WGL_TYPE_RGBA_ARB) { /* Integer RGBA formats */
1681         if(!getColorBits(Format, &redSize, &greenSize, &blueSize, &alphaSize, &colorBits)) {
1682             ERR("Unable to check compatibility for Format=%s\n", debug_d3dformat(Format));
1683             return FALSE;
1684         }
1685
1686         if(cfg->redSize < redSize)
1687             return FALSE;
1688
1689         if(cfg->greenSize < greenSize)
1690             return FALSE;
1691
1692         if(cfg->blueSize < blueSize)
1693             return FALSE;
1694
1695         if(cfg->alphaSize < alphaSize)
1696             return FALSE;
1697
1698         return TRUE;
1699     } else if(cfg->iPixelType == WGL_TYPE_RGBA_FLOAT_ARB) { /* Float RGBA formats; TODO: WGL_NV_float_buffer */
1700         if(Format == WINED3DFMT_R16F)
1701             return (cfg->redSize == 16 && cfg->greenSize == 0 && cfg->blueSize == 0 && cfg->alphaSize == 0);
1702         if(Format == WINED3DFMT_G16R16F)
1703             return (cfg->redSize == 16 && cfg->greenSize == 16 && cfg->blueSize == 0 && cfg->alphaSize == 0);
1704         if(Format == WINED3DFMT_A16B16G16R16F)
1705             return (cfg->redSize == 16 && cfg->greenSize == 16 && cfg->blueSize == 16 && cfg->alphaSize == 16);
1706         if(Format == WINED3DFMT_R32F)
1707             return (cfg->redSize == 32 && cfg->greenSize == 0 && cfg->blueSize == 0 && cfg->alphaSize == 0);
1708         if(Format == WINED3DFMT_G32R32F)
1709             return (cfg->redSize == 32 && cfg->greenSize == 32 && cfg->blueSize == 0 && cfg->alphaSize == 0);
1710         if(Format == WINED3DFMT_A32B32G32R32F)
1711             return (cfg->redSize == 32 && cfg->greenSize == 32 && cfg->blueSize == 32 && cfg->alphaSize == 32);
1712     } else {
1713         /* Probably a color index mode */
1714         return FALSE;
1715     }
1716
1717     return FALSE;
1718 }
1719
1720 static BOOL IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(const WineD3D_PixelFormat *cfg, WINED3DFORMAT Format) {
1721     short depthSize, stencilSize;
1722     BOOL lockable = FALSE;
1723
1724     if(!cfg)
1725         return FALSE;
1726
1727     if(!getDepthStencilBits(Format, &depthSize, &stencilSize)) {
1728         ERR("Unable to check compatibility for Format=%s\n", debug_d3dformat(Format));
1729         return FALSE;
1730     }
1731
1732     if((Format == WINED3DFMT_D16_LOCKABLE) || (Format == WINED3DFMT_D32F_LOCKABLE))
1733         lockable = TRUE;
1734
1735     /* On some modern cards like the Geforce8/9 GLX doesn't offer some dephthstencil formats which D3D9 reports.
1736      * We can safely report 'compatible' formats (e.g. D24 can be used for D16) as long as we aren't dealing with
1737      * a lockable format. This also helps D3D <= 7 as they expect D16 which isn't offered without this on Geforce8 cards. */
1738     if(!(cfg->depthSize == depthSize || (!lockable && cfg->depthSize > depthSize)))
1739         return FALSE;
1740
1741     /* Some cards like Intel i915 ones only offer D24S8 but lots of games also need a format without stencil, so
1742      * allow more stencil bits than requested. */
1743     if(cfg->stencilSize < stencilSize)
1744         return FALSE;
1745
1746     return TRUE;
1747 }
1748
1749 static HRESULT WINAPI IWineD3DImpl_CheckDepthStencilMatch(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
1750                                                    WINED3DFORMAT AdapterFormat,
1751                                                    WINED3DFORMAT RenderTargetFormat,
1752                                                    WINED3DFORMAT DepthStencilFormat) {
1753     IWineD3DImpl *This = (IWineD3DImpl *)iface;
1754     int nCfgs;
1755     WineD3D_PixelFormat *cfgs;
1756     int it;
1757
1758     WARN_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, DevType:(%x,%s), AdptFmt:(%x,%s), RendrTgtFmt:(%x,%s), DepthStencilFmt:(%x,%s))\n",
1759            This, Adapter,
1760            DeviceType, debug_d3ddevicetype(DeviceType),
1761            AdapterFormat, debug_d3dformat(AdapterFormat),
1762            RenderTargetFormat, debug_d3dformat(RenderTargetFormat),
1763            DepthStencilFormat, debug_d3dformat(DepthStencilFormat));
1764
1765     if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
1766         TRACE("(%p) Failed: Atapter (%u) higher than supported adapters (%u) returning WINED3DERR_INVALIDCALL\n", This, Adapter, IWineD3D_GetAdapterCount(iface));
1767         return WINED3DERR_INVALIDCALL;
1768     }
1769
1770     cfgs = Adapters[Adapter].cfgs;
1771     nCfgs = Adapters[Adapter].nCfgs;
1772     for (it = 0; it < nCfgs; ++it) {
1773         if (IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&cfgs[it], RenderTargetFormat)) {
1774             if (IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&cfgs[it], DepthStencilFormat)) {
1775                 TRACE_(d3d_caps)("(%p) : Formats matched\n", This);
1776                 return WINED3D_OK;
1777             }
1778         }
1779     }
1780     WARN_(d3d_caps)("unsupported format pair: %s and %s\n", debug_d3dformat(RenderTargetFormat), debug_d3dformat(DepthStencilFormat));
1781
1782     return WINED3DERR_NOTAVAILABLE;
1783 }
1784
1785 static HRESULT WINAPI IWineD3DImpl_CheckDeviceMultiSampleType(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
1786                                                        WINED3DFORMAT SurfaceFormat,
1787                                                        BOOL Windowed, WINED3DMULTISAMPLE_TYPE MultiSampleType, DWORD*   pQualityLevels) {
1788
1789     IWineD3DImpl *This = (IWineD3DImpl *)iface;
1790     const GlPixelFormatDesc *glDesc;
1791     const StaticPixelFormatDesc *desc;
1792
1793     TRACE_(d3d_caps)("(%p)-> (Adptr:%d, DevType:(%x,%s), SurfFmt:(%x,%s), Win?%d, MultiSamp:%x, pQual:%p)\n",
1794           This,
1795           Adapter,
1796           DeviceType, debug_d3ddevicetype(DeviceType),
1797           SurfaceFormat, debug_d3dformat(SurfaceFormat),
1798           Windowed,
1799           MultiSampleType,
1800           pQualityLevels);
1801
1802     if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
1803         return WINED3DERR_INVALIDCALL;
1804     }
1805
1806     /* TODO: handle Windowed, add more quality levels */
1807
1808     if (WINED3DMULTISAMPLE_NONE == MultiSampleType) return WINED3D_OK;
1809
1810     /* By default multisampling is disabled right now as it causes issues
1811      * on some Nvidia driver versions and it doesn't work well in combination
1812      * with FBOs yet. */
1813     if(!wined3d_settings.allow_multisampling)
1814         return WINED3DERR_NOTAVAILABLE;
1815
1816     desc = getFormatDescEntry(SurfaceFormat, &Adapters[Adapter].gl_info, &glDesc);
1817     if(!desc || !glDesc) {
1818         return WINED3DERR_INVALIDCALL;
1819     }
1820
1821     if(glDesc->Flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL)) {
1822         int i, nCfgs;
1823         WineD3D_PixelFormat *cfgs;
1824
1825         cfgs = Adapters[Adapter].cfgs;
1826         nCfgs = Adapters[Adapter].nCfgs;
1827         for(i=0; i<nCfgs; i++) {
1828             if(cfgs[i].numSamples != MultiSampleType)
1829                 continue;
1830
1831             if(!IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&cfgs[i], SurfaceFormat))
1832                 continue;
1833
1834             TRACE("Found iPixelFormat=%d to support MultiSampleType=%d for format %s\n", cfgs[i].iPixelFormat, MultiSampleType, debug_d3dformat(SurfaceFormat));
1835
1836             if(pQualityLevels)
1837                 *pQualityLevels = 1; /* Guess at a value! */
1838             return WINED3D_OK;
1839         }
1840     }
1841     else if(glDesc->Flags & WINED3DFMT_FLAG_RENDERTARGET) {
1842         short redSize, greenSize, blueSize, alphaSize, colorBits;
1843         int i, nCfgs;
1844         WineD3D_PixelFormat *cfgs;
1845
1846         if(!getColorBits(SurfaceFormat, &redSize, &greenSize, &blueSize, &alphaSize, &colorBits)) {
1847             ERR("Unable to color bits for format %#x, can't check multisampling capability!\n", SurfaceFormat);
1848             return WINED3DERR_NOTAVAILABLE;
1849         }
1850
1851         cfgs = Adapters[Adapter].cfgs;
1852         nCfgs = Adapters[Adapter].nCfgs;
1853         for(i=0; i<nCfgs; i++) {
1854             if(cfgs[i].numSamples != MultiSampleType)
1855                 continue;
1856             if(cfgs[i].redSize != redSize)
1857                 continue;
1858             if(cfgs[i].greenSize != greenSize)
1859                 continue;
1860             if(cfgs[i].blueSize != blueSize)
1861                 continue;
1862             if(cfgs[i].alphaSize != alphaSize)
1863                 continue;
1864
1865             TRACE("Found iPixelFormat=%d to support MultiSampleType=%d for format %s\n", cfgs[i].iPixelFormat, MultiSampleType, debug_d3dformat(SurfaceFormat));
1866
1867             if(pQualityLevels)
1868                 *pQualityLevels = 1; /* Guess at a value! */
1869             return WINED3D_OK;
1870         }
1871     }
1872     return WINED3DERR_NOTAVAILABLE;
1873 }
1874
1875 static HRESULT WINAPI IWineD3DImpl_CheckDeviceType(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
1876                                             WINED3DFORMAT DisplayFormat, WINED3DFORMAT BackBufferFormat, BOOL Windowed) {
1877
1878     IWineD3DImpl *This = (IWineD3DImpl *)iface;
1879     HRESULT hr = WINED3DERR_NOTAVAILABLE;
1880     UINT nmodes;
1881
1882     TRACE_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, CheckType:(%x,%s), DispFmt:(%x,%s), BackBuf:(%x,%s), Win?%d): stub\n",
1883           This,
1884           Adapter,
1885           DeviceType, debug_d3ddevicetype(DeviceType),
1886           DisplayFormat, debug_d3dformat(DisplayFormat),
1887           BackBufferFormat, debug_d3dformat(BackBufferFormat),
1888           Windowed);
1889
1890     if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
1891         WARN_(d3d_caps)("Adapter >= IWineD3D_GetAdapterCount(iface), returning WINED3DERR_INVALIDCALL\n");
1892         return WINED3DERR_INVALIDCALL;
1893     }
1894
1895     /* The task of this function is to check whether a certain display / backbuffer format
1896      * combination is available on the given adapter. In fullscreen mode microsoft specified
1897      * that the display format shouldn't provide alpha and that ignoring alpha the backbuffer
1898      * and display format should match exactly.
1899      * In windowed mode format conversion can occur and this depends on the driver. When format
1900      * conversion is done, this function should nevertheless fail and applications need to use
1901      * CheckDeviceFormatConversion.
1902      * At the moment we assume that fullscreen and windowed have the same capabilities */
1903
1904     /* There are only 4 display formats */
1905     if(!((DisplayFormat == WINED3DFMT_R5G6B5) ||
1906          (DisplayFormat == WINED3DFMT_X1R5G5B5) ||
1907          (DisplayFormat == WINED3DFMT_X8R8G8B8) ||
1908          (DisplayFormat == WINED3DFMT_A2R10G10B10)))
1909     {
1910         TRACE_(d3d_caps)("Format %s unsupported as display format\n", debug_d3dformat(DisplayFormat));
1911         return WINED3DERR_NOTAVAILABLE;
1912     }
1913
1914     /* If the requested DisplayFormat is not available, don't continue */
1915     nmodes = IWineD3DImpl_GetAdapterModeCount(iface, Adapter, DisplayFormat);
1916     if(!nmodes) {
1917         TRACE_(d3d_caps)("No available modes for display format %s\n", debug_d3dformat(DisplayFormat));
1918         return WINED3DERR_NOTAVAILABLE;
1919     }
1920
1921     /* Windowed mode allows you to specify WINED3DFMT_UNKNOWN for the backbufferformat, it means 'reuse' the display format for the backbuffer */
1922     if(!Windowed && BackBufferFormat == WINED3DFMT_UNKNOWN) {
1923         TRACE_(d3d_caps)("BackBufferFormat WINED3FMT_UNKNOWN not available in Windowed mode\n");
1924         return WINED3DERR_NOTAVAILABLE;
1925     }
1926
1927     /* In FULLSCREEN mode R5G6B5 can only be mixed with backbuffer format R5G6B5 */
1928     if( (DisplayFormat == WINED3DFMT_R5G6B5) && (BackBufferFormat != WINED3DFMT_R5G6B5) ) {
1929         TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat), debug_d3dformat(BackBufferFormat));
1930         return WINED3DERR_NOTAVAILABLE;
1931     }
1932
1933     /* In FULLSCREEN mode X1R5G5B5 can only be mixed with backbuffer format *1R5G5B5 */
1934     if( (DisplayFormat == WINED3DFMT_X1R5G5B5) && !((BackBufferFormat == WINED3DFMT_X1R5G5B5) || (BackBufferFormat == WINED3DFMT_A1R5G5B5)) ) {
1935         TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat), debug_d3dformat(BackBufferFormat));
1936         return WINED3DERR_NOTAVAILABLE;
1937     }
1938
1939     /* In FULLSCREEN mode X8R8G8B8 can only be mixed with backbuffer format *8R8G8B8 */
1940     if( (DisplayFormat == WINED3DFMT_X8R8G8B8) && !((BackBufferFormat == WINED3DFMT_X8R8G8B8) || (BackBufferFormat == WINED3DFMT_A8R8G8B8)) ) {
1941         TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat), debug_d3dformat(BackBufferFormat));
1942         return WINED3DERR_NOTAVAILABLE;
1943     }
1944
1945     /* A2R10G10B10 is only allowed in fullscreen mode and it can only be mixed with backbuffer format A2R10G10B10 */
1946     if( (DisplayFormat == WINED3DFMT_A2R10G10B10) && ((BackBufferFormat != WINED3DFMT_A2R10G10B10) || Windowed)) {
1947         TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat), debug_d3dformat(BackBufferFormat));
1948         return WINED3DERR_NOTAVAILABLE;
1949     }
1950
1951     /* Use CheckDeviceFormat to see if the BackBufferFormat is usable with the given DisplayFormat */
1952     hr = IWineD3DImpl_CheckDeviceFormat(iface, Adapter, DeviceType, DisplayFormat, WINED3DUSAGE_RENDERTARGET, WINED3DRTYPE_SURFACE, BackBufferFormat);
1953     if(FAILED(hr))
1954         TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat), debug_d3dformat(BackBufferFormat));
1955
1956     return hr;
1957 }
1958
1959
1960 #define GLINFO_LOCATION Adapters[Adapter].gl_info
1961 /* Check if we support bumpmapping for a format */
1962 static BOOL CheckBumpMapCapability(UINT Adapter, WINED3DFORMAT CheckFormat)
1963 {
1964     if(GL_SUPPORT(NV_REGISTER_COMBINERS) && GL_SUPPORT(NV_TEXTURE_SHADER2)) {
1965         switch (CheckFormat) {
1966             case WINED3DFMT_V8U8:
1967                 TRACE_(d3d_caps)("[OK]\n");
1968                 return TRUE;
1969             /* TODO: Other bump map formats */
1970             default:
1971                 TRACE_(d3d_caps)("[FAILED]\n");
1972                 return FALSE;
1973         }
1974     }
1975     if(GL_SUPPORT(ATI_ENVMAP_BUMPMAP) || GL_SUPPORT(ATI_FRAGMENT_SHADER)) {
1976         switch (CheckFormat) {
1977             case WINED3DFMT_V8U8:
1978                 TRACE_(d3d_caps)("[OK]\n");
1979                 return TRUE;
1980             default:
1981                 TRACE_(d3d_caps)("[FAILED]\n");
1982                 return FALSE;
1983         }
1984     }
1985     TRACE_(d3d_caps)("[FAILED]\n");
1986     return FALSE;
1987 }
1988
1989 /* Check if the given DisplayFormat + DepthStencilFormat combination is valid for the Adapter */
1990 static BOOL CheckDepthStencilCapability(UINT Adapter, WINED3DFORMAT DisplayFormat, WINED3DFORMAT DepthStencilFormat)
1991 {
1992     int it=0;
1993     WineD3D_PixelFormat *cfgs = Adapters[Adapter].cfgs;
1994     const GlPixelFormatDesc *glDesc;
1995     const StaticPixelFormatDesc *desc = getFormatDescEntry(DepthStencilFormat, &GLINFO_LOCATION, &glDesc);
1996
1997     /* Fail if we weren't able to get a description of the format */
1998     if(!desc || !glDesc)
1999         return FALSE;
2000
2001     /* Only allow depth/stencil formats */
2002     if(!(glDesc->Flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL)))
2003         return FALSE;
2004
2005     /* Walk through all WGL pixel formats to find a match */
2006     cfgs = Adapters[Adapter].cfgs;
2007     for (it = 0; it < Adapters[Adapter].nCfgs; ++it) {
2008         if (IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&cfgs[it], DisplayFormat)) {
2009             if (IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&cfgs[it], DepthStencilFormat)) {
2010                 return TRUE;
2011             }
2012         }
2013     }
2014
2015     return FALSE;
2016 }
2017
2018 static BOOL CheckFilterCapability(UINT Adapter, WINED3DFORMAT CheckFormat)
2019 {
2020     const GlPixelFormatDesc *glDesc;
2021     const StaticPixelFormatDesc *desc = getFormatDescEntry(CheckFormat, &GLINFO_LOCATION, &glDesc);
2022
2023     /* Fail if we weren't able to get a description of the format */
2024     if(!desc || !glDesc)
2025         return FALSE;
2026
2027     /* The flags entry of a format contains the filtering capability */
2028     if(glDesc->Flags & WINED3DFMT_FLAG_FILTERING)
2029         return TRUE;
2030
2031     return FALSE;
2032 }
2033
2034 /* Check the render target capabilities of a format */
2035 static BOOL CheckRenderTargetCapability(WINED3DFORMAT AdapterFormat, WINED3DFORMAT CheckFormat)
2036 {
2037     UINT Adapter = 0;
2038     const GlPixelFormatDesc *glDesc;
2039     const StaticPixelFormatDesc *desc = getFormatDescEntry(CheckFormat, &GLINFO_LOCATION, &glDesc);
2040
2041     /* Fail if we weren't able to get a description of the format */
2042     if(!desc || !glDesc)
2043         return FALSE;
2044
2045     /* Filter out non-RT formats */
2046     if(!(glDesc->Flags & WINED3DFMT_FLAG_RENDERTARGET))
2047         return FALSE;
2048
2049     if(wined3d_settings.offscreen_rendering_mode == ORM_BACKBUFFER) {
2050         WineD3D_PixelFormat *cfgs = Adapters[Adapter].cfgs;
2051         int it;
2052         short AdapterRed, AdapterGreen, AdapterBlue, AdapterAlpha, AdapterTotalSize;
2053         short CheckRed, CheckGreen, CheckBlue, CheckAlpha, CheckTotalSize;
2054
2055         getColorBits(AdapterFormat, &AdapterRed, &AdapterGreen, &AdapterBlue, &AdapterAlpha, &AdapterTotalSize);
2056         getColorBits(CheckFormat, &CheckRed, &CheckGreen, &CheckBlue, &CheckAlpha, &CheckTotalSize);
2057
2058         /* In backbuffer mode the front and backbuffer share the same WGL pixelformat.
2059          * The format must match in RGB, alpha is allowed to be different. (Only the backbuffer can have alpha) */
2060         if(!((AdapterRed == CheckRed) && (AdapterGreen == CheckGreen) && (AdapterBlue == CheckBlue))) {
2061             TRACE_(d3d_caps)("[FAILED]\n");
2062             return FALSE;
2063         }
2064
2065         /* Check if there is a WGL pixel format matching the requirements, the format should also be window
2066          * drawable (not offscreen; e.g. Nvidia offers R5G6B5 for pbuffers even when X is running at 24bit) */
2067         for (it = 0; it < Adapters[Adapter].nCfgs; ++it) {
2068             if (cfgs[it].windowDrawable && IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&cfgs[it], CheckFormat)) {
2069                 TRACE_(d3d_caps)("iPixelFormat=%d is compatible with CheckFormat=%s\n", cfgs[it].iPixelFormat, debug_d3dformat(CheckFormat));
2070                 return TRUE;
2071             }
2072         }
2073     } else if(wined3d_settings.offscreen_rendering_mode == ORM_PBUFFER) {
2074         /* We can probably use this function in FBO mode too on some drivers to get some basic indication of the capabilities. */
2075         WineD3D_PixelFormat *cfgs = Adapters[Adapter].cfgs;
2076         int it;
2077
2078         /* Check if there is a WGL pixel format matching the requirements, the pixel format should also be usable with pbuffers */
2079         for (it = 0; it < Adapters[Adapter].nCfgs; ++it) {
2080             if (cfgs[it].pbufferDrawable && IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&cfgs[it], CheckFormat)) {
2081                 TRACE_(d3d_caps)("iPixelFormat=%d is compatible with CheckFormat=%s\n", cfgs[it].iPixelFormat, debug_d3dformat(CheckFormat));
2082                 return TRUE;
2083             }
2084         }
2085     } else if(wined3d_settings.offscreen_rendering_mode == ORM_FBO){
2086         /* For now return TRUE for FBOs until we have some proper checks.
2087          * Note that this function will only be called when the format is around for texturing. */
2088         return TRUE;
2089     }
2090     return FALSE;
2091 }
2092
2093 static BOOL CheckSrgbReadCapability(UINT Adapter, WINED3DFORMAT CheckFormat)
2094 {
2095     /* Check for supported sRGB formats (Texture loading and framebuffer) */
2096     if(!GL_SUPPORT(EXT_TEXTURE_SRGB)) {
2097         TRACE_(d3d_caps)("[FAILED] GL_EXT_texture_sRGB not supported\n");
2098         return FALSE;
2099     }
2100
2101     switch (CheckFormat) {
2102         case WINED3DFMT_A8R8G8B8:
2103         case WINED3DFMT_X8R8G8B8:
2104         case WINED3DFMT_A4R4G4B4:
2105         case WINED3DFMT_L8:
2106         case WINED3DFMT_A8L8:
2107         case WINED3DFMT_DXT1:
2108         case WINED3DFMT_DXT2:
2109         case WINED3DFMT_DXT3:
2110         case WINED3DFMT_DXT4:
2111         case WINED3DFMT_DXT5:
2112             TRACE_(d3d_caps)("[OK]\n");
2113             return TRUE;
2114
2115         default:
2116             TRACE_(d3d_caps)("[FAILED] Gamma texture format %s not supported.\n", debug_d3dformat(CheckFormat));
2117             return FALSE;
2118     }
2119     return FALSE;
2120 }
2121
2122 static BOOL CheckSrgbWriteCapability(UINT Adapter, WINED3DDEVTYPE DeviceType, WINED3DFORMAT CheckFormat)
2123 {
2124     /* Only offer SRGB writing on X8R8G8B8/A8R8G8B8 when we use ARB or GLSL shaders as we are
2125      * doing the color fixup in shaders.
2126      * Note Windows drivers (at least on the Geforce 8800) also offer this on R5G6B5. */
2127     if((CheckFormat == WINED3DFMT_X8R8G8B8) || (CheckFormat == WINED3DFMT_A8R8G8B8)) {
2128         int vs_selected_mode;
2129         int ps_selected_mode;
2130         select_shader_mode(&GLINFO_LOCATION, DeviceType, &ps_selected_mode, &vs_selected_mode);
2131
2132         if((ps_selected_mode == SHADER_ARB) || (ps_selected_mode == SHADER_GLSL)) {
2133             TRACE_(d3d_caps)("[OK]\n");
2134             return TRUE;
2135         }
2136     }
2137
2138     TRACE_(d3d_caps)("[FAILED] - no SRGB writing support on format=%s\n", debug_d3dformat(CheckFormat));
2139     return FALSE;
2140 }
2141
2142 /* Check if a format support blending in combination with pixel shaders */
2143 static BOOL CheckPostPixelShaderBlendingCapability(UINT Adapter, WINED3DFORMAT CheckFormat)
2144 {
2145     const GlPixelFormatDesc *glDesc;
2146     const StaticPixelFormatDesc *desc = getFormatDescEntry(CheckFormat, &GLINFO_LOCATION, &glDesc);
2147
2148     /* Fail if we weren't able to get a description of the format */
2149     if(!desc || !glDesc)
2150         return FALSE;
2151
2152     /* The flags entry of a format contains the post pixel shader blending capability */
2153     if(glDesc->Flags & WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING)
2154         return TRUE;
2155
2156     return FALSE;
2157 }
2158
2159 static BOOL CheckWrapAndMipCapability(UINT Adapter, WINED3DFORMAT CheckFormat) {
2160     /* OpenGL supports mipmapping on all formats basically. Wrapping is unsupported,
2161      * but we have to report mipmapping so we cannot reject this flag. Tests show that
2162      * windows reports WRAPANDMIP on unfilterable surfaces as well, apparently to show
2163      * that wrapping is supported. The lack of filtering will sort out the mipmapping
2164      * capability anyway.
2165      *
2166      * For now lets report this on all formats, but in the future we may want to
2167      * restrict it to some should games need that
2168      */
2169     return TRUE;
2170 }
2171
2172 /* Check if a texture format is supported on the given adapter */
2173 static BOOL CheckTextureCapability(UINT Adapter, WINED3DFORMAT CheckFormat)
2174 {
2175     switch (CheckFormat) {
2176
2177         /*****
2178          *  supported: RGB(A) formats
2179          */
2180         case WINED3DFMT_R8G8B8: /* Enable for dx7, blacklisted for 8 and 9 above */
2181         case WINED3DFMT_A8R8G8B8:
2182         case WINED3DFMT_X8R8G8B8:
2183         case WINED3DFMT_R5G6B5:
2184         case WINED3DFMT_X1R5G5B5:
2185         case WINED3DFMT_A1R5G5B5:
2186         case WINED3DFMT_A4R4G4B4:
2187         case WINED3DFMT_R3G3B2:
2188         case WINED3DFMT_A8:
2189         case WINED3DFMT_X4R4G4B4:
2190         case WINED3DFMT_A8B8G8R8:
2191         case WINED3DFMT_X8B8G8R8:
2192         case WINED3DFMT_A2R10G10B10:
2193         case WINED3DFMT_A2B10G10R10:
2194         case WINED3DFMT_G16R16:
2195             TRACE_(d3d_caps)("[OK]\n");
2196             return TRUE;
2197
2198         /*****
2199          *  supported: Palettized
2200          */
2201         case WINED3DFMT_P8:
2202             TRACE_(d3d_caps)("[OK]\n");
2203             return TRUE;
2204         /* No Windows driver offers A8P8, so don't offer it either */
2205         case WINED3DFMT_A8P8:
2206             return FALSE;
2207
2208         /*****
2209          *  Supported: (Alpha)-Luminance
2210          */
2211         case WINED3DFMT_L8:
2212         case WINED3DFMT_A8L8:
2213         case WINED3DFMT_A4L4:
2214         case WINED3DFMT_L16:
2215             TRACE_(d3d_caps)("[OK]\n");
2216             return TRUE;
2217
2218         /*****
2219          *  Supported: Depth/Stencil formats
2220          */
2221         case WINED3DFMT_D16_LOCKABLE:
2222         case WINED3DFMT_D16:
2223         case WINED3DFMT_D15S1:
2224         case WINED3DFMT_D24X8:
2225         case WINED3DFMT_D24X4S4:
2226         case WINED3DFMT_D24S8:
2227         case WINED3DFMT_D24FS8:
2228         case WINED3DFMT_D32:
2229         case WINED3DFMT_D32F_LOCKABLE:
2230             return TRUE;
2231
2232         /*****
2233          *  Not supported everywhere(depends on GL_ATI_envmap_bumpmap or
2234          *  GL_NV_texture_shader), but advertized to make apps happy.
2235          *  Enable some because games often fail when they are not available
2236          *  and are still playable even without bump mapping
2237          */
2238         case WINED3DFMT_V8U8:
2239             if(GL_SUPPORT(NV_TEXTURE_SHADER) || GL_SUPPORT(ATI_ENVMAP_BUMPMAP) ||
2240                GL_SUPPORT(ATI_FRAGMENT_SHADER)) {
2241                 return TRUE;
2242             }
2243             if(GL_SUPPORT(ARB_FRAGMENT_SHADER) || GL_SUPPORT(ARB_FRAGMENT_PROGRAM)) {
2244                 /* Shader emulated */
2245                 return TRUE;
2246             }
2247             TRACE_(d3d_caps)("[FAILED] - No converted formats on volumes\n");
2248             return FALSE;
2249
2250         case WINED3DFMT_X8L8V8U8:
2251         case WINED3DFMT_L6V5U5:
2252             if(GL_SUPPORT(ARB_FRAGMENT_SHADER) || GL_SUPPORT(ARB_FRAGMENT_PROGRAM)) {
2253                 /* Shader emulated */
2254                 return TRUE;
2255             }
2256             WARN_(d3d_caps)("[FAILED]\n");
2257             return FALSE;
2258
2259         case WINED3DFMT_Q8W8V8U8:
2260         case WINED3DFMT_V16U16:
2261             if(GL_SUPPORT(NV_TEXTURE_SHADER)) {
2262                 WARN_(d3d_caps)("[Not supported, but pretended to do]\n");
2263                 return TRUE;
2264             }
2265             if(GL_SUPPORT(ARB_FRAGMENT_SHADER) || GL_SUPPORT(ARB_FRAGMENT_PROGRAM)) {
2266                 /* Shader emulated */
2267                 return TRUE;
2268             }
2269             TRACE_(d3d_caps)("[FAILED] - No converted formats on volumes\n");
2270             return FALSE;
2271
2272         /* Those are not advertized by the nvidia windows driver, and not
2273          * supported natively by GL_NV_texture_shader or GL_ATI_envmap_bumpmap.
2274          * WINED3DFMT_A2W10V10U10 could be loaded into shaders using the unsigned
2275          * ARGB format if needed
2276          */
2277         case WINED3DFMT_W11V11U10:
2278         case WINED3DFMT_A2W10V10U10:
2279             WARN_(d3d_caps)("[FAILED]\n");
2280             return FALSE;
2281
2282         case WINED3DFMT_DXT1:
2283         case WINED3DFMT_DXT2:
2284         case WINED3DFMT_DXT3:
2285         case WINED3DFMT_DXT4:
2286         case WINED3DFMT_DXT5:
2287             if (GL_SUPPORT(EXT_TEXTURE_COMPRESSION_S3TC)) {
2288                 TRACE_(d3d_caps)("[OK]\n");
2289                 return TRUE;
2290             }
2291             TRACE_(d3d_caps)("[FAILED]\n");
2292             return FALSE;
2293
2294
2295         /*****
2296          *  Odd formats - not supported
2297          */
2298         case WINED3DFMT_VERTEXDATA:
2299         case WINED3DFMT_INDEX16:
2300         case WINED3DFMT_INDEX32:
2301         case WINED3DFMT_Q16W16V16U16:
2302             TRACE_(d3d_caps)("[FAILED]\n"); /* Enable when implemented */
2303             return FALSE;
2304
2305         /*****
2306          *  WINED3DFMT_CxV8U8: Not supported right now
2307          */
2308         case WINED3DFMT_CxV8U8:
2309             TRACE_(d3d_caps)("[FAILED]\n"); /* Enable when implemented */
2310             return FALSE;
2311
2312         /* YUV formats, not supported for now */
2313         case WINED3DFMT_UYVY:
2314         case WINED3DFMT_YUY2:
2315             TRACE_(d3d_caps)("[FAILED]\n"); /* Enable when implemented */
2316             return FALSE;
2317
2318             /* Not supported */
2319         case WINED3DFMT_A16B16G16R16:
2320         case WINED3DFMT_A8R3G3B2:
2321             TRACE_(d3d_caps)("[FAILED]\n"); /* Enable when implemented */
2322             return FALSE;
2323
2324             /* Floating point formats */
2325         case WINED3DFMT_R16F:
2326         case WINED3DFMT_A16B16G16R16F:
2327             if(GL_SUPPORT(ARB_TEXTURE_FLOAT) && GL_SUPPORT(ARB_HALF_FLOAT_PIXEL)) {
2328                 TRACE_(d3d_caps)("[OK]\n");
2329                 return TRUE;
2330             }
2331             TRACE_(d3d_caps)("[FAILED]\n");
2332             return FALSE;
2333
2334         case WINED3DFMT_R32F:
2335         case WINED3DFMT_A32B32G32R32F:
2336             if (GL_SUPPORT(ARB_TEXTURE_FLOAT)) {
2337                 TRACE_(d3d_caps)("[OK]\n");
2338                 return TRUE;
2339             }
2340             TRACE_(d3d_caps)("[FAILED]\n");
2341             return FALSE;
2342
2343         case WINED3DFMT_G16R16F:
2344         case WINED3DFMT_G32R32F:
2345             TRACE_(d3d_caps)("[FAILED]\n");
2346             return FALSE;
2347
2348         /* ATI instancing hack: Although ATI cards do not support Shader Model 3.0, they support
2349          * instancing. To query if the card supports instancing CheckDeviceFormat with the special format
2350          * MAKEFOURCC('I','N','S','T') is used. Should a (broken) app check for this provide a proper return value.
2351          * We can do instancing with all shader versions, but we need vertex shaders.
2352          *
2353          * Additionally applications have to set the D3DRS_POINTSIZE render state to MAKEFOURCC('I','N','S','T') once
2354          * to enable instancing. WineD3D doesn't need that and just ignores it.
2355          *
2356          * With Shader Model 3.0 capable cards Instancing 'just works' in Windows.
2357          */
2358         case WINEMAKEFOURCC('I','N','S','T'):
2359             TRACE("ATI Instancing check hack\n");
2360             if(GL_SUPPORT(ARB_VERTEX_PROGRAM) || GL_SUPPORT(ARB_VERTEX_SHADER)) {
2361                 TRACE_(d3d_caps)("[OK]\n");
2362                 return TRUE;
2363             }
2364             TRACE_(d3d_caps)("[FAILED]\n");
2365             return FALSE;
2366
2367         /* Some weird FOURCC formats */
2368         case WINED3DFMT_R8G8_B8G8:
2369         case WINED3DFMT_G8R8_G8B8:
2370         case WINED3DFMT_MULTI2_ARGB8:
2371             TRACE_(d3d_caps)("[FAILED]\n");
2372             return FALSE;
2373
2374         case WINED3DFMT_UNKNOWN:
2375             return FALSE;
2376
2377         default:
2378             ERR("Unhandled format=%s\n", debug_d3dformat(CheckFormat));
2379             break;
2380     }
2381     return FALSE;
2382 }
2383
2384 static BOOL CheckVertexTextureCapability(UINT Adapter, WINED3DFORMAT CheckFormat)
2385 {
2386     if (!GL_LIMITS(vertex_samplers)) {
2387         TRACE_(d3d_caps)("[FAILED]\n");
2388         return FALSE;
2389     }
2390
2391     switch (CheckFormat) {
2392         case WINED3DFMT_A32B32G32R32F:
2393             if (!GL_SUPPORT(ARB_TEXTURE_FLOAT)) {
2394                 TRACE_(d3d_caps)("[FAILED]\n");
2395                 return FALSE;
2396             }
2397             TRACE_(d3d_caps)("[OK]\n");
2398             return TRUE;
2399
2400         default:
2401             TRACE_(d3d_caps)("[FAILED]\n");
2402             return FALSE;
2403     }
2404     return FALSE;
2405 }
2406
2407 static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
2408                                               WINED3DFORMAT AdapterFormat, DWORD Usage, WINED3DRESOURCETYPE RType, WINED3DFORMAT CheckFormat) {
2409     IWineD3DImpl *This = (IWineD3DImpl *)iface;
2410     DWORD UsageCaps = 0;
2411
2412     TRACE_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, DevType:(%u,%s), AdptFmt:(%u,%s), Use:(%u,%s,%s), ResTyp:(%x,%s), CheckFmt:(%u,%s))\n",
2413           This,
2414           Adapter,
2415           DeviceType, debug_d3ddevicetype(DeviceType),
2416           AdapterFormat, debug_d3dformat(AdapterFormat),
2417           Usage, debug_d3dusage(Usage), debug_d3dusagequery(Usage),
2418           RType, debug_d3dresourcetype(RType),
2419           CheckFormat, debug_d3dformat(CheckFormat));
2420
2421     if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
2422         return WINED3DERR_INVALIDCALL;
2423     }
2424
2425     if(RType == WINED3DRTYPE_CUBETEXTURE) {
2426         /* Cubetexture allows:
2427          *                    - D3DUSAGE_AUTOGENMIPMAP
2428          *                    - D3DUSAGE_DEPTHSTENCIL
2429          *                    - D3DUSAGE_DYNAMIC
2430          *                    - D3DUSAGE_NONSECURE (d3d9ex)
2431          *                    - D3DUSAGE_RENDERTARGET
2432          *                    - D3DUSAGE_SOFTWAREPROCESSING
2433          *                    - D3DUSAGE_QUERY_WRAPANDMIP
2434          */
2435         if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
2436             /* Check if the texture format is around */
2437             if(CheckTextureCapability(Adapter, CheckFormat)) {
2438                 if(Usage & WINED3DUSAGE_AUTOGENMIPMAP) {
2439                     /* Check for automatic mipmap generation support */
2440                     if(GL_SUPPORT(SGIS_GENERATE_MIPMAP)) {
2441                         UsageCaps |= WINED3DUSAGE_AUTOGENMIPMAP;
2442                     } else {
2443                         /* When autogenmipmap isn't around continue and return WINED3DOK_NOAUTOGEN instead of D3D_OK */
2444                         TRACE_(d3d_caps)("[FAILED] - No autogenmipmap support, but continuing\n");
2445                     }
2446                 }
2447
2448                 /* Always report dynamic locking */
2449                 if(Usage & WINED3DUSAGE_DYNAMIC)
2450                     UsageCaps |= WINED3DUSAGE_DYNAMIC;
2451
2452                 if(Usage & WINED3DUSAGE_RENDERTARGET) {
2453                     if(CheckRenderTargetCapability(AdapterFormat, CheckFormat)) {
2454                         UsageCaps |= WINED3DUSAGE_RENDERTARGET;
2455                     } else {
2456                         TRACE_(d3d_caps)("[FAILED] - No rendertarget support\n");
2457                         return WINED3DERR_NOTAVAILABLE;
2458                     }
2459                 }
2460
2461                 /* Always report software processing */
2462                 if(Usage & WINED3DUSAGE_SOFTWAREPROCESSING)
2463                     UsageCaps |= WINED3DUSAGE_SOFTWAREPROCESSING;
2464
2465                 /* Check QUERY_FILTER support */
2466                 if(Usage & WINED3DUSAGE_QUERY_FILTER) {
2467                     if(CheckFilterCapability(Adapter, CheckFormat)) {
2468                         UsageCaps |= WINED3DUSAGE_QUERY_FILTER;
2469                     } else {
2470                         TRACE_(d3d_caps)("[FAILED] - No query filter support\n");
2471                         return WINED3DERR_NOTAVAILABLE;
2472                     }
2473                 }
2474
2475                 /* Check QUERY_POSTPIXELSHADER_BLENDING support */
2476                 if(Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING) {
2477                     if(CheckPostPixelShaderBlendingCapability(Adapter, CheckFormat)) {
2478                         UsageCaps |= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
2479                     } else {
2480                         TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
2481                         return WINED3DERR_NOTAVAILABLE;
2482                     }
2483                 }
2484
2485                 /* Check QUERY_SRGBREAD support */
2486                 if(Usage & WINED3DUSAGE_QUERY_SRGBREAD) {
2487                     if(CheckSrgbReadCapability(Adapter, CheckFormat)) {
2488                         UsageCaps |= WINED3DUSAGE_QUERY_SRGBREAD;
2489                     } else {
2490                         TRACE_(d3d_caps)("[FAILED] - No query srgbread support\n");
2491                         return WINED3DERR_NOTAVAILABLE;
2492                     }
2493                 }
2494
2495                 /* Check QUERY_SRGBWRITE support */
2496                 if(Usage & WINED3DUSAGE_QUERY_SRGBWRITE) {
2497                     if(CheckSrgbWriteCapability(Adapter, DeviceType, CheckFormat)) {
2498                         UsageCaps |= WINED3DUSAGE_QUERY_SRGBWRITE;
2499                     } else {
2500                         TRACE_(d3d_caps)("[FAILED] - No query srgbwrite support\n");
2501                         return WINED3DERR_NOTAVAILABLE;
2502                     }
2503                 }
2504
2505                 /* Check QUERY_VERTEXTEXTURE support */
2506                 if(Usage & WINED3DUSAGE_QUERY_VERTEXTEXTURE) {
2507                     if(CheckVertexTextureCapability(Adapter, CheckFormat)) {
2508                         UsageCaps |= WINED3DUSAGE_QUERY_VERTEXTEXTURE;
2509                     } else {
2510                         TRACE_(d3d_caps)("[FAILED] - No query vertextexture support\n");
2511                         return WINED3DERR_NOTAVAILABLE;
2512                     }
2513                 }
2514
2515                 /* Check QUERY_WRAPANDMIP support */
2516                 if(Usage & WINED3DUSAGE_QUERY_WRAPANDMIP) {
2517                     if(CheckWrapAndMipCapability(Adapter, CheckFormat)) {
2518                         UsageCaps |= WINED3DUSAGE_QUERY_WRAPANDMIP;
2519                     } else {
2520                         TRACE_(d3d_caps)("[FAILED] - No wrapping and mipmapping support\n");
2521                         return WINED3DERR_NOTAVAILABLE;
2522                     }
2523                 }
2524             } else {
2525                 TRACE_(d3d_caps)("[FAILED] - Cube texture format not supported\n");
2526                 return WINED3DERR_NOTAVAILABLE;
2527             }
2528         } else {
2529             TRACE_(d3d_caps)("[FAILED] - No cube texture support\n");
2530             return WINED3DERR_NOTAVAILABLE;
2531         }
2532     } else if(RType == WINED3DRTYPE_SURFACE) {
2533         /* Surface allows:
2534          *                - D3DUSAGE_DEPTHSTENCIL
2535          *                - D3DUSAGE_NONSECURE (d3d9ex)
2536          *                - D3DUSAGE_RENDERTARGET
2537          */
2538
2539         if(Usage & WINED3DUSAGE_DEPTHSTENCIL) {
2540             if(CheckDepthStencilCapability(Adapter, AdapterFormat, CheckFormat)) {
2541                 UsageCaps |= WINED3DUSAGE_DEPTHSTENCIL;
2542             } else {
2543                 TRACE_(d3d_caps)("[FAILED] - No depthstencil support\n");
2544                 return WINED3DERR_NOTAVAILABLE;
2545             }
2546         }
2547
2548         if(Usage & WINED3DUSAGE_RENDERTARGET) {
2549             if(CheckRenderTargetCapability(AdapterFormat, CheckFormat)) {
2550                 UsageCaps |= WINED3DUSAGE_RENDERTARGET;
2551             } else {
2552                 TRACE_(d3d_caps)("[FAILED] - No rendertarget support\n");
2553                  return WINED3DERR_NOTAVAILABLE;
2554             }
2555         }
2556
2557         /* Check QUERY_POSTPIXELSHADER_BLENDING support */
2558         if(Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING) {
2559             if(CheckPostPixelShaderBlendingCapability(Adapter, CheckFormat)) {
2560                 UsageCaps |= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
2561             } else {
2562                 TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
2563                 return WINED3DERR_NOTAVAILABLE;
2564             }
2565         }
2566     } else if(RType == WINED3DRTYPE_TEXTURE) {
2567         /* Texture allows:
2568          *                - D3DUSAGE_AUTOGENMIPMAP
2569          *                - D3DUSAGE_DEPTHSTENCIL
2570          *                - D3DUSAGE_DMAP
2571          *                - D3DUSAGE_DYNAMIC
2572          *                - D3DUSAGE_NONSECURE (d3d9ex)
2573          *                - D3DUSAGE_RENDERTARGET
2574          *                - D3DUSAGE_SOFTWAREPROCESSING
2575          *                - D3DUSAGE_TEXTAPI (d3d9ex)
2576          *                - D3DUSAGE_QUERY_WRAPANDMIP
2577          */
2578
2579         /* Check if the texture format is around */
2580         if(CheckTextureCapability(Adapter, CheckFormat)) {
2581             if(Usage & WINED3DUSAGE_AUTOGENMIPMAP) {
2582                 /* Check for automatic mipmap generation support */
2583                 if(GL_SUPPORT(SGIS_GENERATE_MIPMAP)) {
2584                     UsageCaps |= WINED3DUSAGE_AUTOGENMIPMAP;
2585                 } else {
2586                     /* When autogenmipmap isn't around continue and return WINED3DOK_NOAUTOGEN instead of D3D_OK */
2587                     TRACE_(d3d_caps)("[FAILED] - No autogenmipmap support, but continuing\n");
2588                 }
2589             }
2590
2591             /* Always report dynamic locking */
2592             if(Usage & WINED3DUSAGE_DYNAMIC)
2593                 UsageCaps |= WINED3DUSAGE_DYNAMIC;
2594
2595             if(Usage & WINED3DUSAGE_RENDERTARGET) {
2596                 if(CheckRenderTargetCapability(AdapterFormat, CheckFormat)) {
2597                     UsageCaps |= WINED3DUSAGE_RENDERTARGET;
2598                 } else {
2599                     TRACE_(d3d_caps)("[FAILED] - No rendertarget support\n");
2600                      return WINED3DERR_NOTAVAILABLE;
2601                  }
2602             }
2603
2604             /* Always report software processing */
2605             if(Usage & WINED3DUSAGE_SOFTWAREPROCESSING)
2606                 UsageCaps |= WINED3DUSAGE_SOFTWAREPROCESSING;
2607
2608             /* Check QUERY_FILTER support */
2609             if(Usage & WINED3DUSAGE_QUERY_FILTER) {
2610                 if(CheckFilterCapability(Adapter, CheckFormat)) {
2611                     UsageCaps |= WINED3DUSAGE_QUERY_FILTER;
2612                 } else {
2613                     TRACE_(d3d_caps)("[FAILED] - No query filter support\n");
2614                     return WINED3DERR_NOTAVAILABLE;
2615                 }
2616             }
2617
2618             /* Check QUERY_LEGACYBUMPMAP support */
2619             if(Usage & WINED3DUSAGE_QUERY_LEGACYBUMPMAP) {
2620                 if(CheckBumpMapCapability(Adapter, CheckFormat)) {
2621                     UsageCaps |= WINED3DUSAGE_QUERY_LEGACYBUMPMAP;
2622                 } else {
2623                     TRACE_(d3d_caps)("[FAILED] - No legacy bumpmap support\n");
2624                     return WINED3DERR_NOTAVAILABLE;
2625                 }
2626             }
2627
2628             /* Check QUERY_POSTPIXELSHADER_BLENDING support */
2629             if(Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING) {
2630                 if(CheckPostPixelShaderBlendingCapability(Adapter, CheckFormat)) {
2631                     UsageCaps |= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
2632                 } else {
2633                     TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
2634                     return WINED3DERR_NOTAVAILABLE;
2635                 }
2636             }
2637
2638             /* Check QUERY_SRGBREAD support */
2639             if(Usage & WINED3DUSAGE_QUERY_SRGBREAD) {
2640                 if(CheckSrgbReadCapability(Adapter, CheckFormat)) {
2641                     UsageCaps |= WINED3DUSAGE_QUERY_SRGBREAD;
2642                 } else {
2643                     TRACE_(d3d_caps)("[FAILED] - No query srgbread support\n");
2644                     return WINED3DERR_NOTAVAILABLE;
2645                 }
2646             }
2647
2648             /* Check QUERY_SRGBWRITE support */
2649             if(Usage & WINED3DUSAGE_QUERY_SRGBWRITE) {
2650                 if(CheckSrgbWriteCapability(Adapter, DeviceType, CheckFormat)) {
2651                     UsageCaps |= WINED3DUSAGE_QUERY_SRGBWRITE;
2652                 } else {
2653                     TRACE_(d3d_caps)("[FAILED] - No query srgbwrite support\n");
2654                     return WINED3DERR_NOTAVAILABLE;
2655                 }
2656             }
2657
2658             /* Check QUERY_VERTEXTEXTURE support */
2659             if(Usage & WINED3DUSAGE_QUERY_VERTEXTEXTURE) {
2660                 if(CheckVertexTextureCapability(Adapter, CheckFormat)) {
2661                     UsageCaps |= WINED3DUSAGE_QUERY_VERTEXTEXTURE;
2662                 } else {
2663                     TRACE_(d3d_caps)("[FAILED] - No query vertextexture support\n");
2664                     return WINED3DERR_NOTAVAILABLE;
2665                 }
2666             }
2667
2668             /* Check QUERY_WRAPANDMIP support */
2669             if(Usage & WINED3DUSAGE_QUERY_WRAPANDMIP) {
2670                 if(CheckWrapAndMipCapability(Adapter, CheckFormat)) {
2671                     UsageCaps |= WINED3DUSAGE_QUERY_WRAPANDMIP;
2672                 } else {
2673                     TRACE_(d3d_caps)("[FAILED] - No wrapping and mipmapping support\n");
2674                     return WINED3DERR_NOTAVAILABLE;
2675                 }
2676             }
2677
2678             if(Usage & WINED3DUSAGE_DEPTHSTENCIL) {
2679                 if(CheckDepthStencilCapability(Adapter, AdapterFormat, CheckFormat)) {
2680                     UsageCaps |= WINED3DUSAGE_DEPTHSTENCIL;
2681                 } else {
2682                     TRACE_(d3d_caps)("[FAILED] - No depth stencil support\n");
2683                     return WINED3DERR_NOTAVAILABLE;
2684                 }
2685             }
2686         } else {
2687             TRACE_(d3d_caps)("[FAILED] - Texture format not supported\n");
2688             return WINED3DERR_NOTAVAILABLE;
2689         }
2690     } else if((RType == WINED3DRTYPE_VOLUME) || (RType == WINED3DRTYPE_VOLUMETEXTURE)) {
2691         /* Volume is to VolumeTexture what Surface is to Texture but its usage caps are not documented.
2692          * Most driver seem to offer (nearly) the same on Volume and VolumeTexture, so do that too.
2693          *
2694          * Volumetexture allows:
2695          *                      - D3DUSAGE_DYNAMIC
2696          *                      - D3DUSAGE_NONSECURE (d3d9ex)
2697          *                      - D3DUSAGE_SOFTWAREPROCESSING
2698          *                      - D3DUSAGE_QUERY_WRAPANDMIP
2699          */
2700
2701         /* Check volume texture and volume usage caps */
2702         if(GL_SUPPORT(EXT_TEXTURE3D)) {
2703             if(CheckTextureCapability(Adapter, CheckFormat) == FALSE) {
2704                 TRACE_(d3d_caps)("[FAILED] - Format not supported\n");
2705                 return WINED3DERR_NOTAVAILABLE;
2706             }
2707
2708             /* Always report dynamic locking */
2709             if(Usage & WINED3DUSAGE_DYNAMIC)
2710                 UsageCaps |= WINED3DUSAGE_DYNAMIC;
2711
2712             /* Always report software processing */
2713             if(Usage & WINED3DUSAGE_SOFTWAREPROCESSING)
2714                 UsageCaps |= WINED3DUSAGE_SOFTWAREPROCESSING;
2715
2716             /* Check QUERY_FILTER support */
2717             if(Usage & WINED3DUSAGE_QUERY_FILTER) {
2718                 if(CheckFilterCapability(Adapter, CheckFormat)) {
2719                     UsageCaps |= WINED3DUSAGE_QUERY_FILTER;
2720                 } else {
2721                     TRACE_(d3d_caps)("[FAILED] - No query filter support\n");
2722                     return WINED3DERR_NOTAVAILABLE;
2723                 }
2724             }
2725
2726             /* Check QUERY_POSTPIXELSHADER_BLENDING support */
2727             if(Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING) {
2728                 if(CheckPostPixelShaderBlendingCapability(Adapter, CheckFormat)) {
2729                     UsageCaps |= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
2730                 } else {
2731                     TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
2732                     return WINED3DERR_NOTAVAILABLE;
2733                 }
2734             }
2735
2736             /* Check QUERY_SRGBREAD support */
2737             if(Usage & WINED3DUSAGE_QUERY_SRGBREAD) {
2738                 if(CheckSrgbReadCapability(Adapter, CheckFormat)) {
2739                     UsageCaps |= WINED3DUSAGE_QUERY_SRGBREAD;
2740                 } else {
2741                     TRACE_(d3d_caps)("[FAILED] - No query srgbread support\n");
2742                     return WINED3DERR_NOTAVAILABLE;
2743                 }
2744             }
2745
2746             /* Check QUERY_SRGBWRITE support */
2747             if(Usage & WINED3DUSAGE_QUERY_SRGBWRITE) {
2748                 if(CheckSrgbWriteCapability(Adapter, DeviceType, CheckFormat)) {
2749                     UsageCaps |= WINED3DUSAGE_QUERY_SRGBWRITE;
2750                 } else {
2751                     TRACE_(d3d_caps)("[FAILED] - No query srgbwrite support\n");
2752                     return WINED3DERR_NOTAVAILABLE;
2753                 }
2754             }
2755
2756             /* Check QUERY_VERTEXTEXTURE support */
2757             if(Usage & WINED3DUSAGE_QUERY_VERTEXTEXTURE) {
2758                 if(CheckVertexTextureCapability(Adapter, CheckFormat)) {
2759                     UsageCaps |= WINED3DUSAGE_QUERY_VERTEXTEXTURE;
2760                 } else {
2761                     TRACE_(d3d_caps)("[FAILED] - No query vertextexture support\n");
2762                     return WINED3DERR_NOTAVAILABLE;
2763                 }
2764             }
2765
2766             /* Check QUERY_WRAPANDMIP support */
2767             if(Usage & WINED3DUSAGE_QUERY_WRAPANDMIP) {
2768                 if(CheckWrapAndMipCapability(Adapter, CheckFormat)) {
2769                     UsageCaps |= WINED3DUSAGE_QUERY_WRAPANDMIP;
2770                 } else {
2771                     TRACE_(d3d_caps)("[FAILED] - No wrapping and mipmapping support\n");
2772                     return WINED3DERR_NOTAVAILABLE;
2773                 }
2774             }
2775         } else {
2776             TRACE_(d3d_caps)("[FAILED] - No volume texture support\n");
2777             return WINED3DERR_NOTAVAILABLE;
2778         }
2779
2780         /* Filter formats that need conversion; For one part, this conversion is unimplemented,
2781          * and volume textures are huge, so it would be a big performance hit. Unless we hit an
2782          * app needing one of those formats, don't advertize them to avoid leading apps into
2783          * temptation. The windows drivers don't support most of those formats on volumes anyway,
2784          * except of R32F.
2785          */
2786         switch(CheckFormat) {
2787             case WINED3DFMT_P8:
2788             case WINED3DFMT_A4L4:
2789             case WINED3DFMT_R32F:
2790             case WINED3DFMT_R16F:
2791             case WINED3DFMT_X8L8V8U8:
2792             case WINED3DFMT_L6V5U5:
2793             case WINED3DFMT_G16R16:
2794                 TRACE_(d3d_caps)("[FAILED] - No converted formats on volumes\n");
2795                 return WINED3DERR_NOTAVAILABLE;
2796
2797             case WINED3DFMT_Q8W8V8U8:
2798             case WINED3DFMT_V16U16:
2799             if(!GL_SUPPORT(NV_TEXTURE_SHADER)) {
2800                 TRACE_(d3d_caps)("[FAILED] - No converted formats on volumes\n");
2801                 return WINED3DERR_NOTAVAILABLE;
2802             }
2803             break;
2804
2805             case WINED3DFMT_V8U8:
2806             if(!GL_SUPPORT(NV_TEXTURE_SHADER) || !GL_SUPPORT(ATI_ENVMAP_BUMPMAP)) {
2807                 TRACE_(d3d_caps)("[FAILED] - No converted formats on volumes\n");
2808                 return WINED3DERR_NOTAVAILABLE;
2809             }
2810             break;
2811
2812             case WINED3DFMT_DXT1:
2813             case WINED3DFMT_DXT2:
2814             case WINED3DFMT_DXT3:
2815             case WINED3DFMT_DXT4:
2816             case WINED3DFMT_DXT5:
2817                 /* The GL_EXT_texture_compression_s3tc spec requires that loading an s3tc
2818                  * compressed texture results in an error. While the D3D refrast does
2819                  * support s3tc volumes, at least the nvidia windows driver does not, so
2820                  * we're free not to support this format.
2821                  */
2822                 TRACE_(d3d_caps)("[FAILED] - DXTn does not support 3D textures\n");
2823                 return WINED3DERR_NOTAVAILABLE;
2824
2825             default:
2826                 /* Do nothing, continue with checking the format below */
2827                 break;
2828         }
2829     } else if((RType == WINED3DRTYPE_INDEXBUFFER) || (RType == WINED3DRTYPE_VERTEXBUFFER)){
2830         /* For instance vertexbuffer/indexbuffer aren't supported yet because no Windows drivers seem to offer it */
2831         TRACE_(d3d_caps)("Unhandled resource type D3DRTYPE_INDEXBUFFER / D3DRTYPE_VERTEXBUFFER\n");
2832         return WINED3DERR_NOTAVAILABLE;
2833      }
2834
2835     /* This format is nothing special and it is supported perfectly.
2836      * However, ati and nvidia driver on windows do not mark this format as
2837      * supported (tested with the dxCapsViewer) and pretending to
2838      * support this format uncovers a bug in Battlefield 1942 (fonts are missing)
2839      * So do the same as Windows drivers and pretend not to support it on dx8 and 9
2840      * Enable it on dx7. It will need additional checking on dx10 when we support it.
2841      */
2842     if(This->dxVersion > 7 && CheckFormat == WINED3DFMT_R8G8B8) {
2843         TRACE_(d3d_caps)("[FAILED]\n");
2844         return WINED3DERR_NOTAVAILABLE;
2845     }
2846
2847     /* When the UsageCaps exactly matches Usage return WINED3D_OK except for the situation in which
2848      * WINED3DUSAGE_AUTOGENMIPMAP isn't around, then WINED3DOK_NOAUTOGEN is returned if all the other
2849      * usage flags match. */
2850     if(UsageCaps == Usage) {
2851         return WINED3D_OK;
2852     } else if((UsageCaps == (Usage & ~WINED3DUSAGE_AUTOGENMIPMAP)) && (Usage & WINED3DUSAGE_AUTOGENMIPMAP)){
2853         return WINED3DOK_NOAUTOGEN;
2854     } else {
2855         TRACE_(d3d_caps)("[FAILED] - Usage=%#08x requested for CheckFormat=%s and RType=%d but only %#08x is available\n", Usage, debug_d3dformat(CheckFormat), RType, UsageCaps);
2856         return WINED3DERR_NOTAVAILABLE;
2857     }
2858 }
2859
2860 static HRESULT  WINAPI IWineD3DImpl_CheckDeviceFormatConversion(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
2861                                                           WINED3DFORMAT SourceFormat, WINED3DFORMAT TargetFormat) {
2862     IWineD3DImpl *This = (IWineD3DImpl *)iface;
2863
2864     FIXME_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, DevType:(%u,%s), SrcFmt:(%u,%s), TgtFmt:(%u,%s))\n",
2865           This,
2866           Adapter,
2867           DeviceType, debug_d3ddevicetype(DeviceType),
2868           SourceFormat, debug_d3dformat(SourceFormat),
2869           TargetFormat, debug_d3dformat(TargetFormat));
2870     return WINED3D_OK;
2871 }
2872
2873 static const shader_backend_t *select_shader_backend(UINT Adapter, WINED3DDEVTYPE DeviceType) {
2874     const shader_backend_t *ret;
2875     int vs_selected_mode;
2876     int ps_selected_mode;
2877
2878     select_shader_mode(&GLINFO_LOCATION, DeviceType, &ps_selected_mode, &vs_selected_mode);
2879     if (vs_selected_mode == SHADER_GLSL || ps_selected_mode == SHADER_GLSL) {
2880         ret = &glsl_shader_backend;
2881     } else if (vs_selected_mode == SHADER_ARB || ps_selected_mode == SHADER_ARB) {
2882         ret = &arb_program_shader_backend;
2883     } else {
2884         ret = &none_shader_backend;
2885     }
2886     return ret;
2887 }
2888
2889 static const struct fragment_pipeline *select_fragment_implementation(UINT Adapter, WINED3DDEVTYPE DeviceType) {
2890     int vs_selected_mode;
2891     int ps_selected_mode;
2892
2893     select_shader_mode(&GLINFO_LOCATION, DeviceType, &ps_selected_mode, &vs_selected_mode);
2894     if(ps_selected_mode == SHADER_ATI) {
2895         return &atifs_fragment_pipeline;
2896     } else if(GL_SUPPORT(NV_REGISTER_COMBINERS) && GL_SUPPORT(NV_TEXTURE_SHADER2)) {
2897         return &nvts_fragment_pipeline;
2898     } else if(GL_SUPPORT(NV_REGISTER_COMBINERS)) {
2899         return &nvrc_fragment_pipeline;
2900     } else {
2901         return &ffp_fragment_pipeline;
2902     }
2903 }
2904
2905 /* Note: d3d8 passes in a pointer to a D3DCAPS8 structure, which is a true
2906       subset of a D3DCAPS9 structure. However, it has to come via a void *
2907       as the d3d8 interface cannot import the d3d9 header                  */
2908 static HRESULT WINAPI IWineD3DImpl_GetDeviceCaps(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType, WINED3DCAPS* pCaps) {
2909
2910     IWineD3DImpl    *This = (IWineD3DImpl *)iface;
2911     int vs_selected_mode;
2912     int ps_selected_mode;
2913     struct shader_caps shader_caps;
2914     struct fragment_caps fragment_caps;
2915     const shader_backend_t *shader_backend;
2916     const struct fragment_pipeline *frag_pipeline = NULL;
2917
2918     TRACE_(d3d_caps)("(%p)->(Adptr:%d, DevType: %x, pCaps: %p)\n", This, Adapter, DeviceType, pCaps);
2919
2920     if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
2921         return WINED3DERR_INVALIDCALL;
2922     }
2923
2924     select_shader_mode(&Adapters[Adapter].gl_info, DeviceType, &ps_selected_mode, &vs_selected_mode);
2925
2926     /* This function should *not* be modifying GL caps
2927      * TODO: move the functionality where it belongs */
2928     select_shader_max_constants(ps_selected_mode, vs_selected_mode, &Adapters[Adapter].gl_info);
2929
2930     /* ------------------------------------------------
2931        The following fields apply to both d3d8 and d3d9
2932        ------------------------------------------------ */
2933     pCaps->DeviceType              = (DeviceType == WINED3DDEVTYPE_HAL) ? WINED3DDEVTYPE_HAL : WINED3DDEVTYPE_REF;  /* Not quite true, but use h/w supported by opengl I suppose */
2934     pCaps->AdapterOrdinal          = Adapter;
2935
2936     pCaps->Caps                    = 0;
2937     pCaps->Caps2                   = WINED3DCAPS2_CANRENDERWINDOWED |
2938                                      WINED3DCAPS2_FULLSCREENGAMMA |
2939                                      WINED3DCAPS2_DYNAMICTEXTURES;
2940     if(GL_SUPPORT(SGIS_GENERATE_MIPMAP)) {
2941         pCaps->Caps2 |= WINED3DCAPS2_CANAUTOGENMIPMAP;
2942     }
2943     pCaps->Caps3                   = WINED3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD;
2944     pCaps->PresentationIntervals   = WINED3DPRESENT_INTERVAL_IMMEDIATE  |
2945                                      WINED3DPRESENT_INTERVAL_ONE;
2946
2947     pCaps->CursorCaps              = WINED3DCURSORCAPS_COLOR            |
2948                                      WINED3DCURSORCAPS_LOWRES;
2949
2950     pCaps->DevCaps                 = WINED3DDEVCAPS_FLOATTLVERTEX       |
2951                                      WINED3DDEVCAPS_EXECUTESYSTEMMEMORY |
2952                                      WINED3DDEVCAPS_TLVERTEXSYSTEMMEMORY|
2953                                      WINED3DDEVCAPS_TLVERTEXVIDEOMEMORY |
2954                                      WINED3DDEVCAPS_DRAWPRIMTLVERTEX    |
2955                                      WINED3DDEVCAPS_HWTRANSFORMANDLIGHT |
2956                                      WINED3DDEVCAPS_EXECUTEVIDEOMEMORY  |
2957                                      WINED3DDEVCAPS_PUREDEVICE          |
2958                                      WINED3DDEVCAPS_HWRASTERIZATION     |
2959                                      WINED3DDEVCAPS_TEXTUREVIDEOMEMORY  |
2960                                      WINED3DDEVCAPS_TEXTURESYSTEMMEMORY |
2961                                      WINED3DDEVCAPS_CANRENDERAFTERFLIP  |
2962                                      WINED3DDEVCAPS_DRAWPRIMITIVES2     |
2963                                      WINED3DDEVCAPS_DRAWPRIMITIVES2EX   |
2964                                      WINED3DDEVCAPS_RTPATCHES;
2965
2966     pCaps->PrimitiveMiscCaps       = WINED3DPMISCCAPS_CULLNONE              |
2967                                      WINED3DPMISCCAPS_CULLCCW               |
2968                                      WINED3DPMISCCAPS_CULLCW                |
2969                                      WINED3DPMISCCAPS_COLORWRITEENABLE      |
2970                                      WINED3DPMISCCAPS_CLIPTLVERTS           |
2971                                      WINED3DPMISCCAPS_CLIPPLANESCALEDPOINTS |
2972                                      WINED3DPMISCCAPS_MASKZ                 |
2973                                      WINED3DPMISCCAPS_BLENDOP               |
2974                                      WINED3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING;
2975                                     /* TODO:
2976                                         WINED3DPMISCCAPS_NULLREFERENCE
2977                                         WINED3DPMISCCAPS_INDEPENDENTWRITEMASKS
2978                                         WINED3DPMISCCAPS_FOGANDSPECULARALPHA
2979                                         WINED3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS
2980                                         WINED3DPMISCCAPS_FOGVERTEXCLAMPED */
2981
2982     if(GL_SUPPORT(EXT_BLEND_EQUATION_SEPARATE) && GL_SUPPORT(EXT_BLEND_FUNC_SEPARATE))
2983         pCaps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_SEPARATEALPHABLEND;
2984
2985     pCaps->RasterCaps              = WINED3DPRASTERCAPS_DITHER    |
2986                                      WINED3DPRASTERCAPS_PAT       |
2987                                      WINED3DPRASTERCAPS_WFOG      |
2988                                      WINED3DPRASTERCAPS_ZFOG      |
2989                                      WINED3DPRASTERCAPS_FOGVERTEX |
2990                                      WINED3DPRASTERCAPS_FOGTABLE  |
2991                                      WINED3DPRASTERCAPS_STIPPLE   |
2992                                      WINED3DPRASTERCAPS_SUBPIXEL  |
2993                                      WINED3DPRASTERCAPS_ZTEST     |
2994                                      WINED3DPRASTERCAPS_SCISSORTEST   |
2995                                      WINED3DPRASTERCAPS_SLOPESCALEDEPTHBIAS |
2996                                      WINED3DPRASTERCAPS_DEPTHBIAS;
2997
2998     if (GL_SUPPORT(EXT_TEXTURE_FILTER_ANISOTROPIC)) {
2999         pCaps->RasterCaps |= WINED3DPRASTERCAPS_ANISOTROPY    |
3000                              WINED3DPRASTERCAPS_ZBIAS         |
3001                              WINED3DPRASTERCAPS_MIPMAPLODBIAS;
3002     }
3003     if(GL_SUPPORT(NV_FOG_DISTANCE)) {
3004         pCaps->RasterCaps         |= WINED3DPRASTERCAPS_FOGRANGE;
3005     }
3006                         /* FIXME Add:
3007                            WINED3DPRASTERCAPS_COLORPERSPECTIVE
3008                            WINED3DPRASTERCAPS_STRETCHBLTMULTISAMPLE
3009                            WINED3DPRASTERCAPS_ANTIALIASEDGES
3010                            WINED3DPRASTERCAPS_ZBUFFERLESSHSR
3011                            WINED3DPRASTERCAPS_WBUFFER */
3012
3013     pCaps->ZCmpCaps = WINED3DPCMPCAPS_ALWAYS       |
3014                       WINED3DPCMPCAPS_EQUAL        |
3015                       WINED3DPCMPCAPS_GREATER      |
3016                       WINED3DPCMPCAPS_GREATEREQUAL |
3017                       WINED3DPCMPCAPS_LESS         |
3018                       WINED3DPCMPCAPS_LESSEQUAL    |
3019                       WINED3DPCMPCAPS_NEVER        |
3020                       WINED3DPCMPCAPS_NOTEQUAL;
3021
3022     pCaps->SrcBlendCaps  = WINED3DPBLENDCAPS_BOTHINVSRCALPHA |
3023                            WINED3DPBLENDCAPS_BOTHSRCALPHA    |
3024                            WINED3DPBLENDCAPS_DESTALPHA       |
3025                            WINED3DPBLENDCAPS_DESTCOLOR       |
3026                            WINED3DPBLENDCAPS_INVDESTALPHA    |
3027                            WINED3DPBLENDCAPS_INVDESTCOLOR    |
3028                            WINED3DPBLENDCAPS_INVSRCALPHA     |
3029                            WINED3DPBLENDCAPS_INVSRCCOLOR     |
3030                            WINED3DPBLENDCAPS_ONE             |
3031                            WINED3DPBLENDCAPS_SRCALPHA        |
3032                            WINED3DPBLENDCAPS_SRCALPHASAT     |
3033                            WINED3DPBLENDCAPS_SRCCOLOR        |
3034                            WINED3DPBLENDCAPS_ZERO;
3035
3036     pCaps->DestBlendCaps = WINED3DPBLENDCAPS_DESTALPHA       |
3037                            WINED3DPBLENDCAPS_DESTCOLOR       |
3038                            WINED3DPBLENDCAPS_INVDESTALPHA    |
3039                            WINED3DPBLENDCAPS_INVDESTCOLOR    |
3040                            WINED3DPBLENDCAPS_INVSRCALPHA     |
3041                            WINED3DPBLENDCAPS_INVSRCCOLOR     |
3042                            WINED3DPBLENDCAPS_ONE             |
3043                            WINED3DPBLENDCAPS_SRCALPHA        |
3044                            WINED3DPBLENDCAPS_SRCCOLOR        |
3045                            WINED3DPBLENDCAPS_ZERO;
3046     /* NOTE: WINED3DPBLENDCAPS_SRCALPHASAT is not supported as dest blend factor,
3047      * according to the glBlendFunc manpage
3048      *
3049      * WINED3DPBLENDCAPS_BOTHINVSRCALPHA and WINED3DPBLENDCAPS_BOTHSRCALPHA are
3050      * legacy settings for srcblend only
3051      */
3052
3053     if( GL_SUPPORT(EXT_BLEND_COLOR)) {
3054         pCaps->SrcBlendCaps |= WINED3DPBLENDCAPS_BLENDFACTOR;
3055         pCaps->DestBlendCaps |= WINED3DPBLENDCAPS_BLENDFACTOR;
3056     }
3057
3058
3059     pCaps->AlphaCmpCaps = WINED3DPCMPCAPS_ALWAYS       |
3060                           WINED3DPCMPCAPS_EQUAL        |
3061                           WINED3DPCMPCAPS_GREATER      |
3062                           WINED3DPCMPCAPS_GREATEREQUAL |
3063                           WINED3DPCMPCAPS_LESS         |
3064                           WINED3DPCMPCAPS_LESSEQUAL    |
3065                           WINED3DPCMPCAPS_NEVER        |
3066                           WINED3DPCMPCAPS_NOTEQUAL;
3067
3068     pCaps->ShadeCaps     = WINED3DPSHADECAPS_SPECULARGOURAUDRGB |
3069                            WINED3DPSHADECAPS_COLORGOURAUDRGB    |
3070                            WINED3DPSHADECAPS_ALPHAFLATBLEND     |
3071                            WINED3DPSHADECAPS_ALPHAGOURAUDBLEND  |
3072                            WINED3DPSHADECAPS_COLORFLATRGB       |
3073                            WINED3DPSHADECAPS_FOGFLAT            |
3074                            WINED3DPSHADECAPS_FOGGOURAUD         |
3075                            WINED3DPSHADECAPS_SPECULARFLATRGB;
3076
3077     pCaps->TextureCaps =  WINED3DPTEXTURECAPS_ALPHA              |
3078                           WINED3DPTEXTURECAPS_ALPHAPALETTE       |
3079                           WINED3DPTEXTURECAPS_BORDER             |
3080                           WINED3DPTEXTURECAPS_MIPMAP             |
3081                           WINED3DPTEXTURECAPS_PROJECTED          |
3082                           WINED3DPTEXTURECAPS_PERSPECTIVE;
3083
3084     if( !GL_SUPPORT(ARB_TEXTURE_NON_POWER_OF_TWO)) {
3085         pCaps->TextureCaps |= WINED3DPTEXTURECAPS_POW2 |
3086                               WINED3DPTEXTURECAPS_NONPOW2CONDITIONAL;
3087     }
3088
3089     if( GL_SUPPORT(EXT_TEXTURE3D)) {
3090         pCaps->TextureCaps |=  WINED3DPTEXTURECAPS_VOLUMEMAP      |
3091                                WINED3DPTEXTURECAPS_MIPVOLUMEMAP   |
3092                                WINED3DPTEXTURECAPS_VOLUMEMAP_POW2;
3093     }
3094
3095     if (GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
3096         pCaps->TextureCaps |= WINED3DPTEXTURECAPS_CUBEMAP     |
3097                               WINED3DPTEXTURECAPS_MIPCUBEMAP    |
3098                               WINED3DPTEXTURECAPS_CUBEMAP_POW2;
3099
3100     }
3101
3102     pCaps->TextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR       |
3103                                WINED3DPTFILTERCAPS_MAGFPOINT        |
3104                                WINED3DPTFILTERCAPS_MINFLINEAR       |
3105                                WINED3DPTFILTERCAPS_MINFPOINT        |
3106                                WINED3DPTFILTERCAPS_MIPFLINEAR       |
3107                                WINED3DPTFILTERCAPS_MIPFPOINT        |
3108                                WINED3DPTFILTERCAPS_LINEAR           |
3109                                WINED3DPTFILTERCAPS_LINEARMIPLINEAR  |
3110                                WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
3111                                WINED3DPTFILTERCAPS_MIPLINEAR        |
3112                                WINED3DPTFILTERCAPS_MIPNEAREST       |
3113                                WINED3DPTFILTERCAPS_NEAREST;
3114
3115     if (GL_SUPPORT(EXT_TEXTURE_FILTER_ANISOTROPIC)) {
3116         pCaps->TextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC |
3117                                     WINED3DPTFILTERCAPS_MINFANISOTROPIC;
3118     }
3119
3120     if (GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
3121         pCaps->CubeTextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR       |
3122                                        WINED3DPTFILTERCAPS_MAGFPOINT        |
3123                                        WINED3DPTFILTERCAPS_MINFLINEAR       |
3124                                        WINED3DPTFILTERCAPS_MINFPOINT        |
3125                                        WINED3DPTFILTERCAPS_MIPFLINEAR       |
3126                                        WINED3DPTFILTERCAPS_MIPFPOINT        |
3127                                        WINED3DPTFILTERCAPS_LINEAR           |
3128                                        WINED3DPTFILTERCAPS_LINEARMIPLINEAR  |
3129                                        WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
3130                                        WINED3DPTFILTERCAPS_MIPLINEAR        |
3131                                        WINED3DPTFILTERCAPS_MIPNEAREST       |
3132                                        WINED3DPTFILTERCAPS_NEAREST;
3133
3134         if (GL_SUPPORT(EXT_TEXTURE_FILTER_ANISOTROPIC)) {
3135             pCaps->CubeTextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC |
3136                                             WINED3DPTFILTERCAPS_MINFANISOTROPIC;
3137         }
3138     } else
3139         pCaps->CubeTextureFilterCaps = 0;
3140
3141     if (GL_SUPPORT(EXT_TEXTURE3D)) {
3142         pCaps->VolumeTextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR       |
3143                                          WINED3DPTFILTERCAPS_MAGFPOINT        |
3144                                          WINED3DPTFILTERCAPS_MINFLINEAR       |
3145                                          WINED3DPTFILTERCAPS_MINFPOINT        |
3146                                          WINED3DPTFILTERCAPS_MIPFLINEAR       |
3147                                          WINED3DPTFILTERCAPS_MIPFPOINT        |
3148                                          WINED3DPTFILTERCAPS_LINEAR           |
3149                                          WINED3DPTFILTERCAPS_LINEARMIPLINEAR  |
3150                                          WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
3151                                          WINED3DPTFILTERCAPS_MIPLINEAR        |
3152                                          WINED3DPTFILTERCAPS_MIPNEAREST       |
3153                                          WINED3DPTFILTERCAPS_NEAREST;
3154     } else
3155         pCaps->VolumeTextureFilterCaps = 0;
3156
3157     pCaps->TextureAddressCaps =  WINED3DPTADDRESSCAPS_INDEPENDENTUV |
3158                                  WINED3DPTADDRESSCAPS_CLAMP  |
3159                                  WINED3DPTADDRESSCAPS_WRAP;
3160
3161     if (GL_SUPPORT(ARB_TEXTURE_BORDER_CLAMP)) {
3162         pCaps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_BORDER;
3163     }
3164     if (GL_SUPPORT(ARB_TEXTURE_MIRRORED_REPEAT)) {
3165         pCaps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRROR;
3166     }
3167     if (GL_SUPPORT(ATI_TEXTURE_MIRROR_ONCE)) {
3168         pCaps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRRORONCE;
3169     }
3170
3171     if (GL_SUPPORT(EXT_TEXTURE3D)) {
3172         pCaps->VolumeTextureAddressCaps =  WINED3DPTADDRESSCAPS_INDEPENDENTUV |
3173                                            WINED3DPTADDRESSCAPS_CLAMP  |
3174                                            WINED3DPTADDRESSCAPS_WRAP;
3175         if (GL_SUPPORT(ARB_TEXTURE_BORDER_CLAMP)) {
3176             pCaps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_BORDER;
3177         }
3178         if (GL_SUPPORT(ARB_TEXTURE_MIRRORED_REPEAT)) {
3179             pCaps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRROR;
3180         }
3181         if (GL_SUPPORT(ATI_TEXTURE_MIRROR_ONCE)) {
3182             pCaps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRRORONCE;
3183         }
3184     } else
3185         pCaps->VolumeTextureAddressCaps = 0;
3186
3187     pCaps->LineCaps = WINED3DLINECAPS_TEXTURE |
3188                       WINED3DLINECAPS_ZTEST;
3189                       /* FIXME: Add
3190                         WINED3DLINECAPS_BLEND
3191                         WINED3DLINECAPS_ALPHACMP
3192                         WINED3DLINECAPS_FOG */
3193
3194     pCaps->MaxTextureWidth  = GL_LIMITS(texture_size);
3195     pCaps->MaxTextureHeight = GL_LIMITS(texture_size);
3196
3197     if(GL_SUPPORT(EXT_TEXTURE3D))
3198         pCaps->MaxVolumeExtent = GL_LIMITS(texture3d_size);
3199     else
3200         pCaps->MaxVolumeExtent = 0;
3201
3202     pCaps->MaxTextureRepeat = 32768;
3203     pCaps->MaxTextureAspectRatio = GL_LIMITS(texture_size);
3204     pCaps->MaxVertexW = 1.0;
3205
3206     pCaps->GuardBandLeft = 0;
3207     pCaps->GuardBandTop = 0;
3208     pCaps->GuardBandRight = 0;
3209     pCaps->GuardBandBottom = 0;
3210
3211     pCaps->ExtentsAdjust = 0;
3212
3213     pCaps->StencilCaps =  WINED3DSTENCILCAPS_DECRSAT |
3214                           WINED3DSTENCILCAPS_INCRSAT |
3215                           WINED3DSTENCILCAPS_INVERT  |
3216                           WINED3DSTENCILCAPS_KEEP    |
3217                           WINED3DSTENCILCAPS_REPLACE |
3218                           WINED3DSTENCILCAPS_ZERO;
3219     if (GL_SUPPORT(EXT_STENCIL_WRAP)) {
3220         pCaps->StencilCaps |= WINED3DSTENCILCAPS_DECR  |
3221                               WINED3DSTENCILCAPS_INCR;
3222     }
3223     if ( This->dxVersion > 8 &&
3224         ( GL_SUPPORT(EXT_STENCIL_TWO_SIDE) ||
3225             GL_SUPPORT(ATI_SEPARATE_STENCIL) ) ) {
3226         pCaps->StencilCaps |= WINED3DSTENCILCAPS_TWOSIDED;
3227     }
3228
3229     pCaps->FVFCaps = WINED3DFVFCAPS_PSIZE | 0x0008; /* 8 texture coords */
3230
3231     pCaps->MaxUserClipPlanes       = GL_LIMITS(clipplanes);
3232     pCaps->MaxActiveLights         = GL_LIMITS(lights);
3233
3234     pCaps->MaxVertexBlendMatrices      = GL_LIMITS(blends);
3235     pCaps->MaxVertexBlendMatrixIndex   = 0;
3236
3237     pCaps->MaxAnisotropy   = GL_LIMITS(anisotropy);
3238     pCaps->MaxPointSize    = GL_LIMITS(pointsize);
3239
3240
3241     pCaps->VertexProcessingCaps = WINED3DVTXPCAPS_DIRECTIONALLIGHTS |
3242                                   WINED3DVTXPCAPS_MATERIALSOURCE7   |
3243                                   WINED3DVTXPCAPS_POSITIONALLIGHTS  |
3244                                   WINED3DVTXPCAPS_LOCALVIEWER       |
3245                                   WINED3DVTXPCAPS_VERTEXFOG         |
3246                                   WINED3DVTXPCAPS_TEXGEN;
3247                                   /* FIXME: Add
3248                                      D3DVTXPCAPS_TWEENING, D3DVTXPCAPS_TEXGEN_SPHEREMAP */
3249
3250     pCaps->MaxPrimitiveCount   = 0xFFFFF; /* For now set 2^20-1 which is used by most >=Geforce3/Radeon8500 cards */
3251     pCaps->MaxVertexIndex      = 0xFFFFF;
3252     pCaps->MaxStreams          = MAX_STREAMS;
3253     pCaps->MaxStreamStride     = 1024;
3254
3255     /* d3d9.dll sets D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES here because StretchRects is implemented in d3d9 */
3256     pCaps->DevCaps2                          = WINED3DDEVCAPS2_STREAMOFFSET;
3257     /* TODO: VS3.0 needs at least D3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET */
3258     pCaps->MaxNpatchTessellationLevel        = 0;
3259     pCaps->MasterAdapterOrdinal              = 0;
3260     pCaps->AdapterOrdinalInGroup             = 0;
3261     pCaps->NumberOfAdaptersInGroup           = 1;
3262
3263     pCaps->NumSimultaneousRTs = GL_LIMITS(buffers);
3264
3265     pCaps->StretchRectFilterCaps             = WINED3DPTFILTERCAPS_MINFPOINT  |
3266                                                 WINED3DPTFILTERCAPS_MAGFPOINT  |
3267                                                 WINED3DPTFILTERCAPS_MINFLINEAR |
3268                                                 WINED3DPTFILTERCAPS_MAGFLINEAR;
3269     pCaps->VertexTextureFilterCaps           = 0;
3270
3271     memset(&shader_caps, 0, sizeof(shader_caps));
3272     shader_backend = select_shader_backend(Adapter, DeviceType);
3273     shader_backend->shader_get_caps(DeviceType, &GLINFO_LOCATION, &shader_caps);
3274
3275     memset(&fragment_caps, 0, sizeof(fragment_caps));
3276     frag_pipeline = select_fragment_implementation(Adapter, DeviceType);
3277     frag_pipeline->get_caps(DeviceType, &GLINFO_LOCATION, &fragment_caps);
3278
3279     /* Add shader misc caps. Only some of them belong to the shader parts of the pipeline */
3280     pCaps->PrimitiveMiscCaps |= fragment_caps.PrimitiveMiscCaps;
3281
3282     /* This takes care for disabling vertex shader or pixel shader caps while leaving the other one enabled.
3283      * Ignore shader model capabilities if disabled in config
3284      */
3285     if(vs_selected_mode == SHADER_NONE) {
3286         TRACE_(d3d_caps)("Vertex shader disabled in config, reporting version 0.0\n");
3287         pCaps->VertexShaderVersion          = WINED3DVS_VERSION(0,0);
3288         pCaps->MaxVertexShaderConst         = 0;
3289     } else {
3290         pCaps->VertexShaderVersion          = shader_caps.VertexShaderVersion;
3291         pCaps->MaxVertexShaderConst         = shader_caps.MaxVertexShaderConst;
3292     }
3293
3294     if(ps_selected_mode == SHADER_NONE) {
3295         TRACE_(d3d_caps)("Pixel shader disabled in config, reporting version 0.0\n");
3296         pCaps->PixelShaderVersion           = WINED3DPS_VERSION(0,0);
3297         pCaps->PixelShader1xMaxValue        = 0.0;
3298     } else {
3299         pCaps->PixelShaderVersion           = shader_caps.PixelShaderVersion;
3300         pCaps->PixelShader1xMaxValue        = shader_caps.PixelShader1xMaxValue;
3301     }
3302
3303     pCaps->TextureOpCaps                    = fragment_caps.TextureOpCaps;
3304     pCaps->MaxTextureBlendStages            = fragment_caps.MaxTextureBlendStages;
3305     pCaps->MaxSimultaneousTextures          = fragment_caps.MaxSimultaneousTextures;
3306
3307     pCaps->VS20Caps                         = shader_caps.VS20Caps;
3308     pCaps->MaxVShaderInstructionsExecuted   = shader_caps.MaxVShaderInstructionsExecuted;
3309     pCaps->MaxVertexShader30InstructionSlots= shader_caps.MaxVertexShader30InstructionSlots;
3310     pCaps->PS20Caps                         = shader_caps.PS20Caps;
3311     pCaps->MaxPShaderInstructionsExecuted   = shader_caps.MaxPShaderInstructionsExecuted;
3312     pCaps->MaxPixelShader30InstructionSlots = shader_caps.MaxPixelShader30InstructionSlots;
3313
3314     /* The following caps are shader specific, but they are things we cannot detect, or which
3315      * are the same among all shader models. So to avoid code duplication set the shader version
3316      * specific, but otherwise constant caps here
3317      */
3318     if(pCaps->VertexShaderVersion == WINED3DVS_VERSION(3,0)) {
3319         /* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering)
3320         use the VS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum VS3.0 value. */
3321         pCaps->VS20Caps.Caps                     = WINED3DVS20CAPS_PREDICATION;
3322         pCaps->VS20Caps.DynamicFlowControlDepth  = WINED3DVS20_MAX_DYNAMICFLOWCONTROLDEPTH; /* VS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
3323         pCaps->VS20Caps.NumTemps                 = max(32, GLINFO_LOCATION.vs_arb_max_temps);
3324         pCaps->VS20Caps.StaticFlowControlDepth   = WINED3DVS20_MAX_STATICFLOWCONTROLDEPTH ; /* level of nesting in loops / if-statements; VS 3.0 requires MAX (4) */
3325
3326         pCaps->MaxVShaderInstructionsExecuted    = 65535; /* VS 3.0 needs at least 65535, some cards even use 2^32-1 */
3327         pCaps->MaxVertexShader30InstructionSlots = max(512, GLINFO_LOCATION.vs_arb_max_instructions);
3328     } else if(pCaps->VertexShaderVersion == WINED3DVS_VERSION(2,0)) {
3329         pCaps->VS20Caps.Caps                     = 0;
3330         pCaps->VS20Caps.DynamicFlowControlDepth  = WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH;
3331         pCaps->VS20Caps.NumTemps                 = max(12, GLINFO_LOCATION.vs_arb_max_temps);
3332         pCaps->VS20Caps.StaticFlowControlDepth   = 1;
3333
3334         pCaps->MaxVShaderInstructionsExecuted    = 65535;
3335         pCaps->MaxVertexShader30InstructionSlots = 0;
3336     } else { /* VS 1.x */
3337         pCaps->VS20Caps.Caps                     = 0;
3338         pCaps->VS20Caps.DynamicFlowControlDepth  = 0;
3339         pCaps->VS20Caps.NumTemps                 = 0;
3340         pCaps->VS20Caps.StaticFlowControlDepth   = 0;
3341
3342         pCaps->MaxVShaderInstructionsExecuted    = 0;
3343         pCaps->MaxVertexShader30InstructionSlots = 0;
3344     }
3345
3346     if(pCaps->PixelShaderVersion == WINED3DPS_VERSION(3,0)) {
3347         /* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering)
3348         use the PS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum PS 3.0 value. */
3349
3350         /* 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 */
3351         pCaps->PS20Caps.Caps                     = WINED3DPS20CAPS_ARBITRARYSWIZZLE     |
3352                 WINED3DPS20CAPS_GRADIENTINSTRUCTIONS |
3353                 WINED3DPS20CAPS_PREDICATION          |
3354                 WINED3DPS20CAPS_NODEPENDENTREADLIMIT |
3355                 WINED3DPS20CAPS_NOTEXINSTRUCTIONLIMIT;
3356         pCaps->PS20Caps.DynamicFlowControlDepth  = WINED3DPS20_MAX_DYNAMICFLOWCONTROLDEPTH; /* PS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
3357         pCaps->PS20Caps.NumTemps                 = max(32, GLINFO_LOCATION.ps_arb_max_temps);
3358         pCaps->PS20Caps.StaticFlowControlDepth   = WINED3DPS20_MAX_STATICFLOWCONTROLDEPTH; /* PS 3.0 requires MAX_STATICFLOWCONTROLDEPTH (4) */
3359         pCaps->PS20Caps.NumInstructionSlots      = WINED3DPS20_MAX_NUMINSTRUCTIONSLOTS; /* PS 3.0 requires MAX_NUMINSTRUCTIONSLOTS (512) */
3360
3361         pCaps->MaxPShaderInstructionsExecuted    = 65535;
3362         pCaps->MaxPixelShader30InstructionSlots  = max(WINED3DMIN30SHADERINSTRUCTIONS, GLINFO_LOCATION.ps_arb_max_instructions);
3363     } else if(pCaps->PixelShaderVersion == WINED3DPS_VERSION(2,0)) {
3364         /* Below we assume PS2.0 specs, not extended 2.0a(GeforceFX)/2.0b(Radeon R3xx) ones */
3365         pCaps->PS20Caps.Caps                     = 0;
3366         pCaps->PS20Caps.DynamicFlowControlDepth  = 0; /* WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH = 0 */
3367         pCaps->PS20Caps.NumTemps                 = max(12, GLINFO_LOCATION.ps_arb_max_temps);
3368         pCaps->PS20Caps.StaticFlowControlDepth   = WINED3DPS20_MIN_STATICFLOWCONTROLDEPTH; /* Minimum: 1 */
3369         pCaps->PS20Caps.NumInstructionSlots      = WINED3DPS20_MIN_NUMINSTRUCTIONSLOTS; /* Minimum number (64 ALU + 32 Texture), a GeforceFX uses 512 */
3370
3371         pCaps->MaxPShaderInstructionsExecuted    = 512; /* Minimum value, a GeforceFX uses 1024 */
3372         pCaps->MaxPixelShader30InstructionSlots  = 0;
3373     } else { /* PS 1.x */
3374         pCaps->PS20Caps.Caps                     = 0;
3375         pCaps->PS20Caps.DynamicFlowControlDepth  = 0;
3376         pCaps->PS20Caps.NumTemps                 = 0;
3377         pCaps->PS20Caps.StaticFlowControlDepth   = 0;
3378         pCaps->PS20Caps.NumInstructionSlots      = 0;
3379
3380         pCaps->MaxPShaderInstructionsExecuted    = 0;
3381         pCaps->MaxPixelShader30InstructionSlots  = 0;
3382     }
3383
3384     if(pCaps->VertexShaderVersion >= WINED3DVS_VERSION(2,0)) {
3385         /* OpenGL supports all the formats below, perhaps not always
3386          * without conversion, but it supports them.
3387          * Further GLSL doesn't seem to have an official unsigned type so
3388          * don't advertise it yet as I'm not sure how we handle it.
3389          * We might need to add some clamping in the shader engine to
3390          * support it.
3391          * TODO: WINED3DDTCAPS_USHORT2N, WINED3DDTCAPS_USHORT4N, WINED3DDTCAPS_UDEC3, WINED3DDTCAPS_DEC3N */
3392         pCaps->DeclTypes = WINED3DDTCAPS_UBYTE4    |
3393                            WINED3DDTCAPS_UBYTE4N   |
3394                            WINED3DDTCAPS_SHORT2N   |
3395                            WINED3DDTCAPS_SHORT4N;
3396         if (GL_SUPPORT(NV_HALF_FLOAT)) {
3397             pCaps->DeclTypes |= WINED3DDTCAPS_FLOAT16_2 |
3398                                 WINED3DDTCAPS_FLOAT16_4;
3399         }
3400     } else
3401         pCaps->DeclTypes                         = 0;
3402
3403     return WINED3D_OK;
3404 }
3405
3406 /* Note due to structure differences between dx8 and dx9 D3DPRESENT_PARAMETERS,
3407    and fields being inserted in the middle, a new structure is used in place    */
3408 static HRESULT  WINAPI IWineD3DImpl_CreateDevice(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType, HWND hFocusWindow,
3409                                            DWORD BehaviourFlags, IWineD3DDevice** ppReturnedDeviceInterface,
3410                                            IUnknown *parent) {
3411
3412     IWineD3DDeviceImpl *object  = NULL;
3413     IWineD3DImpl       *This    = (IWineD3DImpl *)iface;
3414     WINED3DDISPLAYMODE  mode;
3415     const struct fragment_pipeline *frag_pipeline = NULL;
3416     int i;
3417
3418     /* Validate the adapter number. If no adapters are available(no GL), ignore the adapter
3419      * number and create a device without a 3D adapter for 2D only operation.
3420      */
3421     if (IWineD3D_GetAdapterCount(iface) && Adapter >= IWineD3D_GetAdapterCount(iface)) {
3422         return WINED3DERR_INVALIDCALL;
3423     }
3424
3425     /* Create a WineD3DDevice object */
3426     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IWineD3DDeviceImpl));
3427     *ppReturnedDeviceInterface = (IWineD3DDevice *)object;
3428     TRACE("Created WineD3DDevice object @ %p\n", object);
3429     if (NULL == object) {
3430       return WINED3DERR_OUTOFVIDEOMEMORY;
3431     }
3432
3433     /* Set up initial COM information */
3434     object->lpVtbl  = &IWineD3DDevice_Vtbl;
3435     object->ref     = 1;
3436     object->wineD3D = iface;
3437     object->adapter = numAdapters ? &Adapters[Adapter] : NULL;
3438     IWineD3D_AddRef(object->wineD3D);
3439     object->parent  = parent;
3440     list_init(&object->resources);
3441     list_init(&object->shaders);
3442
3443     if(This->dxVersion == 7) {
3444         object->surface_alignment = 8;
3445     } else {
3446         object->surface_alignment = 4;
3447     }
3448     object->posFixup[0] = 1.0; /* This is needed to get the x coord unmodified through a MAD */
3449
3450     /* Set the state up as invalid until the device is fully created */
3451     object->state   = WINED3DERR_DRIVERINTERNALERROR;
3452
3453     TRACE("(%p)->(Adptr:%d, DevType: %x, FocusHwnd: %p, BehFlags: %x, RetDevInt: %p)\n", This, Adapter, DeviceType,
3454           hFocusWindow, BehaviourFlags, ppReturnedDeviceInterface);
3455
3456     /* Save the creation parameters */
3457     object->createParms.AdapterOrdinal = Adapter;
3458     object->createParms.DeviceType     = DeviceType;
3459     object->createParms.hFocusWindow   = hFocusWindow;
3460     object->createParms.BehaviorFlags  = BehaviourFlags;
3461
3462     /* Initialize other useful values */
3463     object->adapterNo                    = Adapter;
3464     object->devType                      = DeviceType;
3465
3466     select_shader_mode(&GLINFO_LOCATION, DeviceType, &object->ps_selected_mode, &object->vs_selected_mode);
3467     object->shader_backend = select_shader_backend(Adapter, DeviceType);
3468
3469     frag_pipeline = select_fragment_implementation(Adapter, DeviceType);
3470     object->frag_pipe = frag_pipeline;
3471     compile_state_table(object->StateTable, object->multistate_funcs, &GLINFO_LOCATION,
3472                         ffp_vertexstate_template, frag_pipeline, misc_state_template);
3473
3474     /* Prefer the vtable with functions optimized for single dirtifyable objects if the shader
3475      * model can deal with that. It is essentially the same, just with adjusted
3476      * Set*ShaderConstantF implementations
3477      */
3478     if(object->shader_backend->shader_dirtifyable_constants((IWineD3DDevice *) object)) {
3479         object->lpVtbl  = &IWineD3DDevice_DirtyConst_Vtbl;
3480     }
3481
3482     /* set the state of the device to valid */
3483     object->state = WINED3D_OK;
3484
3485     /* Get the initial screen setup for ddraw */
3486     IWineD3DImpl_GetAdapterDisplayMode(iface, Adapter, &mode);
3487
3488     object->ddraw_width = mode.Width;
3489     object->ddraw_height = mode.Height;
3490     object->ddraw_format = mode.Format;
3491
3492     for(i = 0; i < PATCHMAP_SIZE; i++) {
3493         list_init(&object->patches[i]);
3494     }
3495     return WINED3D_OK;
3496 }
3497 #undef GLINFO_LOCATION
3498
3499 static HRESULT WINAPI IWineD3DImpl_GetParent(IWineD3D *iface, IUnknown **pParent) {
3500     IWineD3DImpl *This = (IWineD3DImpl *)iface;
3501     IUnknown_AddRef(This->parent);
3502     *pParent = This->parent;
3503     return WINED3D_OK;
3504 }
3505
3506 ULONG WINAPI D3DCB_DefaultDestroySurface(IWineD3DSurface *pSurface) {
3507     IUnknown* surfaceParent;
3508     TRACE("(%p) call back\n", pSurface);
3509
3510     /* Now, release the parent, which will take care of cleaning up the surface for us */
3511     IWineD3DSurface_GetParent(pSurface, &surfaceParent);
3512     IUnknown_Release(surfaceParent);
3513     return IUnknown_Release(surfaceParent);
3514 }
3515
3516 ULONG WINAPI D3DCB_DefaultDestroyVolume(IWineD3DVolume *pVolume) {
3517     IUnknown* volumeParent;
3518     TRACE("(%p) call back\n", pVolume);
3519
3520     /* Now, release the parent, which will take care of cleaning up the volume for us */
3521     IWineD3DVolume_GetParent(pVolume, &volumeParent);
3522     IUnknown_Release(volumeParent);
3523     return IUnknown_Release(volumeParent);
3524 }
3525
3526 static BOOL implementation_is_apple(WineD3D_GL_Info *gl_info) {
3527     /* MacOS has various specialities in the extensions it advertises. Some have to be loaded from
3528      * the opengl 1.2+ core, while other extensions are advertised, but software emulated. So try to
3529      * detect the Apple OpenGL implementation to apply some extension fixups afterwards.
3530      *
3531      * Detecting this isn't really easy. The vendor string doesn't mention Apple. Compile-time checks
3532      * aren't sufficient either because a Linux binary may display on a macos X server via remote X11.
3533      * So try to detect the GL implementation by looking at certain Apple extensions. Some extensions
3534      * like client storage might be supported on other implementations too, but GL_APPLE_flush_render
3535      * is specific to the Mac OS X window management, and GL_APPLE_ycbcr_422 is QuickTime specific. So
3536      * the chance that other implementations support them is rather small since Win32 QuickTime uses
3537      * DirectDraw, not OpenGL.
3538      */
3539     if(gl_info->supported[APPLE_FENCE] &&
3540        gl_info->supported[APPLE_CLIENT_STORAGE] &&
3541        gl_info->supported[APPLE_FLUSH_RENDER] &&
3542        gl_info->supported[APPLE_YCBCR_422]) {
3543         TRACE_(d3d_caps)("GL_APPLE_fence, GL_APPLE_client_storage, GL_APPLE_flush_render and GL_ycbcr_422 are supported\n");
3544         TRACE_(d3d_caps)("Activating MacOS fixups\n");
3545         return TRUE;
3546     } else {
3547         TRACE_(d3d_caps)("Apple extensions are not supported\n");
3548         TRACE_(d3d_caps)("Not activating MacOS fixups\n");
3549         return FALSE;
3550     }
3551 }
3552
3553 #define GLINFO_LOCATION (*gl_info)
3554 static void test_pbo_functionality(WineD3D_GL_Info *gl_info) {
3555     /* Some OpenGL implementations, namely Apple's Geforce 8 driver, advertises PBOs,
3556      * but glTexSubImage from a PBO fails miserably, with the first line repeated over
3557      * all the texture. This function detects this bug by its symptom and disables PBOs
3558      * if the test fails.
3559      *
3560      * The test uploads a 4x4 texture via the PBO in the "native" format GL_BGRA,
3561      * GL_UNSIGNED_INT_8_8_8_8_REV. This format triggers the bug, and it is what we use
3562      * for D3DFMT_A8R8G8B8. Then the texture is read back without any PBO and the data
3563      * read back is compared to the original. If they are equal PBOs are assumed to work,
3564      * otherwise the PBO extension is disabled.
3565      */
3566     GLuint texture, pbo;
3567     static const unsigned int pattern[] = {
3568         0x00000000, 0x000000ff, 0x0000ff00, 0x40ff0000,
3569         0x80ffffff, 0x40ffff00, 0x00ff00ff, 0x0000ffff,
3570         0x00ffff00, 0x00ff00ff, 0x0000ffff, 0x000000ff,
3571         0x80ff00ff, 0x0000ffff, 0x00ff00ff, 0x40ff00ff
3572     };
3573     unsigned int check[sizeof(pattern) / sizeof(pattern[0])];
3574
3575     if(!gl_info->supported[ARB_PIXEL_BUFFER_OBJECT]) {
3576         /* No PBO -> No point in testing them */
3577         return;
3578     }
3579
3580     while(glGetError());
3581     glGenTextures(1, &texture);
3582     glBindTexture(GL_TEXTURE_2D, texture);
3583     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, 0);
3584     checkGLcall("Specifying the PBO test texture\n");
3585
3586     GL_EXTCALL(glGenBuffersARB(1, &pbo));
3587     GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pbo));
3588     GL_EXTCALL(glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, sizeof(pattern), pattern, GL_STREAM_DRAW_ARB));
3589     checkGLcall("Specifying the PBO test pbo\n");
3590
3591     glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL);
3592     checkGLcall("Loading the PBO test texture\n");
3593
3594     GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
3595     glFinish(); /* just to be sure */
3596
3597     memset(check, 0, sizeof(check));
3598     glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, check);
3599     checkGLcall("Reading back the PBO test texture\n");
3600
3601     glDeleteTextures(1, &texture);
3602     GL_EXTCALL(glDeleteBuffersARB(1, &pbo));
3603     checkGLcall("PBO test cleanup\n");
3604
3605     if(memcmp(check, pattern, sizeof(check)) != 0) {
3606         WARN_(d3d_caps)("PBO test failed, read back data doesn't match original\n");
3607         WARN_(d3d_caps)("Disabling PBOs. This may result in slower performance\n");
3608         gl_info->supported[ARB_PIXEL_BUFFER_OBJECT] = FALSE;
3609     } else {
3610         TRACE_(d3d_caps)("PBO test successful\n");
3611     }
3612 }
3613 #undef GLINFO_LOCATION
3614
3615 /* Certain applications(Steam) complain if we report an outdated driver version. In general,
3616  * reporting a driver version is moot because we are not the Windows driver, and we have different
3617  * bugs, features, etc.
3618  *
3619  * If a card is not found in this table, the gl driver version is reported
3620  */
3621 struct driver_version_information {
3622     WORD vendor;                        /* reported PCI card vendor ID  */
3623     WORD card;                          /* reported PCI card device ID  */
3624     WORD hipart_hi, hipart_lo;          /* driver hiword to report      */
3625     WORD lopart_hi, lopart_lo;          /* driver loword to report      */
3626 };
3627
3628 static const struct driver_version_information driver_version_table[] = {
3629     /* Nvidia drivers. Geforce6 and newer cards are supported by the current driver (177.x)*/
3630     /* GeforceFX support is up to 173.x, Geforce2MX/3/4 up to 96.x, TNT/Geforce1/2 up to 71.x */
3631     /* Note that version numbers >100 lets say 123.45 use >= x.y.11.2345 and not x.y.10.12345 */
3632     {VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCEFX_5200,     7,  15, 11, 7341   },
3633     {VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCEFX_5600,     7,  15, 11, 7341   },
3634     {VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCEFX_5800,     7,  15, 11, 7341   },
3635     {VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_6200,       7,  15, 11, 7341   },
3636     {VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_6600GT,     7,  15, 11, 7341   },
3637     {VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_6800,       7,  15, 11, 7341   },
3638     {VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_7400,       7,  15, 11, 7341   },
3639     {VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_7300,       7,  15, 11, 7341   },
3640     {VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_7600,       7,  15, 11, 7341   },
3641     {VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_7800GT,     7,  15, 11, 7341   },
3642     {VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_8300GS,     7,  15, 11, 7341   },
3643     {VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_8600GT,     7,  15, 11, 7341   },
3644     {VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_8600MGT,    7,  15, 11, 7341   },
3645     {VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_8800GTS,    7,  15, 11, 7341   },
3646     {VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_9600GT,     7,  15, 11, 7341    },
3647     {VENDOR_NVIDIA,     CARD_NVIDIA_GEFORCE_9800GT,     7,  15, 11, 7341    },
3648
3649     /* ATI cards. The driver versions are somewhat similar, but not quite the same. Let's hardcode */
3650     {VENDOR_ATI,        CARD_ATI_RADEON_9500,           6,  14, 10, 6764    },
3651     {VENDOR_ATI,        CARD_ATI_RADEON_X700,           6,  14, 10, 6764    },
3652     {VENDOR_ATI,        CARD_ATI_RADEON_X1600,          6,  14, 10, 6764    },
3653     {VENDOR_ATI,        CARD_ATI_RADEON_HD2300,         6,  14, 10, 6764    },
3654     {VENDOR_ATI,        CARD_ATI_RADEON_HD2600,         6,  14, 10, 6764    },
3655     {VENDOR_ATI,        CARD_ATI_RADEON_HD2900,         6,  14, 10, 6764    },
3656
3657     /* TODO: Add information about legacy nvidia and ATI hardware, Intel and other cards */
3658 };
3659
3660 static void fixup_extensions(WineD3D_GL_Info *gl_info) {
3661     unsigned int i;
3662     BOOL apple = implementation_is_apple(gl_info);
3663
3664     if(apple) {
3665         /* MacOS advertises more GLSL vertex shader uniforms than supported by the hardware, and if more are
3666          * used it falls back to software. While the compiler can detect if the shader uses all declared
3667          * uniforms, the optimization fails if the shader uses relative addressing. So any GLSL shader
3668          * using relative addressing falls back to software.
3669          *
3670          * ARB vp gives the correct amount of uniforms, so use it instead of GLSL
3671          */
3672         if(gl_info->vs_glsl_constantsF <= gl_info->vs_arb_constantsF) {
3673             FIXME("GLSL doesn't advertise more vertex shader uniforms than ARB. Driver fixup outdated?\n");
3674         } else {
3675             TRACE("Driver claims %u GLSL vs uniforms, replacing with %u ARB vp uniforms\n",
3676                   gl_info->vs_glsl_constantsF, gl_info->vs_arb_constantsF);
3677             gl_info->vs_glsl_constantsF = gl_info->vs_arb_constantsF;
3678         }
3679
3680         /* The Intel GPUs on MacOS set the .w register of texcoords to 0.0 by default, which causes problems
3681          * with fixed function fragment processing. Ideally this flag should be detected with a test shader
3682          * and OpenGL feedback mode, but some GL implementations (MacOS ATI at least, probably all MacOS ones)
3683          * do not like vertex shaders in feedback mode and return an error, even though it should be valid
3684          * according to the spec.
3685          *
3686          * We don't want to enable this on all cards, as it adds an extra instruction per texcoord used. This
3687          * makes the shader slower and eats instruction slots which should be available to the d3d app.
3688          *
3689          * ATI Radeon HD 2xxx cards on MacOS have the issue. Instead of checking for the buggy cards, blacklist
3690          * all radeon cards on Macs and whitelist the good ones. That way we're prepared for the future. If
3691          * this workaround is activated on cards that do not need it, it won't break things, just affect
3692          * performance negatively.
3693          */
3694         if(gl_info->gl_vendor == VENDOR_INTEL ||
3695            (gl_info->gl_vendor == VENDOR_ATI && gl_info->gl_card != CARD_ATI_RADEON_X1600)) {
3696             TRACE("Enabling vertex texture coord fixes in vertex shaders\n");
3697             gl_info->set_texcoord_w = TRUE;
3698         }
3699     }
3700
3701     /* MacOS advertises GL_ARB_texture_non_power_of_two on ATI r500 and earlier cards, although
3702      * these cards only support GL_ARB_texture_rectangle(D3DPTEXTURECAPS_NONPOW2CONDITIONAL).
3703      * If real NP2 textures are used, the driver falls back to software. We could just remove the
3704      * extension and use GL_ARB_texture_rectangle instead, but texture_rectangle is inconventient
3705      * due to the non-normalized texture coordinates. Thus set an internal extension flag,
3706      * GL_WINE_normalized_texrect, which signals the code that it can use non power of two textures
3707      * as per GL_ARB_texture_non_power_of_two, but has to stick to the texture_rectangle limits.
3708      *
3709      * fglrx doesn't advertise GL_ARB_texture_non_power_of_two, but it advertises opengl 2.0 which
3710      * has this extension promoted to core. The extension loading code sets this extension supported
3711      * due to that, so this code works on fglrx as well.
3712      */
3713     if(gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] && gl_info->gl_vendor == VENDOR_ATI) {
3714         if(gl_info->gl_card == CARD_ATI_RADEON_X700 || gl_info->gl_card == CARD_ATI_RADEON_X1600 ||
3715             gl_info->gl_card == CARD_ATI_RADEON_9500 || gl_info->gl_card == CARD_ATI_RADEON_8500  ||
3716             gl_info->gl_card == CARD_ATI_RADEON_7200 || gl_info->gl_card == CARD_ATI_RAGE_128PRO) {
3717             TRACE("GL_ARB_texture_non_power_of_two advertised on R500 or earlier card, removing\n");
3718             gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] = FALSE;
3719             gl_info->supported[WINE_NORMALIZED_TEXRECT] = TRUE;
3720         }
3721     }
3722
3723     /* Find out if PBOs work as they are supposed to */
3724     test_pbo_functionality(gl_info);
3725
3726     /* Fixup the driver version */
3727     for(i = 0; i < (sizeof(driver_version_table) / sizeof(driver_version_table[0])); i++) {
3728         if(gl_info->gl_vendor == driver_version_table[i].vendor &&
3729            gl_info->gl_card   == driver_version_table[i].card) {
3730             TRACE_(d3d_caps)("Found card 0x%04x, 0x%04x in driver version DB\n", gl_info->gl_vendor, gl_info->gl_card);
3731
3732             gl_info->driver_version        = MAKEDWORD_VERSION(driver_version_table[i].lopart_hi,
3733                                                                driver_version_table[i].lopart_lo);
3734             gl_info->driver_version_hipart = MAKEDWORD_VERSION(driver_version_table[i].hipart_hi,
3735                                                                driver_version_table[i].hipart_lo);
3736             break;
3737         }
3738     }
3739 }
3740
3741 void invalid_func(void *data) {
3742     ERR("Invalid vertex attribute function called\n");
3743     DebugBreak();
3744 }
3745
3746 #define GLINFO_LOCATION (Adapters[0].gl_info)
3747
3748 /* Helper functions for providing vertex data to opengl. The arrays are initialized based on
3749  * the extension detection and are used in drawStridedSlow
3750  */
3751 static void position_d3dcolor(void *data) {
3752     DWORD pos = *((DWORD *) data);
3753
3754     FIXME("Add a test for fixed function position from d3dcolor type\n");
3755     glVertex4s(D3DCOLOR_B_R(pos),
3756                D3DCOLOR_B_G(pos),
3757                D3DCOLOR_B_B(pos),
3758                D3DCOLOR_B_A(pos));
3759 }
3760 static void position_float4(void *data) {
3761     GLfloat *pos = (float *) data;
3762
3763     if (pos[3] < eps && pos[3] > -eps)
3764         glVertex3fv(pos);
3765     else {
3766         float w = 1.0 / pos[3];
3767
3768         glVertex4f(pos[0] * w, pos[1] * w, pos[2] * w, w);
3769     }
3770 }
3771
3772 static void diffuse_d3dcolor(void *data) {
3773     DWORD diffuseColor = *((DWORD *) data);
3774
3775     glColor4ub(D3DCOLOR_B_R(diffuseColor),
3776                D3DCOLOR_B_G(diffuseColor),
3777                D3DCOLOR_B_B(diffuseColor),
3778                D3DCOLOR_B_A(diffuseColor));
3779 }
3780
3781 static void specular_d3dcolor(void *data) {
3782     DWORD specularColor = *((DWORD *) data);
3783
3784     GL_EXTCALL(glSecondaryColor3ubEXT)(D3DCOLOR_B_R(specularColor),
3785                                        D3DCOLOR_B_G(specularColor),
3786                                        D3DCOLOR_B_B(specularColor));
3787 }
3788 static void warn_no_specular_func(void *data) {
3789     WARN("GL_EXT_secondary_color not supported\n");
3790 }
3791
3792 void fillGLAttribFuncs(WineD3D_GL_Info *gl_info) {
3793     position_funcs[WINED3DDECLTYPE_FLOAT1]      = (void *) invalid_func;
3794     position_funcs[WINED3DDECLTYPE_FLOAT2]      = (void *) invalid_func;
3795     position_funcs[WINED3DDECLTYPE_FLOAT3]      = (void *) glVertex3fv;
3796     position_funcs[WINED3DDECLTYPE_FLOAT4]      = (void *) position_float4;
3797     position_funcs[WINED3DDECLTYPE_D3DCOLOR]    = (void *) position_d3dcolor;
3798     position_funcs[WINED3DDECLTYPE_UBYTE4]      = (void *) invalid_func;
3799     position_funcs[WINED3DDECLTYPE_SHORT2]      = (void *) invalid_func;
3800     position_funcs[WINED3DDECLTYPE_SHORT4]      = (void *) glVertex2sv;
3801     position_funcs[WINED3DDECLTYPE_UBYTE4N]     = (void *) invalid_func;
3802     position_funcs[WINED3DDECLTYPE_SHORT2N]     = (void *) invalid_func;
3803     position_funcs[WINED3DDECLTYPE_SHORT4N]     = (void *) invalid_func;
3804     position_funcs[WINED3DDECLTYPE_USHORT2N]    = (void *) invalid_func;
3805     position_funcs[WINED3DDECLTYPE_USHORT4N]    = (void *) invalid_func;
3806     position_funcs[WINED3DDECLTYPE_UDEC3]       = (void *) invalid_func;
3807     position_funcs[WINED3DDECLTYPE_DEC3N]       = (void *) invalid_func;
3808     position_funcs[WINED3DDECLTYPE_FLOAT16_2]   = (void *) invalid_func;
3809     position_funcs[WINED3DDECLTYPE_FLOAT16_4]   = (void *) invalid_func;
3810
3811     diffuse_funcs[WINED3DDECLTYPE_FLOAT1]       = (void *) invalid_func;
3812     diffuse_funcs[WINED3DDECLTYPE_FLOAT2]       = (void *) invalid_func;
3813     diffuse_funcs[WINED3DDECLTYPE_FLOAT3]       = (void *) glColor3fv;
3814     diffuse_funcs[WINED3DDECLTYPE_FLOAT4]       = (void *) glColor4fv;
3815     diffuse_funcs[WINED3DDECLTYPE_D3DCOLOR]     = (void *) diffuse_d3dcolor;
3816     diffuse_funcs[WINED3DDECLTYPE_UBYTE4]       = (void *) invalid_func;
3817     diffuse_funcs[WINED3DDECLTYPE_SHORT2]       = (void *) invalid_func;
3818     diffuse_funcs[WINED3DDECLTYPE_SHORT4]       = (void *) invalid_func;
3819     diffuse_funcs[WINED3DDECLTYPE_UBYTE4N]      = (void *) glColor4ubv;
3820     diffuse_funcs[WINED3DDECLTYPE_SHORT2N]      = (void *) invalid_func;
3821     diffuse_funcs[WINED3DDECLTYPE_SHORT4N]      = (void *) glColor4sv;
3822     diffuse_funcs[WINED3DDECLTYPE_USHORT2N]     = (void *) invalid_func;
3823     diffuse_funcs[WINED3DDECLTYPE_USHORT4N]     = (void *) glColor4usv;
3824     diffuse_funcs[WINED3DDECLTYPE_UDEC3]        = (void *) invalid_func;
3825     diffuse_funcs[WINED3DDECLTYPE_DEC3N]        = (void *) invalid_func;
3826     diffuse_funcs[WINED3DDECLTYPE_FLOAT16_2]    = (void *) invalid_func;
3827     diffuse_funcs[WINED3DDECLTYPE_FLOAT16_4]    = (void *) invalid_func;
3828
3829     /* No 4 component entry points here */
3830     specular_funcs[WINED3DDECLTYPE_FLOAT1]      = (void *) invalid_func;
3831     specular_funcs[WINED3DDECLTYPE_FLOAT2]      = (void *) invalid_func;
3832     if(GL_SUPPORT(EXT_SECONDARY_COLOR)) {
3833         specular_funcs[WINED3DDECLTYPE_FLOAT3]      = (void *) GL_EXTCALL(glSecondaryColor3fvEXT);
3834     } else {
3835         specular_funcs[WINED3DDECLTYPE_FLOAT3]      = (void *) warn_no_specular_func;
3836     }
3837     specular_funcs[WINED3DDECLTYPE_FLOAT4]      = (void *) invalid_func;
3838     if(GL_SUPPORT(EXT_SECONDARY_COLOR)) {
3839         specular_funcs[WINED3DDECLTYPE_D3DCOLOR]    = (void *) specular_d3dcolor;
3840     } else {
3841         specular_funcs[WINED3DDECLTYPE_D3DCOLOR]      = (void *) warn_no_specular_func;
3842     }
3843     specular_funcs[WINED3DDECLTYPE_UBYTE4]      = (void *) invalid_func;
3844     specular_funcs[WINED3DDECLTYPE_SHORT2]      = (void *) invalid_func;
3845     specular_funcs[WINED3DDECLTYPE_SHORT4]      = (void *) invalid_func;
3846     specular_funcs[WINED3DDECLTYPE_UBYTE4N]     = (void *) invalid_func;
3847     specular_funcs[WINED3DDECLTYPE_SHORT2N]     = (void *) invalid_func;
3848     specular_funcs[WINED3DDECLTYPE_SHORT4N]     = (void *) invalid_func;
3849     specular_funcs[WINED3DDECLTYPE_USHORT2N]    = (void *) invalid_func;
3850     specular_funcs[WINED3DDECLTYPE_USHORT4N]    = (void *) invalid_func;
3851     specular_funcs[WINED3DDECLTYPE_UDEC3]       = (void *) invalid_func;
3852     specular_funcs[WINED3DDECLTYPE_DEC3N]       = (void *) invalid_func;
3853     specular_funcs[WINED3DDECLTYPE_FLOAT16_2]   = (void *) invalid_func;
3854     specular_funcs[WINED3DDECLTYPE_FLOAT16_4]   = (void *) invalid_func;
3855
3856     /* Only 3 component entry points here. Test how others behave. Float4 normals are used
3857      * by one of our tests, trying to pass it to the pixel shader, which fails on Windows.
3858      */
3859     normal_funcs[WINED3DDECLTYPE_FLOAT1]         = (void *) invalid_func;
3860     normal_funcs[WINED3DDECLTYPE_FLOAT2]         = (void *) invalid_func;
3861     normal_funcs[WINED3DDECLTYPE_FLOAT3]         = (void *) glNormal3fv;
3862     normal_funcs[WINED3DDECLTYPE_FLOAT4]         = (void *) glNormal3fv; /* Just ignore the 4th value */
3863     normal_funcs[WINED3DDECLTYPE_D3DCOLOR]       = (void *) invalid_func;
3864     normal_funcs[WINED3DDECLTYPE_UBYTE4]         = (void *) invalid_func;
3865     normal_funcs[WINED3DDECLTYPE_SHORT2]         = (void *) invalid_func;
3866     normal_funcs[WINED3DDECLTYPE_SHORT4]         = (void *) invalid_func;
3867     normal_funcs[WINED3DDECLTYPE_UBYTE4N]        = (void *) invalid_func;
3868     normal_funcs[WINED3DDECLTYPE_SHORT2N]        = (void *) invalid_func;
3869     normal_funcs[WINED3DDECLTYPE_SHORT4N]        = (void *) invalid_func;
3870     normal_funcs[WINED3DDECLTYPE_USHORT2N]       = (void *) invalid_func;
3871     normal_funcs[WINED3DDECLTYPE_USHORT4N]       = (void *) invalid_func;
3872     normal_funcs[WINED3DDECLTYPE_UDEC3]          = (void *) invalid_func;
3873     normal_funcs[WINED3DDECLTYPE_DEC3N]          = (void *) invalid_func;
3874     normal_funcs[WINED3DDECLTYPE_FLOAT16_2]      = (void *) invalid_func;
3875     normal_funcs[WINED3DDECLTYPE_FLOAT16_4]      = (void *) invalid_func;
3876 }
3877
3878 #define PUSH1(att)        attribs[nAttribs++] = (att);
3879 BOOL InitAdapters(void) {
3880     static HMODULE mod_gl;
3881     BOOL ret;
3882     int ps_selected_mode, vs_selected_mode;
3883
3884     /* No need to hold any lock. The calling library makes sure only one thread calls
3885      * wined3d simultaneously
3886      */
3887     if(numAdapters > 0) return Adapters[0].opengl;
3888
3889     TRACE("Initializing adapters\n");
3890
3891     if(!mod_gl) {
3892 #ifdef USE_WIN32_OPENGL
3893 #define USE_GL_FUNC(pfn) pfn = (void*)GetProcAddress(mod_gl, #pfn);
3894         mod_gl = LoadLibraryA("opengl32.dll");
3895         if(!mod_gl) {
3896             ERR("Can't load opengl32.dll!\n");
3897             goto nogl_adapter;
3898         }
3899 #else
3900 #define USE_GL_FUNC(pfn) pfn = (void*)pwglGetProcAddress(#pfn);
3901         /* To bypass the opengl32 thunks load wglGetProcAddress from gdi32 (glXGetProcAddress wrapper) instead of opengl32's */
3902         mod_gl = GetModuleHandleA("gdi32.dll");
3903 #endif
3904     }
3905
3906 /* Load WGL core functions from opengl32.dll */
3907 #define USE_WGL_FUNC(pfn) p##pfn = (void*)GetProcAddress(mod_gl, #pfn);
3908     WGL_FUNCS_GEN;
3909 #undef USE_WGL_FUNC
3910
3911     if(!pwglGetProcAddress) {
3912         ERR("Unable to load wglGetProcAddress!\n");
3913         goto nogl_adapter;
3914     }
3915
3916 /* Dynamically load all GL core functions */
3917     GL_FUNCS_GEN;
3918 #undef USE_GL_FUNC
3919
3920     /* For now only one default adapter */
3921     {
3922         int iPixelFormat;
3923         int attribs[10];
3924         int values[10];
3925         int nAttribs = 0;
3926         int res;
3927         int i;
3928         WineD3D_PixelFormat *cfgs;
3929         int attribute;
3930         DISPLAY_DEVICEW DisplayDevice;
3931         HDC hdc;
3932
3933         TRACE("Initializing default adapter\n");
3934         Adapters[0].num = 0;
3935         Adapters[0].monitorPoint.x = -1;
3936         Adapters[0].monitorPoint.y = -1;
3937
3938         if (!WineD3D_CreateFakeGLContext()) {
3939             ERR("Failed to get a gl context for default adapter\n");
3940             WineD3D_ReleaseFakeGLContext();
3941             goto nogl_adapter;
3942         }
3943
3944         ret = IWineD3DImpl_FillGLCaps(&Adapters[0].gl_info);
3945         if(!ret) {
3946             ERR("Failed to initialize gl caps for default adapter\n");
3947             WineD3D_ReleaseFakeGLContext();
3948             goto nogl_adapter;
3949         }
3950         ret = initPixelFormats(&Adapters[0].gl_info);
3951         if(!ret) {
3952             ERR("Failed to init gl formats\n");
3953             WineD3D_ReleaseFakeGLContext();
3954             goto nogl_adapter;
3955         }
3956
3957         hdc = pwglGetCurrentDC();
3958         if(!hdc) {
3959             ERR("Failed to get gl HDC\n");
3960             WineD3D_ReleaseFakeGLContext();
3961             goto nogl_adapter;
3962         }
3963
3964         Adapters[0].driver = "Display";
3965         Adapters[0].description = "Direct3D HAL";
3966
3967         /* Use the VideoRamSize registry setting when set */
3968         if(wined3d_settings.emulated_textureram)
3969             Adapters[0].TextureRam = wined3d_settings.emulated_textureram;
3970         else
3971             Adapters[0].TextureRam = Adapters[0].gl_info.vidmem;
3972         Adapters[0].UsedTextureRam = 0;
3973         TRACE("Emulating %dMB of texture ram\n", Adapters[0].TextureRam/(1024*1024));
3974
3975         /* Initialize the Adapter's DeviceName which is required for ChangeDisplaySettings and friends */
3976         DisplayDevice.cb = sizeof(DisplayDevice);
3977         EnumDisplayDevicesW(NULL, 0 /* Adapter 0 = iDevNum 0 */, &DisplayDevice, 0);
3978         TRACE("DeviceName: %s\n", debugstr_w(DisplayDevice.DeviceName));
3979         strcpyW(Adapters[0].DeviceName, DisplayDevice.DeviceName);
3980
3981         attribute = WGL_NUMBER_PIXEL_FORMATS_ARB;
3982         GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc, 0, 0, 1, &attribute, &Adapters[0].nCfgs));
3983
3984         Adapters[0].cfgs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, Adapters[0].nCfgs *sizeof(WineD3D_PixelFormat));
3985         cfgs = Adapters[0].cfgs;
3986         PUSH1(WGL_RED_BITS_ARB)
3987         PUSH1(WGL_GREEN_BITS_ARB)
3988         PUSH1(WGL_BLUE_BITS_ARB)
3989         PUSH1(WGL_ALPHA_BITS_ARB)
3990         PUSH1(WGL_DEPTH_BITS_ARB)
3991         PUSH1(WGL_STENCIL_BITS_ARB)
3992         PUSH1(WGL_DRAW_TO_WINDOW_ARB)
3993         PUSH1(WGL_PIXEL_TYPE_ARB)
3994         PUSH1(WGL_DOUBLE_BUFFER_ARB)
3995         PUSH1(WGL_AUX_BUFFERS_ARB)
3996
3997         for(iPixelFormat=1; iPixelFormat<=Adapters[0].nCfgs; iPixelFormat++) {
3998             res = GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc, iPixelFormat, 0, nAttribs, attribs, values));
3999
4000             if(!res)
4001                 continue;
4002
4003             /* Cache the pixel format */
4004             cfgs->iPixelFormat = iPixelFormat;
4005             cfgs->redSize = values[0];
4006             cfgs->greenSize = values[1];
4007             cfgs->blueSize = values[2];
4008             cfgs->alphaSize = values[3];
4009             cfgs->depthSize = values[4];
4010             cfgs->stencilSize = values[5];
4011             cfgs->windowDrawable = values[6];
4012             cfgs->iPixelType = values[7];
4013             cfgs->doubleBuffer = values[8];
4014             cfgs->auxBuffers = values[9];
4015
4016             cfgs->pbufferDrawable = FALSE;
4017             /* Check for pbuffer support when it is around as wglGetPixelFormatAttribiv fails for unknown attributes. */
4018             if(GL_SUPPORT(WGL_ARB_PBUFFER)) {
4019                 int attrib = WGL_DRAW_TO_PBUFFER_ARB;
4020                 int value;
4021                 if(GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc, iPixelFormat, 0, 1, &attrib, &value)))
4022                     cfgs->pbufferDrawable = value;
4023             }
4024
4025             cfgs->numSamples = 0;
4026             /* Check multisample support */
4027             if(GL_SUPPORT(ARB_MULTISAMPLE)) {
4028                 int attrib[2] = {WGL_SAMPLE_BUFFERS_ARB, WGL_SAMPLES_ARB};
4029                 int value[2];
4030                 if(GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc, iPixelFormat, 0, 2, attrib, value))) {
4031                     /* value[0] = WGL_SAMPLE_BUFFERS_ARB which tells whether multisampling is supported.
4032                      * value[1] = number of multi sample buffers*/
4033                     if(value[0])
4034                         cfgs->numSamples = value[1];
4035                 }
4036             }
4037
4038             TRACE("iPixelFormat=%d, iPixelType=%#x, doubleBuffer=%d, RGBA=%d/%d/%d/%d, depth=%d, stencil=%d, windowDrawable=%d, pbufferDrawable=%d\n", cfgs->iPixelFormat, cfgs->iPixelType, cfgs->doubleBuffer, cfgs->redSize, cfgs->greenSize, cfgs->blueSize, cfgs->alphaSize, cfgs->depthSize, cfgs->stencilSize, cfgs->windowDrawable, cfgs->pbufferDrawable);
4039             cfgs++;
4040         }
4041
4042         /* D16, D24X8 and D24S8 are common depth / depth+stencil formats. All drivers support them though this doesn't
4043          * mean that the format is offered in hardware. For instance Geforce8 cards don't have offer D16 in hardware
4044          * but just fake it using D24(X8?) which is fine. D3D also allows that.
4045          * Some display drivers (i915 on Linux) only report mixed depth+stencil formats like D24S8. MSDN clearly mentions
4046          * that only on lockable formats (e.g. D16_locked) the bit order is guaranteed and that on other formats the
4047          * driver is allowed to consume more bits EXCEPT for stencil bits.
4048          *
4049          * Mark an adapter with this broken stencil behavior.
4050          */
4051         Adapters[0].brokenStencil = TRUE;
4052         for(i=0, cfgs=Adapters[0].cfgs; i<Adapters[0].nCfgs; i++) {
4053             /* Nearly all drivers offer depth formats without stencil, only on i915 this if-statement won't be entered. */
4054             if(cfgs[i].depthSize && !cfgs[i].stencilSize) {
4055                 Adapters[0].brokenStencil = FALSE;
4056                 break;
4057             }
4058         }
4059
4060         fixup_extensions(&Adapters[0].gl_info);
4061
4062         WineD3D_ReleaseFakeGLContext();
4063
4064         select_shader_mode(&Adapters[0].gl_info, WINED3DDEVTYPE_HAL, &ps_selected_mode, &vs_selected_mode);
4065         select_shader_max_constants(ps_selected_mode, vs_selected_mode, &Adapters[0].gl_info);
4066         fillGLAttribFuncs(&Adapters[0].gl_info);
4067         init_type_lookup(&Adapters[0].gl_info);
4068         Adapters[0].opengl = TRUE;
4069     }
4070     numAdapters = 1;
4071     TRACE("%d adapters successfully initialized\n", numAdapters);
4072
4073     return TRUE;
4074
4075 nogl_adapter:
4076     /* Initialize an adapter for ddraw-only memory counting */
4077     memset(Adapters, 0, sizeof(Adapters));
4078     Adapters[0].num = 0;
4079     Adapters[0].opengl = FALSE;
4080     Adapters[0].monitorPoint.x = -1;
4081     Adapters[0].monitorPoint.y = -1;
4082
4083     Adapters[0].driver = "Display";
4084     Adapters[0].description = "WineD3D DirectDraw Emulation";
4085     if(wined3d_settings.emulated_textureram) {
4086         Adapters[0].TextureRam = wined3d_settings.emulated_textureram;
4087     } else {
4088         Adapters[0].TextureRam = 8 * 1024 * 1024; /* This is plenty for a DDraw-only card */
4089     }
4090
4091     numAdapters = 1;
4092     return FALSE;
4093 }
4094 #undef PUSH1
4095 #undef GLINFO_LOCATION
4096
4097 /**********************************************************
4098  * IWineD3D VTbl follows
4099  **********************************************************/
4100
4101 const IWineD3DVtbl IWineD3D_Vtbl =
4102 {
4103     /* IUnknown */
4104     IWineD3DImpl_QueryInterface,
4105     IWineD3DImpl_AddRef,
4106     IWineD3DImpl_Release,
4107     /* IWineD3D */
4108     IWineD3DImpl_GetParent,
4109     IWineD3DImpl_GetAdapterCount,
4110     IWineD3DImpl_RegisterSoftwareDevice,
4111     IWineD3DImpl_GetAdapterMonitor,
4112     IWineD3DImpl_GetAdapterModeCount,
4113     IWineD3DImpl_EnumAdapterModes,
4114     IWineD3DImpl_GetAdapterDisplayMode,
4115     IWineD3DImpl_GetAdapterIdentifier,
4116     IWineD3DImpl_CheckDeviceMultiSampleType,
4117     IWineD3DImpl_CheckDepthStencilMatch,
4118     IWineD3DImpl_CheckDeviceType,
4119     IWineD3DImpl_CheckDeviceFormat,
4120     IWineD3DImpl_CheckDeviceFormatConversion,
4121     IWineD3DImpl_GetDeviceCaps,
4122     IWineD3DImpl_CreateDevice
4123 };