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  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 /* Compile time diagnostics: */
  25
  26 #ifndef DEBUG_SINGLE_MODE
  27 /* Set to 1 to force only a single display mode to be exposed: */
  28 #define DEBUG_SINGLE_MODE 0
  29 #endif
  30
  31
  32 #include "config.h"
  33 #include <assert.h>
  34 #include "wined3d_private.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
  37 WINE_DECLARE_DEBUG_CHANNEL(d3d_caps);
  38
  39 /* Extension detection */
  40 static const struct {
  41     const char *extension_string;
  42     GL_SupportedExt extension;
  43 } EXTENSION_MAP[] = {
  44     /* APPLE */
  45     {"GL_APPLE_client_storage",             APPLE_CLIENT_STORAGE},
  46     {"GL_APPLE_fence",                      APPLE_FENCE},
  47
  48     /* ATI */
  49     {"GL_ATI_separate_stencil",             ATI_SEPARATE_STENCIL},
  50     {"GL_ATI_texture_env_combine3",         ATI_TEXTURE_ENV_COMBINE3},
  51     {"GL_ATI_texture_mirror_once",          ATI_TEXTURE_MIRROR_ONCE},
  52     {"GL_ATI_envmap_bumpmap",               ATI_ENVMAP_BUMPMAP},
  53
  54     /* ARB */
  55     {"GL_ARB_draw_buffers",                 ARB_DRAW_BUFFERS},
  56     {"GL_ARB_fragment_program",             ARB_FRAGMENT_PROGRAM},
  57     {"GL_ARB_fragment_shader",              ARB_FRAGMENT_SHADER},
  58     {"GL_ARB_half_float_pixel",             ARB_HALF_FLOAT_PIXEL},
  59     {"GL_ARB_imaging",                      ARB_IMAGING},
  60     {"GL_ARB_multisample",                  ARB_MULTISAMPLE}, /* needs GLX_ARB_MULTISAMPLE as well */
  61     {"GL_ARB_multitexture",                 ARB_MULTITEXTURE},
  62     {"GL_ARB_occlusion_query",              ARB_OCCLUSION_QUERY},
  63     {"GL_ARB_pixel_buffer_object",          ARB_PIXEL_BUFFER_OBJECT},
  64     {"GL_ARB_point_parameters",             ARB_POINT_PARAMETERS},
  65     {"GL_ARB_point_sprite",                 ARB_POINT_SPRITE},
  66     {"GL_ARB_texture_border_clamp",         ARB_TEXTURE_BORDER_CLAMP},
  67     {"GL_ARB_texture_compression",          ARB_TEXTURE_COMPRESSION},
  68     {"GL_ARB_texture_cube_map",             ARB_TEXTURE_CUBE_MAP},
  69     {"GL_ARB_texture_env_add",              ARB_TEXTURE_ENV_ADD},
  70     {"GL_ARB_texture_env_combine",          ARB_TEXTURE_ENV_COMBINE},
  71     {"GL_ARB_texture_env_dot3",             ARB_TEXTURE_ENV_DOT3},
  72     {"GL_ARB_texture_float",                ARB_TEXTURE_FLOAT},
  73     {"GL_ARB_texture_mirrored_repeat",      ARB_TEXTURE_MIRRORED_REPEAT},
  74     {"GL_ARB_texture_non_power_of_two",     ARB_TEXTURE_NON_POWER_OF_TWO},
  75     {"GL_ARB_vertex_blend",                 ARB_VERTEX_BLEND},
  76     {"GL_ARB_vertex_buffer_object",         ARB_VERTEX_BUFFER_OBJECT},
  77     {"GL_ARB_vertex_program",               ARB_VERTEX_PROGRAM},
  78     {"GL_ARB_vertex_shader",                ARB_VERTEX_SHADER},
  79
  80     /* EXT */
  81     {"GL_EXT_blend_minmax",                 EXT_BLEND_MINMAX},
  82     {"GL_EXT_fog_coord",                    EXT_FOG_COORD},
  83     {"GL_EXT_framebuffer_blit",             EXT_FRAMEBUFFER_BLIT},
  84     {"GL_EXT_framebuffer_object",           EXT_FRAMEBUFFER_OBJECT},
  85     {"GL_EXT_paletted_texture",             EXT_PALETTED_TEXTURE},
  86     {"GL_EXT_point_parameters",             EXT_POINT_PARAMETERS},
  87     {"GL_EXT_secondary_color",              EXT_SECONDARY_COLOR},
  88     {"GL_EXT_stencil_two_side",             EXT_STENCIL_TWO_SIDE},
  89     {"GL_EXT_stencil_wrap",                 EXT_STENCIL_WRAP},
  90     {"GL_EXT_texture3D",                    EXT_TEXTURE3D},
  91     {"GL_EXT_texture_compression_s3tc",     EXT_TEXTURE_COMPRESSION_S3TC},
  92     {"GL_EXT_texture_env_add",              EXT_TEXTURE_ENV_ADD},
  93     {"GL_EXT_texture_env_combine",          EXT_TEXTURE_ENV_COMBINE},
  94     {"GL_EXT_texture_env_dot3",             EXT_TEXTURE_ENV_DOT3},
  95     {"GL_EXT_texture_sRGB",                 EXT_TEXTURE_SRGB},
  96     {"GL_EXT_texture_filter_anisotropic",   EXT_TEXTURE_FILTER_ANISOTROPIC},
  97     {"GL_EXT_texture_lod",                  EXT_TEXTURE_LOD},
  98     {"GL_EXT_texture_lod_bias",             EXT_TEXTURE_LOD_BIAS},
  99     {"GL_EXT_vertex_shader",                EXT_VERTEX_SHADER},
 100     {"GL_EXT_vertex_weighting",             EXT_VERTEX_WEIGHTING},
 101
 102     /* NV */
 103     {"GL_NV_half_float",                    NV_HALF_FLOAT},
 104     {"GL_NV_fence",                         NV_FENCE},
 105     {"GL_NV_fog_distance",                  NV_FOG_DISTANCE},
 106     {"GL_NV_fragment_program",              NV_FRAGMENT_PROGRAM},
 107     {"GL_NV_fragment_program2",             NV_FRAGMENT_PROGRAM2},
 108     {"GL_NV_register_combiners",            NV_REGISTER_COMBINERS},
 109     {"GL_NV_register_combiners2",           NV_REGISTER_COMBINERS2},
 110     {"GL_NV_texgen_reflection",             NV_TEXGEN_REFLECTION},
 111     {"GL_NV_texture_env_combine4",          NV_TEXTURE_ENV_COMBINE4},
 112     {"GL_NV_texture_shader",                NV_TEXTURE_SHADER},
 113     {"GL_NV_texture_shader2",               NV_TEXTURE_SHADER2},
 114     {"GL_NV_texture_shader3",               NV_TEXTURE_SHADER3},
 115     {"GL_NV_occlusion_query",               NV_OCCLUSION_QUERY},
 116     {"GL_NV_vertex_program",                NV_VERTEX_PROGRAM},
 117     {"GL_NV_vertex_program1_1",             NV_VERTEX_PROGRAM1_1},
 118     {"GL_NV_vertex_program2",               NV_VERTEX_PROGRAM2},
 119     {"GL_NV_vertex_program3",               NV_VERTEX_PROGRAM3},
 120     {"GL_NV_depth_clamp",                   NV_DEPTH_CLAMP},
 121
 122     /* SGI */
 123     {"GL_SGIS_generate_mipmap",             SGIS_GENERATE_MIPMAP},
 124 };
 125
 126 /**********************************************************
 127  * Utility functions follow
 128  **********************************************************/
 129
 130 /* Adapters */
 131 static int numAdapters = 0;
 132 static struct WineD3DAdapter Adapters[1];
 133
 134 /* lookup tables */
 135 int minLookup[MAX_LOOKUPS];
 136 int maxLookup[MAX_LOOKUPS];
 137 DWORD *stateLookup[MAX_LOOKUPS];
 138
 139 DWORD minMipLookup[WINED3DTEXF_ANISOTROPIC + 1][WINED3DTEXF_LINEAR + 1];
 140
 141
 142 /**
 143  * Note: GL seems to trap if GetDeviceCaps is called before any HWND's created
 144  * ie there is no GL Context - Get a default rendering context to enable the
 145  * function query some info from GL
 146  */
 147
 148 static int             wined3d_fake_gl_context_ref = 0;
 149 static BOOL            wined3d_fake_gl_context_foreign;
 150 static BOOL            wined3d_fake_gl_context_available = FALSE;
 151 static HDC             wined3d_fake_gl_context_hdc = NULL;
 152 static HWND            wined3d_fake_gl_context_hwnd = NULL;
 153
 154 static CRITICAL_SECTION wined3d_fake_gl_context_cs;
 155 static CRITICAL_SECTION_DEBUG wined3d_fake_gl_context_cs_debug =
 156 {
 157     0, 0, &wined3d_fake_gl_context_cs,
 158     { &wined3d_fake_gl_context_cs_debug.ProcessLocksList,
 159       &wined3d_fake_gl_context_cs_debug.ProcessLocksList },
 160     0, 0, { (DWORD_PTR)(__FILE__ ": wined3d_fake_gl_context_cs") }
 161 };
 162 static CRITICAL_SECTION wined3d_fake_gl_context_cs = { &wined3d_fake_gl_context_cs_debug, -1, 0, 0, 0, 0 };
 163
 164 static void WineD3D_ReleaseFakeGLContext(void) {
 165     HGLRC glCtx;
 166
 167     EnterCriticalSection(&wined3d_fake_gl_context_cs);
 168
 169     if(!wined3d_fake_gl_context_available) {
 170         TRACE_(d3d_caps)("context not available\n");
 171         LeaveCriticalSection(&wined3d_fake_gl_context_cs);
 172         return;
 173     }
 174
 175     glCtx = pwglGetCurrentContext();
 176
 177     TRACE_(d3d_caps)("decrementing ref from %i\n", wined3d_fake_gl_context_ref);
 178     if (0 == (--wined3d_fake_gl_context_ref) ) {
 179         if(!wined3d_fake_gl_context_foreign && glCtx) {
 180             TRACE_(d3d_caps)("destroying fake GL context\n");
 181             pwglMakeCurrent(NULL, NULL);
 182             pwglDeleteContext(glCtx);
 183         }
 184         if(wined3d_fake_gl_context_hdc)
 185             ReleaseDC(wined3d_fake_gl_context_hwnd, wined3d_fake_gl_context_hdc);
 186         wined3d_fake_gl_context_hdc = NULL; /* Make sure we don't think that it is still around */
 187         if(wined3d_fake_gl_context_hwnd)
 188             DestroyWindow(wined3d_fake_gl_context_hwnd);
 189         wined3d_fake_gl_context_hwnd = NULL;
 190         wined3d_fake_gl_context_available = FALSE;
 191     }
 192     assert(wined3d_fake_gl_context_ref >= 0);
 193
 194     LeaveCriticalSection(&wined3d_fake_gl_context_cs);
 195 }
 196
 197 static BOOL WineD3D_CreateFakeGLContext(void) {
 198     HGLRC glCtx = NULL;
 199
 200     EnterCriticalSection(&wined3d_fake_gl_context_cs);
 201
 202     TRACE("getting context...\n");
 203     if(wined3d_fake_gl_context_ref > 0) goto ret;
 204     assert(0 == wined3d_fake_gl_context_ref);
 205
 206     wined3d_fake_gl_context_foreign = TRUE;
 207
 208     glCtx = pwglGetCurrentContext();
 209     if (!glCtx) {
 210         PIXELFORMATDESCRIPTOR pfd;
 211         int iPixelFormat;
 212
 213         wined3d_fake_gl_context_foreign = FALSE;
 214
 215         /* We need a fake window as a hdc retrieved using GetDC(0) can't be used for much GL purposes */
 216         wined3d_fake_gl_context_hwnd = CreateWindowA("WineD3D_OpenGL", "WineD3D fake window", WS_OVERLAPPEDWINDOW,        10, 10, 10, 10, NULL, NULL, NULL, NULL);
 217         if(!wined3d_fake_gl_context_hwnd) {
 218             ERR("HWND creation failed!\n");
 219             goto fail;
 220         }
 221         wined3d_fake_gl_context_hdc = GetDC(wined3d_fake_gl_context_hwnd);
 222         if(!wined3d_fake_gl_context_hdc) {
 223             ERR("GetDC failed!\n");
 224             goto fail;
 225         }
 226
 227         /* PixelFormat selection */
 228         ZeroMemory(&pfd, sizeof(pfd));
 229         pfd.nSize      = sizeof(pfd);
 230         pfd.nVersion   = 1;
 231         pfd.dwFlags    = PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER | PFD_DRAW_TO_WINDOW;/*PFD_GENERIC_ACCELERATED*/
 232         pfd.iPixelType = PFD_TYPE_RGBA;
 233         pfd.cColorBits = 32;
 234         pfd.iLayerType = PFD_MAIN_PLANE;
 235
 236         iPixelFormat = ChoosePixelFormat(wined3d_fake_gl_context_hdc, &pfd);
 237         if(!iPixelFormat) {
 238             /* If this happens something is very wrong as ChoosePixelFormat barely fails */
 239             ERR("Can't find a suitable iPixelFormat\n");
 240             goto fail;
 241         }
 242         DescribePixelFormat(wined3d_fake_gl_context_hdc, iPixelFormat, sizeof(pfd), &pfd);
 243         SetPixelFormat(wined3d_fake_gl_context_hdc, iPixelFormat, &pfd);
 244
 245         /* Create a GL context */
 246         glCtx = pwglCreateContext(wined3d_fake_gl_context_hdc);
 247         if (!glCtx) {
 248             WARN_(d3d_caps)("Error creating default context for capabilities initialization\n");
 249             goto fail;
 250         }
 251
 252         /* Make it the current GL context */
 253         if (!pwglMakeCurrent(wined3d_fake_gl_context_hdc, glCtx)) {
 254             WARN_(d3d_caps)("Error setting default context as current for capabilities initialization\n");
 255             goto fail;
 256         }
 257     }
 258
 259   ret:
 260     TRACE("incrementing ref from %i\n", wined3d_fake_gl_context_ref);
 261     wined3d_fake_gl_context_ref++;
 262     wined3d_fake_gl_context_available = TRUE;
 263     LeaveCriticalSection(&wined3d_fake_gl_context_cs);
 264     return TRUE;
 265   fail:
 266     if(wined3d_fake_gl_context_hdc)
 267         ReleaseDC(wined3d_fake_gl_context_hwnd, wined3d_fake_gl_context_hdc);
 268     wined3d_fake_gl_context_hdc = NULL;
 269     if(wined3d_fake_gl_context_hwnd)
 270         DestroyWindow(wined3d_fake_gl_context_hwnd);
 271     wined3d_fake_gl_context_hwnd = NULL;
 272     if(glCtx) pwglDeleteContext(glCtx);
 273     LeaveCriticalSection(&wined3d_fake_gl_context_cs);
 274     return FALSE;
 275 }
 276
 277 /* Adjust the amount of used texture memory */
 278 long WineD3DAdapterChangeGLRam(IWineD3DDeviceImpl *D3DDevice, long glram){
 279     UINT Adapter = D3DDevice->adapterNo;
 280
 281     Adapters[Adapter].UsedTextureRam += glram;
 282     TRACE("Adjusted gl ram by %ld to %d\n", glram, Adapters[Adapter].UsedTextureRam);
 283     return Adapters[Adapter].UsedTextureRam;
 284 }
 285
 286 /**********************************************************
 287  * IUnknown parts follows
 288  **********************************************************/
 289
 290 static HRESULT WINAPI IWineD3DImpl_QueryInterface(IWineD3D *iface,REFIID riid,LPVOID *ppobj)
 291 {
 292     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
 293
 294     TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppobj);
 295     if (IsEqualGUID(riid, &IID_IUnknown)
 296         || IsEqualGUID(riid, &IID_IWineD3DBase)
 297         || IsEqualGUID(riid, &IID_IWineD3DDevice)) {
 298         IUnknown_AddRef(iface);
 299         *ppobj = This;
 300         return S_OK;
 301     }
 302     *ppobj = NULL;
 303     return E_NOINTERFACE;
 304 }
 305
 306 static ULONG WINAPI IWineD3DImpl_AddRef(IWineD3D *iface) {
 307     IWineD3DImpl *This = (IWineD3DImpl *)iface;
 308     ULONG refCount = InterlockedIncrement(&This->ref);
 309
 310     TRACE("(%p) : AddRef increasing from %d\n", This, refCount - 1);
 311     return refCount;
 312 }
 313
 314 static ULONG WINAPI IWineD3DImpl_Release(IWineD3D *iface) {
 315     IWineD3DImpl *This = (IWineD3DImpl *)iface;
 316     ULONG ref;
 317     TRACE("(%p) : Releasing from %d\n", This, This->ref);
 318     ref = InterlockedDecrement(&This->ref);
 319     if (ref == 0) {
 320         HeapFree(GetProcessHeap(), 0, This);
 321     }
 322
 323     return ref;
 324 }
 325
 326 /* Set the shader type for this device, depending on the given capabilities,
 327  * the device type, and the user preferences in wined3d_settings */
 328
 329 static void select_shader_mode(
 330     WineD3D_GL_Info *gl_info,
 331     WINED3DDEVTYPE DeviceType,
 332     int* ps_selected,
 333     int* vs_selected) {
 334
 335     if (wined3d_settings.vs_mode == VS_NONE) {
 336         *vs_selected = SHADER_NONE;
 337     } else if (gl_info->supported[ARB_VERTEX_SHADER] && wined3d_settings.glslRequested) {
 338         *vs_selected = SHADER_GLSL;
 339     } else if (gl_info->supported[ARB_VERTEX_PROGRAM]) {
 340         *vs_selected = SHADER_ARB;
 341     } else {
 342         *vs_selected = SHADER_NONE;
 343     }
 344
 345     if (wined3d_settings.ps_mode == PS_NONE) {
 346         *ps_selected = SHADER_NONE;
 347     } else if (gl_info->supported[ARB_FRAGMENT_SHADER] && wined3d_settings.glslRequested) {
 348         *ps_selected = SHADER_GLSL;
 349     } else if (gl_info->supported[ARB_FRAGMENT_PROGRAM]) {
 350         *ps_selected = SHADER_ARB;
 351     } else {
 352         *ps_selected = SHADER_NONE;
 353     }
 354 }
 355
 356 /** Select the number of report maximum shader constants based on the selected shader modes */
 357 static void select_shader_max_constants(
 358     int ps_selected_mode,
 359     int vs_selected_mode,
 360     WineD3D_GL_Info *gl_info) {
 361
 362     switch (vs_selected_mode) {
 363         case SHADER_GLSL:
 364             /* Subtract the other potential uniforms from the max available (bools, ints, and 1 row of projection matrix) */
 365             gl_info->max_vshader_constantsF = gl_info->vs_glsl_constantsF - (MAX_CONST_B / 4) - MAX_CONST_I - 1;
 366             break;
 367         case SHADER_ARB:
 368             /* We have to subtract any other PARAMs that we might use in our shader programs.
 369              * ATI seems to count 2 implicit PARAMs when we use fog and NVIDIA counts 1,
 370              * and we reference one row of the PROJECTION matrix which counts as 1 PARAM. */
 371             gl_info->max_vshader_constantsF = gl_info->vs_arb_constantsF - 3;
 372             break;
 373         default:
 374             gl_info->max_vshader_constantsF = 0;
 375             break;
 376     }
 377
 378     switch (ps_selected_mode) {
 379         case SHADER_GLSL:
 380             /* Subtract the other potential uniforms from the max available (bools & ints), and 2 states for fog.
 381              * In theory the texbem instruction may need one more shader constant too. But lets assume
 382              * that a sm <= 1.3 shader does not need all the uniforms provided by a glsl-capable card,
 383              * and lets not take away a uniform needlessly from all other shaders.
 384              */
 385             gl_info->max_pshader_constantsF = gl_info->ps_glsl_constantsF - (MAX_CONST_B / 4) - MAX_CONST_I - 2;
 386             break;
 387         case SHADER_ARB:
 388             /* The arb shader only loads the bump mapping environment matrix into the shader if it finds
 389              * a free constant to do that, so only reduce the number of available constants by 2 for the fog states.
 390              */
 391             gl_info->max_pshader_constantsF = gl_info->ps_arb_constantsF - 2;
 392             break;
 393         default:
 394             gl_info->max_pshader_constantsF = 0;
 395             break;
 396     }
 397 }
 398
 399 /**********************************************************
 400  * IWineD3D parts follows
 401  **********************************************************/
 402
 403 #define GLINFO_LOCATION (*gl_info)
 404 BOOL IWineD3DImpl_FillGLCaps(WineD3D_GL_Info *gl_info) {
 405     const char *GL_Extensions    = NULL;
 406     const char *WGL_Extensions   = NULL;
 407     const char *gl_string        = NULL;
 408     const char *gl_string_cursor = NULL;
 409     GLint       gl_max;
 410     GLfloat     gl_floatv[2];
 411     int         major = 1, minor = 0;
 412     BOOL        return_value = TRUE;
 413     int         i;
 414     HDC         hdc;
 415     unsigned int vidmem=0;
 416
 417     TRACE_(d3d_caps)("(%p)\n", gl_info);
 418
 419     ENTER_GL();
 420
 421     gl_string = (const char *) glGetString(GL_RENDERER);
 422     if (NULL == gl_string)
 423         gl_string = "None";
 424     strcpy(gl_info->gl_renderer, gl_string);
 425
 426     gl_string = (const char *) glGetString(GL_VENDOR);
 427     TRACE_(d3d_caps)("Filling vendor string %s\n", gl_string);
 428     if (gl_string != NULL) {
 429         /* Fill in the GL vendor */
 430         if (strstr(gl_string, "NVIDIA")) {
 431             gl_info->gl_vendor = VENDOR_NVIDIA;
 432         } else if (strstr(gl_string, "ATI")) {
 433             gl_info->gl_vendor = VENDOR_ATI;
 434         } else if (strstr(gl_string, "Intel(R)") ||
 435                    strstr(gl_info->gl_renderer, "Intel(R)")) {
 436             gl_info->gl_vendor = VENDOR_INTEL;
 437         } else if (strstr(gl_string, "Mesa")) {
 438             gl_info->gl_vendor = VENDOR_MESA;
 439         } else {
 440             gl_info->gl_vendor = VENDOR_WINE;
 441         }
 442     } else {
 443         gl_info->gl_vendor = VENDOR_WINE;
 444     }
 445
 446
 447     TRACE_(d3d_caps)("found GL_VENDOR (%s)->(0x%04x)\n", debugstr_a(gl_string), gl_info->gl_vendor);
 448
 449     /* Parse the GL_VERSION field into major and minor information */
 450     gl_string = (const char *) glGetString(GL_VERSION);
 451     if (gl_string != NULL) {
 452
 453         switch (gl_info->gl_vendor) {
 454         case VENDOR_NVIDIA:
 455             gl_string_cursor = strstr(gl_string, "NVIDIA");
 456             if (!gl_string_cursor) {
 457                 ERR_(d3d_caps)("Invalid nVidia version string: %s\n", debugstr_a(gl_string));
 458                 break;
 459             }
 460
 461             gl_string_cursor = strstr(gl_string_cursor, " ");
 462             if (!gl_string_cursor) {
 463                 ERR_(d3d_caps)("Invalid nVidia version string: %s\n", debugstr_a(gl_string));
 464                 break;
 465             }
 466
 467             while (*gl_string_cursor == ' ') {
 468                 ++gl_string_cursor;
 469             }
 470
 471             if (!*gl_string_cursor) {
 472                 ERR_(d3d_caps)("Invalid nVidia version string: %s\n", debugstr_a(gl_string));
 473                 break;
 474             }
 475
 476             major = atoi(gl_string_cursor);
 477             while (*gl_string_cursor <= '9' && *gl_string_cursor >= '0') {
 478                 ++gl_string_cursor;
 479             }
 480
 481             if (*gl_string_cursor++ != '.') {
 482                 ERR_(d3d_caps)("Invalid nVidia version string: %s\n", debugstr_a(gl_string));
 483                 break;
 484             }
 485
 486             minor = atoi(gl_string_cursor);
 487             minor = major*100+minor;
 488             major = 10;
 489
 490             break;
 491
 492         case VENDOR_ATI:
 493             major = minor = 0;
 494             gl_string_cursor = strchr(gl_string, '-');
 495             if (gl_string_cursor) {
 496                 int error = 0;
 497                 gl_string_cursor++;
 498
 499                 /* Check if version number is of the form x.y.z */
 500                 if (*gl_string_cursor > '9' && *gl_string_cursor < '0')
 501                     error = 1;
 502                 if (!error && *(gl_string_cursor+2) > '9' && *(gl_string_cursor+2) < '0')
 503                     error = 1;
 504                 if (!error && *(gl_string_cursor+4) > '9' && *(gl_string_cursor+4) < '0')
 505                     error = 1;
 506                 if (!error && *(gl_string_cursor+1) != '.' && *(gl_string_cursor+3) != '.')
 507                     error = 1;
 508
 509                 /* Mark version number as malformed */
 510                 if (error)
 511                     gl_string_cursor = 0;
 512             }
 513
 514             if (!gl_string_cursor)
 515                 WARN_(d3d_caps)("malformed GL_VERSION (%s)\n", debugstr_a(gl_string));
 516             else {
 517                 major = *gl_string_cursor - '0';
 518                 minor = (*(gl_string_cursor+2) - '0') * 256 + (*(gl_string_cursor+4) - '0');
 519             }
 520             break;
 521
 522         case VENDOR_INTEL:
 523         case VENDOR_MESA:
 524             gl_string_cursor = strstr(gl_string, "Mesa");
 525             gl_string_cursor = strstr(gl_string_cursor, " ");
 526             while (*gl_string_cursor && ' ' == *gl_string_cursor) ++gl_string_cursor;
 527             if (*gl_string_cursor) {
 528                 char tmp[16];
 529                 int cursor = 0;
 530
 531                 while (*gl_string_cursor <= '9' && *gl_string_cursor >= '0') {
 532                     tmp[cursor++] = *gl_string_cursor;
 533                     ++gl_string_cursor;
 534                 }
 535                 tmp[cursor] = 0;
 536                 major = atoi(tmp);
 537
 538                 if (*gl_string_cursor != '.') WARN_(d3d_caps)("malformed GL_VERSION (%s)\n", debugstr_a(gl_string));
 539                 ++gl_string_cursor;
 540
 541                 cursor = 0;
 542                 while (*gl_string_cursor <= '9' && *gl_string_cursor >= '0') {
 543                     tmp[cursor++] = *gl_string_cursor;
 544                     ++gl_string_cursor;
 545                 }
 546                 tmp[cursor] = 0;
 547                 minor = atoi(tmp);
 548             }
 549             break;
 550
 551         default:
 552             major = 0;
 553             minor = 9;
 554         }
 555         gl_info->gl_driver_version = MAKEDWORD_VERSION(major, minor);
 556         TRACE_(d3d_caps)("found GL_VERSION  (%s)->%i.%i->(0x%08x)\n", debugstr_a(gl_string), major, minor, gl_info->gl_driver_version);
 557     }
 558
 559     TRACE_(d3d_caps)("found GL_RENDERER (%s)->(0x%04x)\n", debugstr_a(gl_info->gl_renderer), gl_info->gl_card);
 560
 561     /*
 562      * Initialize openGL extension related variables
 563      *  with Default values
 564      */
 565     memset(&gl_info->supported, 0, sizeof(gl_info->supported));
 566     gl_info->max_buffers        = 1;
 567     gl_info->max_textures       = 1;
 568     gl_info->max_texture_stages = 1;
 569     gl_info->max_fragment_samplers = 1;
 570     gl_info->max_vertex_samplers = 0;
 571     gl_info->max_combined_samplers = 0;
 572     gl_info->max_sampler_stages = 1;
 573     gl_info->ps_arb_version = PS_VERSION_NOT_SUPPORTED;
 574     gl_info->ps_arb_max_temps = 0;
 575     gl_info->ps_arb_max_instructions = 0;
 576     gl_info->vs_arb_version = VS_VERSION_NOT_SUPPORTED;
 577     gl_info->vs_arb_max_temps = 0;
 578     gl_info->vs_arb_max_instructions = 0;
 579     gl_info->vs_nv_version  = VS_VERSION_NOT_SUPPORTED;
 580     gl_info->vs_ati_version = VS_VERSION_NOT_SUPPORTED;
 581     gl_info->vs_glsl_constantsF = 0;
 582     gl_info->ps_glsl_constantsF = 0;
 583     gl_info->vs_arb_constantsF = 0;
 584     gl_info->ps_arb_constantsF = 0;
 585
 586 /* Now work out what GL support this card really has */
 587 #define USE_GL_FUNC(type, pfn) gl_info->pfn = (type) pwglGetProcAddress(#pfn);
 588     GL_EXT_FUNCS_GEN;
 589     WGL_EXT_FUNCS_GEN;
 590 #undef USE_GL_FUNC
 591
 592     /* Retrieve opengl defaults */
 593     glGetIntegerv(GL_MAX_CLIP_PLANES, &gl_max);
 594     gl_info->max_clipplanes = min(WINED3DMAXUSERCLIPPLANES, gl_max);
 595     TRACE_(d3d_caps)("ClipPlanes support - num Planes=%d\n", gl_max);
 596
 597     glGetIntegerv(GL_MAX_LIGHTS, &gl_max);
 598     gl_info->max_lights = gl_max;
 599     TRACE_(d3d_caps)("Lights support - max lights=%d\n", gl_max);
 600
 601     glGetIntegerv(GL_MAX_TEXTURE_SIZE, &gl_max);
 602     gl_info->max_texture_size = gl_max;
 603     TRACE_(d3d_caps)("Maximum texture size support - max texture size=%d\n", gl_max);
 604
 605     glGetFloatv(GL_POINT_SIZE_RANGE, gl_floatv);
 606     gl_info->max_pointsize = gl_floatv[1];
 607     TRACE_(d3d_caps)("Maximum point size support - max point size=%f\n", gl_floatv[1]);
 608
 609     glGetIntegerv(GL_AUX_BUFFERS, &gl_max);
 610     gl_info->max_aux_buffers = gl_max;
 611     TRACE_(d3d_caps)("Offscreen rendering support - number of aux buffers=%d\n", gl_max);
 612
 613     /* Parse the gl supported features, in theory enabling parts of our code appropriately */
 614     GL_Extensions = (const char *) glGetString(GL_EXTENSIONS);
 615     TRACE_(d3d_caps)("GL_Extensions reported:\n");
 616
 617     if (NULL == GL_Extensions) {
 618         ERR("   GL_Extensions returns NULL\n");
 619     } else {
 620         while (*GL_Extensions != 0x00) {
 621             const char *Start;
 622             char        ThisExtn[256];
 623             size_t      len;
 624
 625             while (isspace(*GL_Extensions)) GL_Extensions++;
 626             Start = GL_Extensions;
 627             while (!isspace(*GL_Extensions) && *GL_Extensions != 0x00) {
 628                 GL_Extensions++;
 629             }
 630
 631             len = GL_Extensions - Start;
 632             if (len == 0 || len >= sizeof(ThisExtn))
 633                 continue;
 634
 635             memcpy(ThisExtn, Start, len);
 636             ThisExtn[len] = '\0';
 637             TRACE_(d3d_caps)("- %s\n", ThisExtn);
 638
 639             for (i = 0; i < (sizeof(EXTENSION_MAP) / sizeof(*EXTENSION_MAP)); ++i) {
 640                 if (!strcmp(ThisExtn, EXTENSION_MAP[i].extension_string)) {
 641                     TRACE_(d3d_caps)(" FOUND: %s support\n", EXTENSION_MAP[i].extension_string);
 642                     gl_info->supported[EXTENSION_MAP[i].extension] = TRUE;
 643                     break;
 644                 }
 645             }
 646         }
 647
 648         if (gl_info->supported[APPLE_FENCE]) {
 649             /* GL_NV_fence and GL_APPLE_fence provide the same functionality basically.
 650              * The apple extension interacts with some other apple exts. Disable the NV
 651              * extension if the apple one is support to prevent confusion in other parts
 652              * of the code
 653              */
 654             gl_info->supported[NV_FENCE] = FALSE;
 655         }
 656         if (gl_info->supported[ARB_TEXTURE_CUBE_MAP]) {
 657             TRACE_(d3d_caps)(" IMPLIED: NVIDIA (NV) Texture Gen Reflection support\n");
 658             gl_info->supported[NV_TEXGEN_REFLECTION] = TRUE;
 659         }
 660         if (gl_info->supported[NV_TEXTURE_SHADER2]) {
 661             /* GL_ATI_envmap_bumpmap won't play nice with texture shaders, so disable it
 662              * Won't occur in any real world situation though
 663              */
 664             gl_info->supported[ATI_ENVMAP_BUMPMAP] = FALSE;
 665         }
 666         if (gl_info->supported[ARB_DRAW_BUFFERS]) {
 667             glGetIntegerv(GL_MAX_DRAW_BUFFERS_ARB, &gl_max);
 668             gl_info->max_buffers = gl_max;
 669             TRACE_(d3d_caps)("Max draw buffers: %u\n", gl_max);
 670         }
 671         if (gl_info->supported[ARB_MULTITEXTURE]) {
 672             glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &gl_max);
 673             gl_info->max_textures = min(MAX_TEXTURES, gl_max);
 674             TRACE_(d3d_caps)("Max textures: %d\n", gl_info->max_textures);
 675
 676             if (gl_info->supported[NV_REGISTER_COMBINERS]) {
 677                 GLint tmp;
 678                 glGetIntegerv(GL_MAX_GENERAL_COMBINERS_NV, &tmp);
 679                 gl_info->max_texture_stages = min(MAX_TEXTURES, tmp);
 680             } else {
 681                 gl_info->max_texture_stages = min(MAX_TEXTURES, gl_max);
 682             }
 683             TRACE_(d3d_caps)("Max texture stages: %d\n", gl_info->max_texture_stages);
 684
 685             if (gl_info->supported[ARB_FRAGMENT_PROGRAM]) {
 686                 GLint tmp;
 687                 glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS_ARB, &tmp);
 688                 gl_info->max_fragment_samplers = min(MAX_FRAGMENT_SAMPLERS, tmp);
 689             } else {
 690                 gl_info->max_fragment_samplers = max(gl_info->max_fragment_samplers, gl_max);
 691             }
 692             TRACE_(d3d_caps)("Max fragment samplers: %d\n", gl_info->max_fragment_samplers);
 693
 694             if (gl_info->supported[ARB_VERTEX_SHADER]) {
 695                 GLint tmp;
 696                 glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB, &tmp);
 697                 gl_info->max_vertex_samplers = tmp;
 698                 glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB, &tmp);
 699                 gl_info->max_combined_samplers = tmp;
 700             } else {
 701                 gl_info->max_combined_samplers = gl_info->max_fragment_samplers;
 702             }
 703             TRACE_(d3d_caps)("Max vertex samplers: %u\n", gl_info->max_vertex_samplers);
 704             TRACE_(d3d_caps)("Max combined samplers: %u\n", gl_info->max_combined_samplers);
 705         }
 706         if (gl_info->supported[ARB_VERTEX_BLEND]) {
 707             glGetIntegerv(GL_MAX_VERTEX_UNITS_ARB, &gl_max);
 708             gl_info->max_blends = gl_max;
 709             TRACE_(d3d_caps)("Max blends: %u\n", gl_info->max_blends);
 710         }
 711         if (gl_info->supported[EXT_TEXTURE3D]) {
 712             glGetIntegerv(GL_MAX_3D_TEXTURE_SIZE_EXT, &gl_max);
 713             gl_info->max_texture3d_size = gl_max;
 714             TRACE_(d3d_caps)("Max texture3D size: %d\n", gl_info->max_texture3d_size);
 715         }
 716         if (gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC]) {
 717             glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &gl_max);
 718             gl_info->max_anisotropy = gl_max;
 719             TRACE_(d3d_caps)("Max anisotropy: %d\n", gl_info->max_anisotropy);
 720         }
 721         if (gl_info->supported[ARB_FRAGMENT_PROGRAM]) {
 722             gl_info->ps_arb_version = PS_VERSION_11;
 723             GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max));
 724             gl_info->ps_arb_constantsF = gl_max;
 725             TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM float constants: %d\n", gl_info->ps_arb_constantsF);
 726             GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_TEMPORARIES_ARB, &gl_max));
 727             gl_info->ps_arb_max_temps = gl_max;
 728             TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM temporaries: %d\n", gl_info->ps_arb_max_temps);
 729             GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_INSTRUCTIONS_ARB, &gl_max));
 730             gl_info->ps_arb_max_instructions = gl_max;
 731             TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM instructions: %d\n", gl_info->ps_arb_max_instructions);
 732         }
 733         if (gl_info->supported[ARB_VERTEX_PROGRAM]) {
 734             gl_info->vs_arb_version = VS_VERSION_11;
 735             GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max));
 736             gl_info->vs_arb_constantsF = gl_max;
 737             TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM float constants: %d\n", gl_info->vs_arb_constantsF);
 738             GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_TEMPORARIES_ARB, &gl_max));
 739             gl_info->vs_arb_max_temps = gl_max;
 740             TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM temporaries: %d\n", gl_info->vs_arb_max_temps);
 741             GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_INSTRUCTIONS_ARB, &gl_max));
 742             gl_info->vs_arb_max_instructions = gl_max;
 743             TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM instructions: %d\n", gl_info->vs_arb_max_instructions);
 744         }
 745         if (gl_info->supported[ARB_VERTEX_SHADER]) {
 746             glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB, &gl_max);
 747             gl_info->vs_glsl_constantsF = gl_max / 4;
 748             TRACE_(d3d_caps)("Max ARB_VERTEX_SHADER float constants: %u\n", gl_info->vs_glsl_constantsF);
 749         }
 750         if (gl_info->supported[ARB_FRAGMENT_SHADER]) {
 751             glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB, &gl_max);
 752             gl_info->ps_glsl_constantsF = gl_max / 4;
 753             TRACE_(d3d_caps)("Max ARB_FRAGMENT_SHADER float constants: %u\n", gl_info->ps_glsl_constantsF);
 754         }
 755         if (gl_info->supported[EXT_VERTEX_SHADER]) {
 756             gl_info->vs_ati_version = VS_VERSION_11;
 757         }
 758         if (gl_info->supported[NV_VERTEX_PROGRAM3]) {
 759             gl_info->vs_nv_version = VS_VERSION_30;
 760         } else if (gl_info->supported[NV_VERTEX_PROGRAM2]) {
 761             gl_info->vs_nv_version = VS_VERSION_20;
 762         } else if (gl_info->supported[NV_VERTEX_PROGRAM1_1]) {
 763             gl_info->vs_nv_version = VS_VERSION_11;
 764         } else if (gl_info->supported[NV_VERTEX_PROGRAM]) {
 765             gl_info->vs_nv_version = VS_VERSION_10;
 766         }
 767         if (gl_info->supported[NV_FRAGMENT_PROGRAM2]) {
 768             gl_info->ps_nv_version = PS_VERSION_30;
 769         } else if (gl_info->supported[NV_FRAGMENT_PROGRAM]) {
 770             gl_info->ps_nv_version = PS_VERSION_20;
 771         }
 772
 773     }
 774     checkGLcall("extension detection\n");
 775
 776     /* In some cases the number of texture stages can be larger than the number
 777      * of samplers. The GF4 for example can use only 2 samplers (no fragment
 778      * shaders), but 8 texture stages (register combiners). */
 779     gl_info->max_sampler_stages = max(gl_info->max_fragment_samplers, gl_info->max_texture_stages);
 780
 781     /* We can only use ORM_FBO when the hardware supports it. */
 782     if (wined3d_settings.offscreen_rendering_mode == ORM_FBO && !gl_info->supported[EXT_FRAMEBUFFER_OBJECT]) {
 783         WARN_(d3d_caps)("GL_EXT_framebuffer_object not supported, falling back to PBuffer offscreen rendering mode.\n");
 784         wined3d_settings.offscreen_rendering_mode = ORM_PBUFFER;
 785     }
 786
 787     /* MRTs are currently only supported when FBOs are used. */
 788     if (wined3d_settings.offscreen_rendering_mode != ORM_FBO) {
 789         gl_info->max_buffers = 1;
 790     }
 791
 792     /* Below is a list of Nvidia and ATI GPUs. Both vendors have dozens of different GPUs with roughly the same
 793      * features. In most cases GPUs from a certain family differ in clockspeeds, the amount of video memory and
 794      * in case of the latest videocards in the number of pixel/vertex pipelines.
 795      *
 796      * A Direct3D device object contains the PCI id (vendor + device) of the videocard which is used for
 797      * rendering. Various games use this information to get a rough estimation of the features of the card
 798      * and some might use it for enabling 3d effects only on certain types of videocards. In some cases
 799      * games might even use it to work around bugs which happen on certain videocards/driver combinations.
 800      * The problem is that OpenGL only exposes a rendering string containing the name of the videocard and
 801      * not the PCI id.
 802      *
 803      * Various games depend on the PCI id, so somehow we need to provide one. A simple option is to parse
 804      * the renderer string and translate this to the right PCI id. This is a lot of work because there are more
 805      * than 200 GPUs just for Nvidia. Various cards share the same renderer string, so the amount of code might
 806      * be 'small' but there are quite a number of exceptions which would make this a pain to maintain.
 807      * Another way would be to query the PCI id from the operating system (assuming this is the videocard which
 808      * is used for rendering which is not always the case). This would work but it is not very portable. Second
 809      * it would not work well in, let's say, a remote X situation in which the amount of 3d features which can be used
 810      * is limited.
 811      *
 812      * As said most games only use the PCI id to get an indication of the capabilities of the card.
 813      * It doesn't really matter if the given id is the correct one if we return the id of a card with
 814      * similar 3d features.
 815      *
 816      * The code below checks the OpenGL capabilities of a videocard and matches that to a certain level of
 817      * Direct3D functionality. Once a card passes the Direct3D9 check, we know that the card (in case of Nvidia)
 818      * is at least a GeforceFX. To give a better estimate we do a basic check on the renderer string but if that
 819      * won't pass we return a default card. This way is better than maintaining a full card database as even
 820      * without a full database we can return a card with similar features. Second the size of the database
 821      * can be made quite small because when you know what type of 3d functionality a card has, you know to which
 822      * GPU family the GPU must belong. Because of this you only have to check a small part of the renderer string
 823      * to distinguishes between different models from that family.
 824      *
 825      * The code also selects a default amount of video memory which we will use for an estimation of the amount
 826      * of free texture memory. In case of real D3D the amount of texture memory includes video memory and system
 827      * memory (to be specific AGP memory or in case of PCIE TurboCache/HyperMemory). We don't know how much
 828      * system memory can be addressed by the system but we can make a reasonable estimation about the amount of
 829      * video memory. If the value is slightly wrong it doesn't matter as we didn't include AGP-like memory which
 830      * makes the amount of addressable memory higher and second OpenGL isn't that critical it moves to system
 831      * memory behind our backs if really needed.
 832      * Note that the amout of video memory can be overruled using a registry setting.
 833      */
 834     switch (gl_info->gl_vendor) {
 835         case VENDOR_NVIDIA:
 836             /* Both the GeforceFX, 6xxx and 7xxx series support D3D9. The last two types have more
 837              * shader capabilities, so we use the shader capabilities to distinguish between FX and 6xxx/7xxx.
 838              */
 839             if(WINE_D3D9_CAPABLE(gl_info) && (gl_info->vs_nv_version == VS_VERSION_30)) {
 840                 /* Geforce8 - highend */
 841                 if (strstr(gl_info->gl_renderer, "8800")) {
 842                     gl_info->gl_card = CARD_NVIDIA_GEFORCE_8800GTS;
 843                     vidmem = 320; /* The 8800GTS uses 320MB, a 8800GTX can have 768MB */
 844                 }
 845                 /* Geforce8 - midend */
 846                 else if(strstr(gl_info->gl_renderer, "8600") ||
 847                         strstr(gl_info->gl_renderer, "8700"))
 848                 {
 849                     gl_info->gl_card = CARD_NVIDIA_GEFORCE_8600GT;
 850                     vidmem = 256;
 851                 }
 852                 /* Geforce8 - lowend */
 853                 else if(strstr(gl_info->gl_renderer, "8300") ||
 854                         strstr(gl_info->gl_renderer, "8400") ||
 855                         strstr(gl_info->gl_renderer, "8500"))
 856                 {
 857                     gl_info->gl_card = CARD_NVIDIA_GEFORCE_8300GS;
 858                     vidmem = 128; /* 128-256MB for a 8300, 256-512MB for a 8400 */
 859                 }
 860                 /* Geforce7 - highend */
 861                 else if(strstr(gl_info->gl_renderer, "7800") ||
 862                         strstr(gl_info->gl_renderer, "7900") ||
 863                         strstr(gl_info->gl_renderer, "7950") ||
 864                         strstr(gl_info->gl_renderer, "Quadro FX 4") ||
 865                         strstr(gl_info->gl_renderer, "Quadro FX 5"))
 866                 {
 867                     gl_info->gl_card = CARD_NVIDIA_GEFORCE_7800GT;
 868                     vidmem = 256; /* A 7800GT uses 256MB while highend 7900 cards can use 512MB */
 869                 }
 870                 /* Geforce7 midend / Geforce6 highend */
 871                 else if(strstr(gl_info->gl_renderer, "6800") ||
 872                         strstr(gl_info->gl_renderer, "7600") ||
 873                         strstr(gl_info->gl_renderer, "7700"))
 874                 {
 875                     gl_info->gl_card = CARD_NVIDIA_GEFORCE_6800;
 876                     vidmem = 128; /* The 6800 uses 128-256MB, the 7600 uses 256-512MB */
 877                 }
 878                 /* Geforce6 - midend */
 879                 else if(strstr(gl_info->gl_renderer, "6600") ||
 880                         strstr(gl_info->gl_renderer, "6610") ||
 881                         strstr(gl_info->gl_renderer, "6700"))
 882                 {
 883                     gl_info->gl_card = CARD_NVIDIA_GEFORCE_6600GT;
 884                     vidmem = 128; /* A 6600GT has 128-256MB */
 885                 }
 886                 /* Geforce6/7 lowend */
 887                 else {
 888                     gl_info->gl_card = CARD_NVIDIA_GEFORCE_6200; /* Geforce 6100/6150/6200/7300/7400/7500 */
 889                     vidmem = 64; /* */
 890                 }
 891             } else if(WINE_D3D9_CAPABLE(gl_info)) {
 892                 /* GeforceFX - highend */
 893                 if (strstr(gl_info->gl_renderer, "5800") ||
 894                     strstr(gl_info->gl_renderer, "5900") ||
 895                     strstr(gl_info->gl_renderer, "5950") ||
 896                     strstr(gl_info->gl_renderer, "Quadro FX"))
 897                 {
 898                     gl_info->gl_card = CARD_NVIDIA_GEFORCEFX_5800;
 899                     vidmem = 256; /* 5800-5900 cards use 256MB */
 900                 }
 901                 /* GeforceFX - midend */
 902                 else if(strstr(gl_info->gl_renderer, "5600") ||
 903                         strstr(gl_info->gl_renderer, "5650") ||
 904                         strstr(gl_info->gl_renderer, "5700") ||
 905                         strstr(gl_info->gl_renderer, "5750"))
 906                 {
 907                     gl_info->gl_card = CARD_NVIDIA_GEFORCEFX_5600;
 908                     vidmem = 128; /* A 5600 uses 128-256MB */
 909                 }
 910                 /* GeforceFX - lowend */
 911                 else {
 912                     gl_info->gl_card = CARD_NVIDIA_GEFORCEFX_5200; /* GeforceFX 5100/5200/5250/5300/5500 */
 913                     vidmem = 64; /* Normal FX5200 cards use 64-256MB; laptop (non-standard) can have less */
 914                 }
 915             } else if(WINE_D3D8_CAPABLE(gl_info)) {
 916                 if (strstr(gl_info->gl_renderer, "GeForce4 Ti") || strstr(gl_info->gl_renderer, "Quadro4")) {
 917                     gl_info->gl_card = CARD_NVIDIA_GEFORCE4_TI4200; /* Geforce4 Ti4200/Ti4400/Ti4600/Ti4800, Quadro4 */
 918                     vidmem = 64; /* Geforce4 Ti cards have 64-128MB */
 919                 }
 920                 else {
 921                     gl_info->gl_card = CARD_NVIDIA_GEFORCE3; /* Geforce3 standard/Ti200/Ti500, Quadro DCC */
 922                     vidmem = 64; /* Geforce3 cards have 64-128MB */
 923                 }
 924             } else if(WINE_D3D7_CAPABLE(gl_info)) {
 925                 if (strstr(gl_info->gl_renderer, "GeForce4 MX")) {
 926                     gl_info->gl_card = CARD_NVIDIA_GEFORCE4_MX; /* MX420/MX440/MX460/MX4000 */
 927                     vidmem = 64; /* Most Geforce4MX GPUs have at least 64MB of memory, some early models had 32MB but most have 64MB or even 128MB */
 928                 }
 929                 else if(strstr(gl_info->gl_renderer, "GeForce2 MX") || strstr(gl_info->gl_renderer, "Quadro2 MXR")) {
 930                     gl_info->gl_card = CARD_NVIDIA_GEFORCE2_MX; /* Geforce2 standard/MX100/MX200/MX400, Quadro2 MXR */
 931                     vidmem = 32; /* Geforce2MX GPUs have 32-64MB of video memory */
 932                 }
 933                 else if(strstr(gl_info->gl_renderer, "GeForce2") || strstr(gl_info->gl_renderer, "Quadro2")) {
 934                     gl_info->gl_card = CARD_NVIDIA_GEFORCE2; /* Geforce2 GTS/Pro/Ti/Ultra, Quadro2 */
 935                     vidmem = 32; /* Geforce2 GPUs have 32-64MB of video memory */
 936                 }
 937                 else {
 938                     gl_info->gl_card = CARD_NVIDIA_GEFORCE; /* Geforce 256/DDR, Quadro */
 939                     vidmem = 32; /* Most Geforce1 cards have 32MB, there are also some rare 16 and 64MB (Dell) models */
 940                 }
 941             } else {
 942                 if (strstr(gl_info->gl_renderer, "TNT2")) {
 943                     gl_info->gl_card = CARD_NVIDIA_RIVA_TNT2; /* Riva TNT2 standard/M64/Pro/Ultra */
 944                     vidmem = 32; /* Most TNT2 boards have 32MB, though there are 16MB boards too */
 945                 }
 946                 else {
 947                     gl_info->gl_card = CARD_NVIDIA_RIVA_TNT; /* Riva TNT, Vanta */
 948                     vidmem = 16; /* Most TNT boards have 16MB, some rare models have 8MB */
 949                 }
 950             }
 951             break;
 952         case VENDOR_ATI:
 953             if(WINE_D3D9_CAPABLE(gl_info)) {
 954                 /* Radeon R6xx HD2900 - highend */
 955                 if (strstr(gl_info->gl_renderer, "HD 2900")) {
 956                     gl_info->gl_card = CARD_ATI_RADEON_HD2900;
 957                     vidmem = 512; /* HD2900 uses 512-1024MB */
 958                 }
 959                 /* Radeon R6xx HD2600- midend */
 960                 else if (strstr(gl_info->gl_renderer, "HD 2600")) {
 961                     gl_info->gl_card = CARD_ATI_RADEON_HD2600;
 962                     vidmem = 256; /* HD2600 uses 256-512MB */
 963                 }
 964                 /* Radeon R6xx HD2300/HD2400 - lowend */
 965                 else if (strstr(gl_info->gl_renderer, "HD 2300") ||
 966                          strstr(gl_info->gl_renderer, "HD 2400"))
 967                 {
 968                     gl_info->gl_card = CARD_ATI_RADEON_HD2300;
 969                     vidmem = 128; /* HD2300 uses at least 128MB, HD2400 uses 256MB */
 970                 }
 971                 /* Radeon R5xx */
 972                 else if (strstr(gl_info->gl_renderer, "X1600") ||
 973                          strstr(gl_info->gl_renderer, "X1650") ||
 974                          strstr(gl_info->gl_renderer, "X1800") ||
 975                          strstr(gl_info->gl_renderer, "X1900") ||
 976                          strstr(gl_info->gl_renderer, "X1950"))
 977                 {
 978                     gl_info->gl_card = CARD_ATI_RADEON_X1600;
 979                     vidmem = 128; /* X1600 uses 128-256MB, >=X1800 uses 256MB */
 980                 }
 981                 /* Radeon R4xx + X1300/X1400/X1450/X1550/X2300 (lowend R5xx) */
 982                 else if(strstr(gl_info->gl_renderer, "X700") ||
 983                         strstr(gl_info->gl_renderer, "X800") ||
 984                         strstr(gl_info->gl_renderer, "X850") ||
 985                         strstr(gl_info->gl_renderer, "X1300") ||
 986                         strstr(gl_info->gl_renderer, "X1400") ||
 987                         strstr(gl_info->gl_renderer, "X1450") ||
 988                         strstr(gl_info->gl_renderer, "X1550"))
 989                 {
 990                     gl_info->gl_card = CARD_ATI_RADEON_X700;
 991                     vidmem = 128; /* x700/x8*0 use 128-256MB, >=x1300 128-512MB */
 992                 }
 993                 /* Radeon R3xx */
 994                 else {
 995                     gl_info->gl_card = CARD_ATI_RADEON_9500; /* Radeon 9500/9550/9600/9700/9800/X300/X550/X600 */
 996                     vidmem = 64; /* Radeon 9500 uses 64MB, higher models use up to 256MB */
 997                 }
 998             } else if(WINE_D3D8_CAPABLE(gl_info)) {
 999                 gl_info->gl_card = CARD_ATI_RADEON_8500; /* Radeon 8500/9000/9100/9200/9300 */
1000                 vidmem = 64; /* 8500/9000 cards use mostly 64MB, though there are 32MB and 128MB models */
1001             } else if(WINE_D3D7_CAPABLE(gl_info)) {
1002                 gl_info->gl_card = CARD_ATI_RADEON_7200; /* Radeon 7000/7100/7200/7500 */
1003                 vidmem = 32; /* There are models with up to 64MB */
1004             } else
1005                 gl_info->gl_card = CARD_ATI_RAGE_128PRO;
1006                 vidmem = 16; /* There are 16-32MB models */
1007             break;
1008         case VENDOR_INTEL:
1009             if (strstr(gl_info->gl_renderer, "915GM")) {
1010                 gl_info->gl_card = CARD_INTEL_I915GM;
1011             } else if (strstr(gl_info->gl_renderer, "915G")) {
1012                 gl_info->gl_card = CARD_INTEL_I915G;
1013             } else if (strstr(gl_info->gl_renderer, "865G")) {
1014                 gl_info->gl_card = CARD_INTEL_I865G;
1015             } else if (strstr(gl_info->gl_renderer, "855G")) {
1016                 gl_info->gl_card = CARD_INTEL_I855G;
1017             } else if (strstr(gl_info->gl_renderer, "830G")) {
1018                 gl_info->gl_card = CARD_INTEL_I830G;
1019             } else {
1020                 gl_info->gl_card = CARD_INTEL_I915G;
1021             }
1022             break;
1023         case VENDOR_MESA:
1024         case VENDOR_WINE:
1025         default:
1026             /* Default to generic Nvidia hardware based on the supported OpenGL extensions. The choice
1027              * for Nvidia was because the hardware and drivers they make are of good quality. This makes
1028              * them a good generic choice.
1029              */
1030             gl_info->gl_vendor = VENDOR_NVIDIA;
1031             if(WINE_D3D9_CAPABLE(gl_info))
1032                 gl_info->gl_card = CARD_NVIDIA_GEFORCEFX_5600;
1033             else if(WINE_D3D8_CAPABLE(gl_info))
1034                 gl_info->gl_card = CARD_NVIDIA_GEFORCE3;
1035             else if(WINE_D3D7_CAPABLE(gl_info))
1036                 gl_info->gl_card = CARD_NVIDIA_GEFORCE;
1037             else if(WINE_D3D6_CAPABLE(gl_info))
1038                 gl_info->gl_card = CARD_NVIDIA_RIVA_TNT;
1039             else
1040                 gl_info->gl_card = CARD_NVIDIA_RIVA_128;
1041     }
1042     TRACE("FOUND (fake) card: 0x%x (vendor id), 0x%x (device id)\n", gl_info->gl_vendor, gl_info->gl_card);
1043
1044     /* If we have an estimate use it, else default to 64MB;  */
1045     if(vidmem)
1046         gl_info->vidmem = vidmem*1024*1024; /* convert from MBs to bytes */
1047     else
1048         gl_info->vidmem = WINE_DEFAULT_VIDMEM;
1049
1050     /* Load all the lookup tables
1051     TODO: It may be a good idea to make minLookup and maxLookup const and populate them in wined3d_private.h where they are declared */
1052     minLookup[WINELOOKUP_WARPPARAM] = WINED3DTADDRESS_WRAP;
1053     maxLookup[WINELOOKUP_WARPPARAM] = WINED3DTADDRESS_MIRRORONCE;
1054
1055     minLookup[WINELOOKUP_MAGFILTER] = WINED3DTEXF_NONE;
1056     maxLookup[WINELOOKUP_MAGFILTER] = WINED3DTEXF_ANISOTROPIC;
1057
1058
1059     for (i = 0; i < MAX_LOOKUPS; i++) {
1060         stateLookup[i] = HeapAlloc(GetProcessHeap(), 0, sizeof(*stateLookup[i]) * (1 + maxLookup[i] - minLookup[i]) );
1061     }
1062
1063     stateLookup[WINELOOKUP_WARPPARAM][WINED3DTADDRESS_WRAP   - minLookup[WINELOOKUP_WARPPARAM]] = GL_REPEAT;
1064     stateLookup[WINELOOKUP_WARPPARAM][WINED3DTADDRESS_CLAMP  - minLookup[WINELOOKUP_WARPPARAM]] = GL_CLAMP_TO_EDGE;
1065     stateLookup[WINELOOKUP_WARPPARAM][WINED3DTADDRESS_BORDER - minLookup[WINELOOKUP_WARPPARAM]] =
1066              gl_info->supported[ARB_TEXTURE_BORDER_CLAMP] ? GL_CLAMP_TO_BORDER_ARB : GL_REPEAT;
1067     stateLookup[WINELOOKUP_WARPPARAM][WINED3DTADDRESS_BORDER - minLookup[WINELOOKUP_WARPPARAM]] =
1068              gl_info->supported[ARB_TEXTURE_BORDER_CLAMP] ? GL_CLAMP_TO_BORDER_ARB : GL_REPEAT;
1069     stateLookup[WINELOOKUP_WARPPARAM][WINED3DTADDRESS_MIRROR - minLookup[WINELOOKUP_WARPPARAM]] =
1070              gl_info->supported[ARB_TEXTURE_MIRRORED_REPEAT] ? GL_MIRRORED_REPEAT_ARB : GL_REPEAT;
1071     stateLookup[WINELOOKUP_WARPPARAM][WINED3DTADDRESS_MIRRORONCE - minLookup[WINELOOKUP_WARPPARAM]] =
1072              gl_info->supported[ATI_TEXTURE_MIRROR_ONCE] ? GL_MIRROR_CLAMP_TO_EDGE_ATI : GL_REPEAT;
1073
1074     stateLookup[WINELOOKUP_MAGFILTER][WINED3DTEXF_NONE        - minLookup[WINELOOKUP_MAGFILTER]]  = GL_NEAREST;
1075     stateLookup[WINELOOKUP_MAGFILTER][WINED3DTEXF_POINT       - minLookup[WINELOOKUP_MAGFILTER]] = GL_NEAREST;
1076     stateLookup[WINELOOKUP_MAGFILTER][WINED3DTEXF_LINEAR      - minLookup[WINELOOKUP_MAGFILTER]] = GL_LINEAR;
1077     stateLookup[WINELOOKUP_MAGFILTER][WINED3DTEXF_ANISOTROPIC - minLookup[WINELOOKUP_MAGFILTER]] =
1078              gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC] ? GL_LINEAR : GL_NEAREST;
1079
1080
1081     minMipLookup[WINED3DTEXF_NONE][WINED3DTEXF_NONE]     = GL_LINEAR;
1082     minMipLookup[WINED3DTEXF_NONE][WINED3DTEXF_POINT]    = GL_LINEAR;
1083     minMipLookup[WINED3DTEXF_NONE][WINED3DTEXF_LINEAR]   = GL_LINEAR;
1084     minMipLookup[WINED3DTEXF_POINT][WINED3DTEXF_NONE]    = GL_NEAREST;
1085     minMipLookup[WINED3DTEXF_POINT][WINED3DTEXF_POINT]   = GL_NEAREST_MIPMAP_NEAREST;
1086     minMipLookup[WINED3DTEXF_POINT][WINED3DTEXF_LINEAR]  = GL_NEAREST_MIPMAP_LINEAR;
1087     minMipLookup[WINED3DTEXF_LINEAR][WINED3DTEXF_NONE]   = GL_LINEAR;
1088     minMipLookup[WINED3DTEXF_LINEAR][WINED3DTEXF_POINT]  = GL_LINEAR_MIPMAP_NEAREST;
1089     minMipLookup[WINED3DTEXF_LINEAR][WINED3DTEXF_LINEAR] = GL_LINEAR_MIPMAP_LINEAR;
1090     minMipLookup[WINED3DTEXF_ANISOTROPIC][WINED3DTEXF_NONE]   = gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC] ?
1091     GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR;
1092     minMipLookup[WINED3DTEXF_ANISOTROPIC][WINED3DTEXF_POINT]  = gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC] ? GL_LINEAR_MIPMAP_NEAREST : GL_LINEAR;
1093     minMipLookup[WINED3DTEXF_ANISOTROPIC][WINED3DTEXF_LINEAR] = gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC] ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR;
1094
1095 /* TODO: config lookups */
1096
1097     /* Make sure there's an active HDC else the WGL extensions will fail */
1098     hdc = pwglGetCurrentDC();
1099     if (hdc) {
1100         WGL_Extensions = GL_EXTCALL(wglGetExtensionsStringARB(hdc));
1101         TRACE_(d3d_caps)("WGL_Extensions reported:\n");
1102
1103         if (NULL == WGL_Extensions) {
1104             ERR("   WGL_Extensions returns NULL\n");
1105         } else {
1106             while (*WGL_Extensions != 0x00) {
1107                 const char *Start;
1108                 char ThisExtn[256];
1109                 size_t len;
1110
1111                 while (isspace(*WGL_Extensions)) WGL_Extensions++;
1112                 Start = WGL_Extensions;
1113                 while (!isspace(*WGL_Extensions) && *WGL_Extensions != 0x00) {
1114                     WGL_Extensions++;
1115                 }
1116
1117                 len = WGL_Extensions - Start;
1118                 if (len == 0 || len >= sizeof(ThisExtn))
1119                     continue;
1120
1121                 memcpy(ThisExtn, Start, len);
1122                 ThisExtn[len] = '\0';
1123                 TRACE_(d3d_caps)("- %s\n", ThisExtn);
1124
1125                 if (!strcmp(ThisExtn, "WGL_ARB_pbuffer")) {
1126                     gl_info->supported[WGL_ARB_PBUFFER] = TRUE;
1127                     TRACE_(d3d_caps)("FOUND: WGL_ARB_pbuffer support\n");
1128                 }
1129             }
1130         }
1131     }
1132     LEAVE_GL();
1133
1134     return return_value;
1135 }
1136 #undef GLINFO_LOCATION
1137
1138 /**********************************************************
1139  * IWineD3D implementation follows
1140  **********************************************************/
1141
1142 static UINT     WINAPI IWineD3DImpl_GetAdapterCount (IWineD3D *iface) {
1143     IWineD3DImpl *This = (IWineD3DImpl *)iface;
1144
1145     TRACE_(d3d_caps)("(%p): Reporting %d adapters\n", This, numAdapters);
1146     return numAdapters;
1147 }
1148
1149 static HRESULT  WINAPI IWineD3DImpl_RegisterSoftwareDevice(IWineD3D *iface, void* pInitializeFunction) {
1150     IWineD3DImpl *This = (IWineD3DImpl *)iface;
1151     FIXME("(%p)->(%p): stub\n", This, pInitializeFunction);
1152     return WINED3D_OK;
1153 }
1154
1155 static HMONITOR WINAPI IWineD3DImpl_GetAdapterMonitor(IWineD3D *iface, UINT Adapter) {
1156     IWineD3DImpl *This = (IWineD3DImpl *)iface;
1157
1158     if (Adapter >= IWineD3DImpl_GetAdapterCount(iface)) {
1159         return NULL;
1160     }
1161
1162     TRACE_(d3d_caps)("(%p)->(%d)\n", This, Adapter);
1163     return MonitorFromPoint(Adapters[Adapter].monitorPoint, MONITOR_DEFAULTTOPRIMARY);
1164 }
1165
1166 /* FIXME: GetAdapterModeCount and EnumAdapterModes currently only returns modes
1167      of the same bpp but different resolutions                                  */
1168
1169 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */
1170 static UINT     WINAPI IWineD3DImpl_GetAdapterModeCount(IWineD3D *iface, UINT Adapter, WINED3DFORMAT Format) {
1171     IWineD3DImpl *This = (IWineD3DImpl *)iface;
1172     TRACE_(d3d_caps)("(%p}->(Adapter: %d, Format: %s)\n", This, Adapter, debug_d3dformat(Format));
1173
1174     if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
1175         return 0;
1176     }
1177
1178     /* TODO: Store modes per adapter and read it from the adapter structure */
1179     if (Adapter == 0) { /* Display */
1180         int i = 0;
1181         int j = 0;
1182
1183         if (!DEBUG_SINGLE_MODE) {
1184             DEVMODEW DevModeW;
1185
1186             ZeroMemory(&DevModeW, sizeof(DevModeW));
1187             DevModeW.dmSize = sizeof(DevModeW);
1188             while (EnumDisplaySettingsExW(NULL, j, &DevModeW, 0)) {
1189                 j++;
1190                 switch (Format)
1191                 {
1192                     case WINED3DFMT_UNKNOWN:
1193                         /* This is for D3D8, do not enumerate P8 here */
1194                         if (DevModeW.dmBitsPerPel == 32 ||
1195                             DevModeW.dmBitsPerPel == 16) i++;
1196                         break;
1197                     case WINED3DFMT_X8R8G8B8:
1198                         if (DevModeW.dmBitsPerPel == 32) i++;
1199                         break;
1200                     case WINED3DFMT_R5G6B5:
1201                         if (DevModeW.dmBitsPerPel == 16) i++;
1202                         break;
1203                     case WINED3DFMT_P8:
1204                         if (DevModeW.dmBitsPerPel == 8) i++;
1205                         break;
1206                     default:
1207                         /* Skip other modes as they do not match the requested format */
1208                         break;
1209                 }
1210             }
1211         } else {
1212             i = 1;
1213             j = 1;
1214         }
1215
1216         TRACE_(d3d_caps)("(%p}->(Adapter: %d) => %d (out of %d)\n", This, Adapter, i, j);
1217         return i;
1218     } else {
1219         FIXME_(d3d_caps)("Adapter not primary display\n");
1220     }
1221     return 0;
1222 }
1223
1224 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */
1225 static HRESULT WINAPI IWineD3DImpl_EnumAdapterModes(IWineD3D *iface, UINT Adapter, WINED3DFORMAT Format, UINT Mode, WINED3DDISPLAYMODE* pMode) {
1226     IWineD3DImpl *This = (IWineD3DImpl *)iface;
1227     TRACE_(d3d_caps)("(%p}->(Adapter:%d, mode:%d, pMode:%p, format:%s)\n", This, Adapter, Mode, pMode, debug_d3dformat(Format));
1228
1229     /* Validate the parameters as much as possible */
1230     if (NULL == pMode ||
1231         Adapter >= IWineD3DImpl_GetAdapterCount(iface) ||
1232         Mode    >= IWineD3DImpl_GetAdapterModeCount(iface, Adapter, Format)) {
1233         return WINED3DERR_INVALIDCALL;
1234     }
1235
1236     /* TODO: Store modes per adapter and read it from the adapter structure */
1237     if (Adapter == 0 && !DEBUG_SINGLE_MODE) { /* Display */
1238         DEVMODEW DevModeW;
1239         int ModeIdx = 0;
1240         int i = 0;
1241         int j = 0;
1242
1243         ZeroMemory(&DevModeW, sizeof(DevModeW));
1244         DevModeW.dmSize = sizeof(DevModeW);
1245
1246         /* If we are filtering to a specific format (D3D9), then need to skip
1247            all unrelated modes, but if mode is irrelevant (D3D8), then we can
1248            just count through the ones with valid bit depths */
1249         while ((i<=Mode) && EnumDisplaySettingsExW(NULL, j++, &DevModeW, 0)) {
1250             switch (Format)
1251             {
1252                 case WINED3DFMT_UNKNOWN:
1253                     /* This is D3D8. Do not enumerate P8 here */
1254                     if (DevModeW.dmBitsPerPel == 32 ||
1255                         DevModeW.dmBitsPerPel == 16) i++;
1256                     break;
1257                 case WINED3DFMT_X8R8G8B8:
1258                     if (DevModeW.dmBitsPerPel == 32) i++;
1259                     break;
1260                 case WINED3DFMT_R5G6B5:
1261                     if (DevModeW.dmBitsPerPel == 16) i++;
1262                     break;
1263                 case WINED3DFMT_P8:
1264                     if (DevModeW.dmBitsPerPel == 8) i++;
1265                     break;
1266                 default:
1267                     /* Modes that don't match what we support can get an early-out */
1268                     TRACE_(d3d_caps)("Searching for %s, returning D3DERR_INVALIDCALL\n", debug_d3dformat(Format));
1269                     return WINED3DERR_INVALIDCALL;
1270             }
1271         }
1272
1273         if (i == 0) {
1274             TRACE_(d3d_caps)("No modes found for format (%x - %s)\n", Format, debug_d3dformat(Format));
1275             return WINED3DERR_INVALIDCALL;
1276         }
1277         ModeIdx = j - 1;
1278
1279         /* Now get the display mode via the calculated index */
1280         if (EnumDisplaySettingsExW(NULL, ModeIdx, &DevModeW, 0)) {
1281             pMode->Width        = DevModeW.dmPelsWidth;
1282             pMode->Height       = DevModeW.dmPelsHeight;
1283             pMode->RefreshRate  = WINED3DADAPTER_DEFAULT;
1284             if (DevModeW.dmFields & DM_DISPLAYFREQUENCY)
1285                 pMode->RefreshRate = DevModeW.dmDisplayFrequency;
1286
1287             if (Format == WINED3DFMT_UNKNOWN)
1288             {
1289                 switch (DevModeW.dmBitsPerPel)
1290                 {
1291                     case 8:
1292                         pMode->Format = WINED3DFMT_P8;
1293                         break;
1294                     case 16:
1295                         pMode->Format = WINED3DFMT_R5G6B5;
1296                         break;
1297                     case 32:
1298                         pMode->Format = WINED3DFMT_X8R8G8B8;
1299                         break;
1300                     default:
1301                         pMode->Format = WINED3DFMT_UNKNOWN;
1302                         ERR("Unhandled bit depth (%u) in mode list!\n", DevModeW.dmBitsPerPel);
1303                 }
1304             } else {
1305                 pMode->Format = Format;
1306             }
1307         } else {
1308             TRACE_(d3d_caps)("Requested mode out of range %d\n", Mode);
1309             return WINED3DERR_INVALIDCALL;
1310         }
1311
1312         TRACE_(d3d_caps)("W %d H %d rr %d fmt (%x - %s) bpp %u\n", pMode->Width, pMode->Height,
1313                 pMode->RefreshRate, pMode->Format, debug_d3dformat(pMode->Format),
1314                 DevModeW.dmBitsPerPel);
1315
1316     } else if (DEBUG_SINGLE_MODE) {
1317         /* Return one setting of the format requested */
1318         if (Mode > 0) return WINED3DERR_INVALIDCALL;
1319         pMode->Width        = 800;
1320         pMode->Height       = 600;
1321         pMode->RefreshRate  = 60;
1322         pMode->Format       = (Format == WINED3DFMT_UNKNOWN) ? WINED3DFMT_X8R8G8B8 : Format;
1323     } else {
1324         FIXME_(d3d_caps)("Adapter not primary display\n");
1325     }
1326
1327     return WINED3D_OK;
1328 }
1329
1330 static HRESULT WINAPI IWineD3DImpl_GetAdapterDisplayMode(IWineD3D *iface, UINT Adapter, WINED3DDISPLAYMODE* pMode) {
1331     IWineD3DImpl *This = (IWineD3DImpl *)iface;
1332     TRACE_(d3d_caps)("(%p}->(Adapter: %d, pMode: %p)\n", This, Adapter, pMode);
1333
1334     if (NULL == pMode ||
1335         Adapter >= IWineD3D_GetAdapterCount(iface)) {
1336         return WINED3DERR_INVALIDCALL;
1337     }
1338
1339     if (Adapter == 0) { /* Display */
1340         int bpp = 0;
1341         DEVMODEW DevModeW;
1342
1343         ZeroMemory(&DevModeW, sizeof(DevModeW));
1344         DevModeW.dmSize = sizeof(DevModeW);
1345
1346         EnumDisplaySettingsExW(NULL, ENUM_CURRENT_SETTINGS, &DevModeW, 0);
1347         pMode->Width        = DevModeW.dmPelsWidth;
1348         pMode->Height       = DevModeW.dmPelsHeight;
1349         bpp                 = DevModeW.dmBitsPerPel;
1350         pMode->RefreshRate  = WINED3DADAPTER_DEFAULT;
1351         if (DevModeW.dmFields&DM_DISPLAYFREQUENCY)
1352         {
1353             pMode->RefreshRate = DevModeW.dmDisplayFrequency;
1354         }
1355
1356         switch (bpp) {
1357         case  8: pMode->Format       = WINED3DFMT_R3G3B2;   break;
1358         case 16: pMode->Format       = WINED3DFMT_R5G6B5;   break;
1359         case 24: pMode->Format       = WINED3DFMT_X8R8G8B8; break; /* Robots needs 24bit to be X8R8G8B8 */
1360         case 32: pMode->Format       = WINED3DFMT_X8R8G8B8; break; /* EVE online and the Fur demo need 32bit AdapterDisplatMode to return X8R8G8B8 */
1361         default: pMode->Format       = WINED3DFMT_UNKNOWN;
1362         }
1363
1364     } else {
1365         FIXME_(d3d_caps)("Adapter not primary display\n");
1366     }
1367
1368     TRACE_(d3d_caps)("returning w:%d, h:%d, ref:%d, fmt:%s\n", pMode->Width,
1369           pMode->Height, pMode->RefreshRate, debug_d3dformat(pMode->Format));
1370     return WINED3D_OK;
1371 }
1372
1373 /* NOTE: due to structure differences between dx8 and dx9 D3DADAPTER_IDENTIFIER,
1374    and fields being inserted in the middle, a new structure is used in place    */
1375 static HRESULT WINAPI IWineD3DImpl_GetAdapterIdentifier(IWineD3D *iface, UINT Adapter, DWORD Flags,
1376                                                    WINED3DADAPTER_IDENTIFIER* pIdentifier) {
1377     IWineD3DImpl *This = (IWineD3DImpl *)iface;
1378
1379     TRACE_(d3d_caps)("(%p}->(Adapter: %d, Flags: %x, pId=%p)\n", This, Adapter, Flags, pIdentifier);
1380
1381     if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
1382         return WINED3DERR_INVALIDCALL;
1383     }
1384
1385     /* Return the information requested */
1386     TRACE_(d3d_caps)("device/Vendor Name and Version detection using FillGLCaps\n");
1387     strcpy(pIdentifier->Driver, Adapters[Adapter].driver);
1388     strcpy(pIdentifier->Description, Adapters[Adapter].description);
1389
1390     /* Note dx8 doesn't supply a DeviceName */
1391     if (NULL != pIdentifier->DeviceName) strcpy(pIdentifier->DeviceName, "\\\\.\\DISPLAY"); /* FIXME: May depend on desktop? */
1392     /* Current Windows drivers have versions like 6.14.... (some older have an earlier version) */
1393     pIdentifier->DriverVersion->u.HighPart = MAKEDWORD_VERSION(6, 14);
1394     pIdentifier->DriverVersion->u.LowPart = Adapters[Adapter].gl_info.gl_driver_version;
1395     *(pIdentifier->VendorId) = Adapters[Adapter].gl_info.gl_vendor;
1396     *(pIdentifier->DeviceId) = Adapters[Adapter].gl_info.gl_card;
1397     *(pIdentifier->SubSysId) = 0;
1398     *(pIdentifier->Revision) = 0;
1399
1400     /*FIXME: memcpy(&pIdentifier->DeviceIdentifier, ??, sizeof(??GUID)); */
1401     if (Flags & WINED3DENUM_NO_WHQL_LEVEL) {
1402         *(pIdentifier->WHQLLevel) = 0;
1403     } else {
1404         *(pIdentifier->WHQLLevel) = 1;
1405     }
1406
1407     return WINED3D_OK;
1408 }
1409
1410 static BOOL IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(const WineD3D_PixelFormat *cfg, WINED3DFORMAT Format) {
1411     short redSize, greenSize, blueSize, alphaSize, colorBits;
1412
1413     if(!cfg)
1414         return FALSE;
1415
1416     if(!getColorBits(Format, &redSize, &greenSize, &blueSize, &alphaSize, &colorBits)) {
1417         ERR("Unable to check compatibility for Format=%s\n", debug_d3dformat(Format));
1418         return FALSE;
1419     }
1420
1421     if(cfg->redSize < redSize)
1422         return FALSE;
1423
1424     if(cfg->greenSize < greenSize)
1425         return FALSE;
1426
1427     if(cfg->blueSize < blueSize)
1428         return FALSE;
1429
1430     if(cfg->alphaSize < alphaSize)
1431         return FALSE;
1432
1433     return TRUE;
1434 }
1435
1436 static BOOL IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(const WineD3D_PixelFormat *cfg, WINED3DFORMAT Format) {
1437     short depthSize, stencilSize;
1438
1439     if(!cfg)
1440         return FALSE;
1441
1442     if(!getDepthStencilBits(Format, &depthSize, &stencilSize)) {
1443         ERR("Unable to check compatibility for Format=%s\n", debug_d3dformat(Format));
1444         return FALSE;
1445     }
1446
1447     if(cfg->depthSize < depthSize)
1448         return FALSE;
1449
1450     if(cfg->stencilSize < stencilSize)
1451         return FALSE;
1452
1453     return TRUE;
1454 }
1455
1456 static HRESULT WINAPI IWineD3DImpl_CheckDepthStencilMatch(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
1457                                                    WINED3DFORMAT AdapterFormat,
1458                                                    WINED3DFORMAT RenderTargetFormat,
1459                                                    WINED3DFORMAT DepthStencilFormat) {
1460     IWineD3DImpl *This = (IWineD3DImpl *)iface;
1461     int nCfgs;
1462     WineD3D_PixelFormat *cfgs;
1463     int it;
1464
1465     WARN_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, DevType:(%x,%s), AdptFmt:(%x,%s), RendrTgtFmt:(%x,%s), DepthStencilFmt:(%x,%s))\n",
1466            This, Adapter,
1467            DeviceType, debug_d3ddevicetype(DeviceType),
1468            AdapterFormat, debug_d3dformat(AdapterFormat),
1469            RenderTargetFormat, debug_d3dformat(RenderTargetFormat),
1470            DepthStencilFormat, debug_d3dformat(DepthStencilFormat));
1471
1472     if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
1473         TRACE("(%p) Failed: Atapter (%u) higher than supported adapters (%u) returning WINED3DERR_INVALIDCALL\n", This, Adapter, IWineD3D_GetAdapterCount(iface));
1474         return WINED3DERR_INVALIDCALL;
1475     }
1476
1477     cfgs = Adapters[Adapter].cfgs;
1478     nCfgs = Adapters[Adapter].nCfgs;
1479     for (it = 0; it < nCfgs; ++it) {
1480         if (IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&cfgs[it], RenderTargetFormat)) {
1481             if (IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&cfgs[it], DepthStencilFormat)) {
1482                 TRACE_(d3d_caps)("(%p) : Formats matched\n", This);
1483                 return WINED3D_OK;
1484             }
1485         }
1486     }
1487     WARN_(d3d_caps)("unsupported format pair: %s and %s\n", debug_d3dformat(RenderTargetFormat), debug_d3dformat(DepthStencilFormat));
1488
1489     return WINED3DERR_NOTAVAILABLE;
1490 }
1491
1492 static HRESULT WINAPI IWineD3DImpl_CheckDeviceMultiSampleType(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
1493                                                        WINED3DFORMAT SurfaceFormat,
1494                                                        BOOL Windowed, WINED3DMULTISAMPLE_TYPE MultiSampleType, DWORD*   pQualityLevels) {
1495
1496     IWineD3DImpl *This = (IWineD3DImpl *)iface;
1497     TRACE_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, DevType:(%x,%s), SurfFmt:(%x,%s), Win?%d, MultiSamp:%x, pQual:%p)\n",
1498           This,
1499           Adapter,
1500           DeviceType, debug_d3ddevicetype(DeviceType),
1501           SurfaceFormat, debug_d3dformat(SurfaceFormat),
1502           Windowed,
1503           MultiSampleType,
1504           pQualityLevels);
1505
1506     if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
1507         return WINED3DERR_INVALIDCALL;
1508     }
1509
1510     /* TODO: Store in Adapter structure */
1511     if (pQualityLevels != NULL) {
1512         static int s_single_shot = 0;
1513         if (!s_single_shot) {
1514             FIXME("Quality levels unsupported at present\n");
1515             s_single_shot = 1;
1516         }
1517         *pQualityLevels = 1; /* Guess at a value! */
1518     }
1519
1520     if (WINED3DMULTISAMPLE_NONE == MultiSampleType) return WINED3D_OK;
1521     return WINED3DERR_NOTAVAILABLE;
1522 }
1523
1524 static HRESULT WINAPI IWineD3DImpl_CheckDeviceType(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE CheckType,
1525                                             WINED3DFORMAT DisplayFormat, WINED3DFORMAT BackBufferFormat, BOOL Windowed) {
1526
1527     IWineD3DImpl *This = (IWineD3DImpl *)iface;
1528     int nCfgs = 0;
1529     WineD3D_PixelFormat *cfgs;
1530     int it;
1531     HRESULT hr = WINED3DERR_NOTAVAILABLE;
1532
1533     TRACE_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, CheckType:(%x,%s), DispFmt:(%x,%s), BackBuf:(%x,%s), Win?%d): stub\n",
1534           This,
1535           Adapter,
1536           CheckType, debug_d3ddevicetype(CheckType),
1537           DisplayFormat, debug_d3dformat(DisplayFormat),
1538           BackBufferFormat, debug_d3dformat(BackBufferFormat),
1539           Windowed);
1540
1541     if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
1542         WARN_(d3d_caps)("Adapter >= IWineD3D_GetAdapterCount(iface), returning WINED3DERR_INVALIDCALL\n");
1543         return WINED3DERR_INVALIDCALL;
1544     }
1545
1546     cfgs = Adapters[Adapter].cfgs;
1547     nCfgs = Adapters[Adapter].nCfgs;
1548     for (it = 0; it < nCfgs; ++it) {
1549         if (IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&cfgs[it], DisplayFormat)) {
1550             hr = WINED3D_OK;
1551             TRACE_(d3d_caps)("OK\n");
1552             break ;
1553         }
1554     }
1555
1556     if(hr != WINED3D_OK)
1557         ERR("unsupported format %s\n", debug_d3dformat(DisplayFormat));
1558
1559     if(hr != WINED3D_OK)
1560         TRACE_(d3d_caps)("returning something different from WINED3D_OK\n");
1561
1562     return hr;
1563 }
1564
1565 #define GLINFO_LOCATION Adapters[Adapter].gl_info
1566 static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
1567                                               WINED3DFORMAT AdapterFormat, DWORD Usage, WINED3DRESOURCETYPE RType, WINED3DFORMAT CheckFormat) {
1568     IWineD3DImpl *This = (IWineD3DImpl *)iface;
1569     TRACE_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, DevType:(%u,%s), AdptFmt:(%u,%s), Use:(%u,%s,%s), ResTyp:(%x,%s), CheckFmt:(%u,%s))\n",
1570           This,
1571           Adapter,
1572           DeviceType, debug_d3ddevicetype(DeviceType),
1573           AdapterFormat, debug_d3dformat(AdapterFormat),
1574           Usage, debug_d3dusage(Usage), debug_d3dusagequery(Usage),
1575           RType, debug_d3dresourcetype(RType),
1576           CheckFormat, debug_d3dformat(CheckFormat));
1577
1578     if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
1579         return WINED3DERR_INVALIDCALL;
1580     }
1581
1582     if (Usage & WINED3DUSAGE_QUERY_FILTER) {
1583         switch (CheckFormat) {
1584             /* Filtering not supported */
1585             case WINED3DFMT_A32B32G32R32F:
1586                 TRACE_(d3d_caps)("[FAILED]\n");
1587                 return WINED3DERR_NOTAVAILABLE;
1588             default:
1589                 break;
1590         }
1591     }
1592
1593     if (Usage & WINED3DUSAGE_AUTOGENMIPMAP) {
1594         if(!GL_SUPPORT(SGIS_GENERATE_MIPMAP)) {
1595             TRACE_(d3d_caps)("[FAILED] - No mipmap generation support\n");
1596             return WINED3DERR_NOTAVAILABLE;
1597         }
1598     }
1599
1600     if(RType == WINED3DRTYPE_VOLUMETEXTURE) {
1601         if(!GL_SUPPORT(EXT_TEXTURE3D)) {
1602             TRACE_(d3d_caps)("[FAILED] - No volume texture support\n");
1603             return WINED3DERR_NOTAVAILABLE;
1604         }
1605         /* Filter formats that need conversion; For one part, this conversion is unimplemented,
1606          * and volume textures are huge, so it would be a big performance hit. Unless we hit an
1607          * app needing one of those formats, don't advertize them to avoid leading apps into
1608          * temptation. The windows drivers don't support most of those formats on volumes anyway,
1609          * except of R32F.
1610          */
1611         switch(CheckFormat) {
1612             case WINED3DFMT_P8:
1613             case WINED3DFMT_A4L4:
1614             case WINED3DFMT_R32F:
1615             case WINED3DFMT_R16F:
1616             case WINED3DFMT_X8L8V8U8:
1617             case WINED3DFMT_L6V5U5:
1618                 TRACE_(d3d_caps)("[FAILED] - No converted formats on volumes\n");
1619                 return WINED3DERR_NOTAVAILABLE;
1620
1621             case WINED3DFMT_Q8W8V8U8:
1622             case WINED3DFMT_V16U16:
1623             if(!GL_SUPPORT(NV_TEXTURE_SHADER)) {
1624                 TRACE_(d3d_caps)("[FAILED] - No converted formats on volumes\n");
1625                 return WINED3DERR_NOTAVAILABLE;
1626             }
1627             break;
1628
1629             case WINED3DFMT_V8U8:
1630             if(!GL_SUPPORT(NV_TEXTURE_SHADER) || !GL_SUPPORT(ATI_ENVMAP_BUMPMAP)) {
1631                 TRACE_(d3d_caps)("[FAILED] - No converted formats on volumes\n");
1632                 return WINED3DERR_NOTAVAILABLE;
1633             }
1634             break;
1635
1636             case WINED3DFMT_DXT1:
1637             case WINED3DFMT_DXT2:
1638             case WINED3DFMT_DXT3:
1639             case WINED3DFMT_DXT4:
1640             case WINED3DFMT_DXT5:
1641                 /* The GL_EXT_texture_compression_s3tc spec requires that loading an s3tc
1642                  * compressed texture results in an error. While the D3D refrast does
1643                  * support s3tc volumes, at least the nvidia windows driver does not, so
1644                  * we're free not to support this format.
1645                  */
1646                 TRACE_(d3d_caps)("[FAILED] - DXTn does not support 3D textures\n");
1647                 return WINED3DERR_NOTAVAILABLE;
1648
1649             default:
1650                 /* Do nothing, continue with checking the format below */
1651                 break;
1652         }
1653     }
1654     /* TODO: Check support against more of the WINED3DUSAGE_QUERY_* constants
1655      * See http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/IDirect3D9__CheckDeviceFormat.asp
1656      * and http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/D3DUSAGE_QUERY.asp */
1657     if (Usage & WINED3DUSAGE_QUERY_VERTEXTEXTURE) {
1658         if (!GL_LIMITS(vertex_samplers)) {
1659             TRACE_(d3d_caps)("[FAILED]\n");
1660             return WINED3DERR_NOTAVAILABLE;
1661         }
1662
1663         switch (CheckFormat) {
1664             case WINED3DFMT_A32B32G32R32F:
1665                 if (!GL_SUPPORT(ARB_TEXTURE_FLOAT)) {
1666                     TRACE_(d3d_caps)("[FAILED]\n");
1667                     return WINED3DERR_NOTAVAILABLE;
1668                 }
1669                 TRACE_(d3d_caps)("[OK]\n");
1670                 return WINED3D_OK;
1671
1672             default:
1673                 TRACE_(d3d_caps)("[FAILED]\n");
1674                 return WINED3DERR_NOTAVAILABLE;
1675         }
1676     }
1677
1678     if(Usage & WINED3DUSAGE_DEPTHSTENCIL) {
1679         switch (CheckFormat) {
1680             /* In theory we could do all formats, just fetch them accordingly should the buffer be locked.
1681              * Windows supports only those 3, and enumerating the other formats confuses applications
1682              */
1683             case WINED3DFMT_D24S8:
1684             case WINED3DFMT_D24X8:
1685             case WINED3DFMT_D16:
1686                 TRACE_(d3d_caps)("[OK]\n");
1687                 return WINED3D_OK;
1688             case WINED3DFMT_D16_LOCKABLE:
1689             case WINED3DFMT_D24FS8:
1690             case WINED3DFMT_D32F_LOCKABLE:
1691             case WINED3DFMT_D24X4S4:
1692             case WINED3DFMT_D15S1:
1693             case WINED3DFMT_D32:
1694                 TRACE_(d3d_caps)("[FAILED]. Disabled because not enumerated on windows\n");
1695                 return WINED3DERR_NOTAVAILABLE;
1696             default:
1697                 TRACE_(d3d_caps)("[FAILED]\n");
1698                 return WINED3DERR_NOTAVAILABLE;
1699         }
1700     } else if(Usage & WINED3DUSAGE_RENDERTARGET) {
1701         switch (CheckFormat) {
1702             case WINED3DFMT_R8G8B8:
1703             case WINED3DFMT_A8R8G8B8:
1704             case WINED3DFMT_X8R8G8B8:
1705             case WINED3DFMT_R5G6B5:
1706             case WINED3DFMT_X1R5G5B5:
1707             case WINED3DFMT_A1R5G5B5:
1708             case WINED3DFMT_A4R4G4B4:
1709             case WINED3DFMT_R3G3B2:
1710             case WINED3DFMT_X4R4G4B4:
1711             case WINED3DFMT_A8B8G8R8:
1712             case WINED3DFMT_X8B8G8R8:
1713             case WINED3DFMT_P8:
1714                 TRACE_(d3d_caps)("[OK]\n");
1715                 return WINED3D_OK;
1716             case WINED3DFMT_R16F:
1717             case WINED3DFMT_A16B16G16R16F:
1718                 if (!GL_SUPPORT(ARB_HALF_FLOAT_PIXEL) || !GL_SUPPORT(ARB_TEXTURE_FLOAT)) {
1719                     TRACE_(d3d_caps)("[FAILED]\n");
1720                     return WINED3DERR_NOTAVAILABLE;
1721                 }
1722                 TRACE_(d3d_caps)("[OK]\n");
1723                 return WINED3D_OK;
1724             case WINED3DFMT_A32B32G32R32F:
1725                if (!GL_SUPPORT(ARB_TEXTURE_FLOAT)) {
1726                     TRACE_(d3d_caps)("[FAILED]\n");
1727                     return WINED3DERR_NOTAVAILABLE;
1728                 }
1729                 TRACE_(d3d_caps)("[OK]\n");
1730                 return WINED3D_OK;
1731             default:
1732                 TRACE_(d3d_caps)("[FAILED]\n");
1733                 return WINED3DERR_NOTAVAILABLE;
1734         }
1735     } else if(Usage & WINED3DUSAGE_QUERY_LEGACYBUMPMAP) {
1736         if(GL_SUPPORT(NV_REGISTER_COMBINERS) && GL_SUPPORT(NV_TEXTURE_SHADER2)) {
1737             switch (CheckFormat) {
1738                 case WINED3DFMT_V8U8:
1739                     TRACE_(d3d_caps)("[OK]\n");
1740                     return WINED3D_OK;
1741                 /* TODO: Other bump map formats */
1742                 default:
1743                     TRACE_(d3d_caps)("[FAILED]\n");
1744                     return WINED3DERR_NOTAVAILABLE;
1745             }
1746         }
1747         if(GL_SUPPORT(ATI_ENVMAP_BUMPMAP)) {
1748             switch (CheckFormat) {
1749                 case WINED3DFMT_V8U8:
1750                     TRACE_(d3d_caps)("[OK]\n");
1751                     return WINED3D_OK;
1752                 default:
1753                     TRACE_(d3d_caps)("[FAILED]\n");
1754                     return WINED3DERR_NOTAVAILABLE;
1755             }
1756         }
1757         TRACE_(d3d_caps)("[FAILED]\n");
1758         return WINED3DERR_NOTAVAILABLE;
1759     }
1760
1761     if (GL_SUPPORT(EXT_TEXTURE_COMPRESSION_S3TC)) {
1762         switch (CheckFormat) {
1763         case WINED3DFMT_DXT1:
1764         case WINED3DFMT_DXT2:
1765         case WINED3DFMT_DXT3:
1766         case WINED3DFMT_DXT4:
1767         case WINED3DFMT_DXT5:
1768           TRACE_(d3d_caps)("[OK]\n");
1769           return WINED3D_OK;
1770         default:
1771             break; /* Avoid compiler warnings */
1772         }
1773     }
1774
1775     /* Check for supported sRGB formats (Texture loading and framebuffer) */
1776     if (GL_SUPPORT(EXT_TEXTURE_SRGB) && (Usage & WINED3DUSAGE_QUERY_SRGBREAD)) {
1777         switch (CheckFormat) {
1778             case WINED3DFMT_A8R8G8B8:
1779             case WINED3DFMT_X8R8G8B8:
1780             case WINED3DFMT_A4R4G4B4:
1781             case WINED3DFMT_L8:
1782             case WINED3DFMT_A8L8:
1783             case WINED3DFMT_DXT1:
1784             case WINED3DFMT_DXT2:
1785             case WINED3DFMT_DXT3:
1786             case WINED3DFMT_DXT4:
1787             case WINED3DFMT_DXT5:
1788                 TRACE_(d3d_caps)("[OK]\n");
1789                 return WINED3D_OK;
1790
1791             default:
1792                 TRACE_(d3d_caps)("[FAILED] Gamma texture format %s not supported.\n", debug_d3dformat(CheckFormat));
1793                 return WINED3DERR_NOTAVAILABLE;
1794         }
1795     }
1796
1797     if (GL_SUPPORT(ARB_TEXTURE_FLOAT)) {
1798
1799         BOOL half_pixel_support = GL_SUPPORT(ARB_HALF_FLOAT_PIXEL);
1800
1801         switch (CheckFormat) {
1802             case WINED3DFMT_R16F:
1803             case WINED3DFMT_A16B16G16R16F:
1804                 if (!half_pixel_support) break;
1805             case WINED3DFMT_R32F:
1806             case WINED3DFMT_A32B32G32R32F:
1807                 TRACE_(d3d_caps)("[OK]\n");
1808                 return WINED3D_OK;
1809             default:
1810                 break; /* Avoid compiler warnings */
1811         }
1812     }
1813
1814     /* This format is nothing special and it is supported perfectly.
1815      * However, ati and nvidia driver on windows do not mark this format as
1816      * supported (tested with the dxCapsViewer) and pretending to
1817      * support this format uncovers a bug in Battlefield 1942 (fonts are missing)
1818      * So do the same as Windows drivers and pretend not to support it on dx8 and 9
1819      * Enable it on dx7. It will need additional checking on dx10 when we support it.
1820      */
1821     if(This->dxVersion > 7 && CheckFormat == WINED3DFMT_R8G8B8) {
1822         TRACE_(d3d_caps)("[FAILED]\n");
1823         return WINED3DERR_NOTAVAILABLE;
1824     }
1825
1826     switch (CheckFormat) {
1827
1828         /*****
1829          *  supported: RGB(A) formats
1830          */
1831         case WINED3DFMT_R8G8B8: /* Enable for dx7, blacklisted for 8 and 9 above */
1832         case WINED3DFMT_A8R8G8B8:
1833         case WINED3DFMT_X8R8G8B8:
1834         case WINED3DFMT_R5G6B5:
1835         case WINED3DFMT_X1R5G5B5:
1836         case WINED3DFMT_A1R5G5B5:
1837         case WINED3DFMT_A4R4G4B4:
1838         case WINED3DFMT_R3G3B2:
1839         case WINED3DFMT_A8:
1840         case WINED3DFMT_X4R4G4B4:
1841         case WINED3DFMT_A8B8G8R8:
1842         case WINED3DFMT_X8B8G8R8:
1843         case WINED3DFMT_A2R10G10B10:
1844         case WINED3DFMT_A2B10G10R10:
1845             TRACE_(d3d_caps)("[OK]\n");
1846             return WINED3D_OK;
1847
1848         /*****
1849          *  supported: Palettized
1850          */
1851         case WINED3DFMT_P8:
1852             TRACE_(d3d_caps)("[OK]\n");
1853             return WINED3D_OK;
1854
1855         /*****
1856          *  Supported: (Alpha)-Luminance
1857          */
1858         case WINED3DFMT_L8:
1859         case WINED3DFMT_A8L8:
1860         case WINED3DFMT_A4L4:
1861             TRACE_(d3d_caps)("[OK]\n");
1862             return WINED3D_OK;
1863
1864         /*****
1865          *  Not supported everywhere(depends on GL_ATI_envmap_bumpmap or
1866          *  GL_NV_texture_shader), but advertized to make apps happy.
1867          *  Enable some because games often fail when they are not available
1868          *  and are still playable even without bump mapping
1869          */
1870         case WINED3DFMT_V8U8:
1871         case WINED3DFMT_V16U16:
1872         case WINED3DFMT_L6V5U5:
1873         case WINED3DFMT_X8L8V8U8:
1874         case WINED3DFMT_Q8W8V8U8:
1875             WARN_(d3d_caps)("[Not supported, but pretended to do]\n");
1876             return WINED3D_OK;
1877
1878         /* Those are not advertized by the nvidia windows driver, and not
1879          * supported natively by GL_NV_texture_shader or GL_ATI_envmap_bumpmap.
1880          * WINED3DFMT_A2W10V10U10 could be loaded into shaders using the unsigned
1881          * ARGB format if needed
1882          */
1883         case WINED3DFMT_W11V11U10:
1884         case WINED3DFMT_A2W10V10U10:
1885             WARN_(d3d_caps)("[FAILED]\n");
1886             return WINED3DERR_NOTAVAILABLE;
1887
1888         /*****
1889          *  DXTN Formats: Handled above
1890          * WINED3DFMT_DXT1
1891          * WINED3DFMT_DXT2
1892          * WINED3DFMT_DXT3
1893          * WINED3DFMT_DXT4
1894          * WINED3DFMT_DXT5
1895          */
1896
1897         /*****
1898          *  Odd formats - not supported
1899          */
1900         case WINED3DFMT_VERTEXDATA:
1901         case WINED3DFMT_INDEX16:
1902         case WINED3DFMT_INDEX32:
1903         case WINED3DFMT_Q16W16V16U16:
1904             TRACE_(d3d_caps)("[FAILED]\n"); /* Enable when implemented */
1905             return WINED3DERR_NOTAVAILABLE;
1906
1907         /*****
1908          *  Float formats: Not supported right now
1909          */
1910         case WINED3DFMT_G16R16F:
1911         case WINED3DFMT_G32R32F:
1912         case WINED3DFMT_CxV8U8:
1913             TRACE_(d3d_caps)("[FAILED]\n"); /* Enable when implemented */
1914             return WINED3DERR_NOTAVAILABLE;
1915
1916             /* Not supported */
1917         case WINED3DFMT_G16R16:
1918         case WINED3DFMT_A16B16G16R16:
1919         case WINED3DFMT_A8R3G3B2:
1920             TRACE_(d3d_caps)("[FAILED]\n"); /* Enable when implemented */
1921             return WINED3DERR_NOTAVAILABLE;
1922
1923         /* ATI instancing hack: Although ATI cards do not support Shader Model 3.0, they support
1924          * instancing. To query if the card supports instancing CheckDeviceFormat with the special format
1925          * MAKEFOURCC('I','N','S','T') is used. Should a (broken) app check for this provide a proper return value.
1926          * We can do instancing with all shader versions, but we need vertex shaders.
1927          *
1928          * Additionally applications have to set the D3DRS_POINTSIZE render state to MAKEFOURCC('I','N','S','T') once
1929          * to enable instancing. WineD3D doesn't need that and just ignores it.
1930          *
1931          * With Shader Model 3.0 capable cards Instancing 'just works' in Windows.
1932          */
1933         case WINEMAKEFOURCC('I','N','S','T'):
1934             TRACE("ATI Instancing check hack\n");
1935             if(GL_SUPPORT(ARB_VERTEX_PROGRAM) || GL_SUPPORT(ARB_VERTEX_SHADER)) {
1936                 TRACE_(d3d_caps)("[OK]\n");
1937                 return WINED3D_OK;
1938             } else {
1939                 TRACE_(d3d_caps)("[FAILED]\n");
1940                 return WINED3DERR_NOTAVAILABLE;
1941             }
1942
1943         default:
1944             break;
1945     }
1946
1947     TRACE_(d3d_caps)("[FAILED]\n");
1948     return WINED3DERR_NOTAVAILABLE;
1949 }
1950
1951 static HRESULT  WINAPI IWineD3DImpl_CheckDeviceFormatConversion(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
1952                                                           WINED3DFORMAT SourceFormat, WINED3DFORMAT TargetFormat) {
1953     IWineD3DImpl *This = (IWineD3DImpl *)iface;
1954
1955     FIXME_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, DevType:(%u,%s), SrcFmt:(%u,%s), TgtFmt:(%u,%s))\n",
1956           This,
1957           Adapter,
1958           DeviceType, debug_d3ddevicetype(DeviceType),
1959           SourceFormat, debug_d3dformat(SourceFormat),
1960           TargetFormat, debug_d3dformat(TargetFormat));
1961     return WINED3D_OK;
1962 }
1963
1964 /* Note: d3d8 passes in a pointer to a D3DCAPS8 structure, which is a true
1965       subset of a D3DCAPS9 structure. However, it has to come via a void *
1966       as the d3d8 interface cannot import the d3d9 header                  */
1967 static HRESULT WINAPI IWineD3DImpl_GetDeviceCaps(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType, WINED3DCAPS* pCaps) {
1968
1969     IWineD3DImpl    *This = (IWineD3DImpl *)iface;
1970     int vs_selected_mode;
1971     int ps_selected_mode;
1972
1973     TRACE_(d3d_caps)("(%p)->(Adptr:%d, DevType: %x, pCaps: %p)\n", This, Adapter, DeviceType, pCaps);
1974
1975     if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
1976         return WINED3DERR_INVALIDCALL;
1977     }
1978
1979     select_shader_mode(&Adapters[Adapter].gl_info, DeviceType, &ps_selected_mode, &vs_selected_mode);
1980
1981     /* This function should *not* be modifying GL caps
1982      * TODO: move the functionality where it belongs */
1983     select_shader_max_constants(ps_selected_mode, vs_selected_mode, &Adapters[Adapter].gl_info);
1984
1985     /* ------------------------------------------------
1986        The following fields apply to both d3d8 and d3d9
1987        ------------------------------------------------ */
1988     *pCaps->DeviceType              = (DeviceType == WINED3DDEVTYPE_HAL) ? WINED3DDEVTYPE_HAL : WINED3DDEVTYPE_REF;  /* Not quite true, but use h/w supported by opengl I suppose */
1989     *pCaps->AdapterOrdinal          = Adapter;
1990
1991     *pCaps->Caps                    = 0;
1992     *pCaps->Caps2                   = WINED3DCAPS2_CANRENDERWINDOWED |
1993                                       WINED3DCAPS2_FULLSCREENGAMMA |
1994                                       WINED3DCAPS2_DYNAMICTEXTURES;
1995     *pCaps->Caps3                   = WINED3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD;
1996     *pCaps->PresentationIntervals   = WINED3DPRESENT_INTERVAL_IMMEDIATE  |
1997                                       WINED3DPRESENT_INTERVAL_ONE;
1998
1999     *pCaps->CursorCaps              = WINED3DCURSORCAPS_COLOR            |
2000                                       WINED3DCURSORCAPS_LOWRES;
2001
2002     *pCaps->DevCaps                 = WINED3DDEVCAPS_FLOATTLVERTEX       |
2003                                       WINED3DDEVCAPS_EXECUTESYSTEMMEMORY |
2004                                       WINED3DDEVCAPS_TLVERTEXSYSTEMMEMORY|
2005                                       WINED3DDEVCAPS_TLVERTEXVIDEOMEMORY |
2006                                       WINED3DDEVCAPS_DRAWPRIMTLVERTEX    |
2007                                       WINED3DDEVCAPS_HWTRANSFORMANDLIGHT |
2008                                       WINED3DDEVCAPS_EXECUTEVIDEOMEMORY  |
2009                                       WINED3DDEVCAPS_PUREDEVICE          |
2010                                       WINED3DDEVCAPS_HWRASTERIZATION     |
2011                                       WINED3DDEVCAPS_TEXTUREVIDEOMEMORY  |
2012                                       WINED3DDEVCAPS_TEXTURESYSTEMMEMORY |
2013                                       WINED3DDEVCAPS_CANRENDERAFTERFLIP  |
2014                                       WINED3DDEVCAPS_DRAWPRIMITIVES2     |
2015                                       WINED3DDEVCAPS_DRAWPRIMITIVES2EX   |
2016                                       WINED3DDEVCAPS_RTPATCHES;
2017
2018     *pCaps->PrimitiveMiscCaps       = WINED3DPMISCCAPS_CULLNONE              |
2019                                       WINED3DPMISCCAPS_CULLCCW               |
2020                                       WINED3DPMISCCAPS_CULLCW                |
2021                                       WINED3DPMISCCAPS_COLORWRITEENABLE      |
2022                                       WINED3DPMISCCAPS_CLIPTLVERTS           |
2023                                       WINED3DPMISCCAPS_CLIPPLANESCALEDPOINTS |
2024                                       WINED3DPMISCCAPS_MASKZ                 |
2025                                       WINED3DPMISCCAPS_BLENDOP;
2026                                     /* TODO:
2027                                         WINED3DPMISCCAPS_NULLREFERENCE
2028                                         WINED3DPMISCCAPS_INDEPENDENTWRITEMASKS
2029                                         WINED3DPMISCCAPS_FOGANDSPECULARALPHA
2030                                         WINED3DPMISCCAPS_SEPARATEALPHABLEND
2031                                         WINED3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS
2032                                         WINED3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING
2033                                         WINED3DPMISCCAPS_FOGVERTEXCLAMPED */
2034
2035 /* The caps below can be supported but aren't handled yet in utils.c 'd3dta_to_combiner_input', disable them until support is fixed */
2036 #if 0
2037     if (GL_SUPPORT(NV_REGISTER_COMBINERS))
2038         *pCaps->PrimitiveMiscCaps |=  WINED3DPMISCCAPS_TSSARGTEMP;
2039     if (GL_SUPPORT(NV_REGISTER_COMBINERS2))
2040         *pCaps->PrimitiveMiscCaps |=  WINED3DPMISCCAPS_PERSTAGECONSTANT;
2041 #endif
2042
2043     *pCaps->RasterCaps              = WINED3DPRASTERCAPS_DITHER    |
2044                                       WINED3DPRASTERCAPS_PAT       |
2045                                       WINED3DPRASTERCAPS_WFOG      |
2046                                       WINED3DPRASTERCAPS_ZFOG      |
2047                                       WINED3DPRASTERCAPS_FOGVERTEX |
2048                                       WINED3DPRASTERCAPS_FOGTABLE  |
2049                                       WINED3DPRASTERCAPS_STIPPLE   |
2050                                       WINED3DPRASTERCAPS_SUBPIXEL  |
2051                                       WINED3DPRASTERCAPS_ZTEST     |
2052                                       WINED3DPRASTERCAPS_SCISSORTEST   |
2053                                       WINED3DPRASTERCAPS_SLOPESCALEDEPTHBIAS |
2054                                       WINED3DPRASTERCAPS_DEPTHBIAS;
2055
2056     if (GL_SUPPORT(EXT_TEXTURE_FILTER_ANISOTROPIC)) {
2057       *pCaps->RasterCaps |= WINED3DPRASTERCAPS_ANISOTROPY    |
2058                             WINED3DPRASTERCAPS_ZBIAS         |
2059                             WINED3DPRASTERCAPS_MIPMAPLODBIAS;
2060     }
2061     if(GL_SUPPORT(NV_FOG_DISTANCE)) {
2062         *pCaps->RasterCaps         |= WINED3DPRASTERCAPS_FOGRANGE;
2063     }
2064                         /* FIXME Add:
2065                            WINED3DPRASTERCAPS_COLORPERSPECTIVE
2066                            WINED3DPRASTERCAPS_STRETCHBLTMULTISAMPLE
2067                            WINED3DPRASTERCAPS_ANTIALIASEDGES
2068                            WINED3DPRASTERCAPS_ZBUFFERLESSHSR
2069                            WINED3DPRASTERCAPS_WBUFFER */
2070
2071     *pCaps->ZCmpCaps = WINED3DPCMPCAPS_ALWAYS       |
2072                        WINED3DPCMPCAPS_EQUAL        |
2073                        WINED3DPCMPCAPS_GREATER      |
2074                        WINED3DPCMPCAPS_GREATEREQUAL |
2075                        WINED3DPCMPCAPS_LESS         |
2076                        WINED3DPCMPCAPS_LESSEQUAL    |
2077                        WINED3DPCMPCAPS_NEVER        |
2078                        WINED3DPCMPCAPS_NOTEQUAL;
2079
2080     *pCaps->SrcBlendCaps  = WINED3DPBLENDCAPS_BLENDFACTOR     |
2081                             WINED3DPBLENDCAPS_BOTHINVSRCALPHA |
2082                             WINED3DPBLENDCAPS_BOTHSRCALPHA    |
2083                             WINED3DPBLENDCAPS_DESTALPHA       |
2084                             WINED3DPBLENDCAPS_DESTCOLOR       |
2085                             WINED3DPBLENDCAPS_INVDESTALPHA    |
2086                             WINED3DPBLENDCAPS_INVDESTCOLOR    |
2087                             WINED3DPBLENDCAPS_INVSRCALPHA     |
2088                             WINED3DPBLENDCAPS_INVSRCCOLOR     |
2089                             WINED3DPBLENDCAPS_ONE             |
2090                             WINED3DPBLENDCAPS_SRCALPHA        |
2091                             WINED3DPBLENDCAPS_SRCALPHASAT     |
2092                             WINED3DPBLENDCAPS_SRCCOLOR        |
2093                             WINED3DPBLENDCAPS_ZERO;
2094
2095     *pCaps->DestBlendCaps = WINED3DPBLENDCAPS_BLENDFACTOR     |
2096                             WINED3DPBLENDCAPS_DESTALPHA       |
2097                             WINED3DPBLENDCAPS_DESTCOLOR       |
2098                             WINED3DPBLENDCAPS_INVDESTALPHA    |
2099                             WINED3DPBLENDCAPS_INVDESTCOLOR    |
2100                             WINED3DPBLENDCAPS_INVSRCALPHA     |
2101                             WINED3DPBLENDCAPS_INVSRCCOLOR     |
2102                             WINED3DPBLENDCAPS_ONE             |
2103                             WINED3DPBLENDCAPS_SRCALPHA        |
2104                             WINED3DPBLENDCAPS_SRCCOLOR        |
2105                             WINED3DPBLENDCAPS_ZERO;
2106     /* NOTE: WINED3DPBLENDCAPS_SRCALPHASAT is not supported as dest blend factor,
2107      * according to the glBlendFunc manpage
2108      *
2109      * WINED3DPBLENDCAPS_BOTHINVSRCALPHA and WINED3DPBLENDCAPS_BOTHSRCALPHA are
2110      * legacy settings for srcblend only
2111      */
2112
2113     *pCaps->AlphaCmpCaps = WINED3DPCMPCAPS_ALWAYS       |
2114                            WINED3DPCMPCAPS_EQUAL        |
2115                            WINED3DPCMPCAPS_GREATER      |
2116                            WINED3DPCMPCAPS_GREATEREQUAL |
2117                            WINED3DPCMPCAPS_LESS         |
2118                            WINED3DPCMPCAPS_LESSEQUAL    |
2119                            WINED3DPCMPCAPS_NEVER        |
2120                            WINED3DPCMPCAPS_NOTEQUAL;
2121
2122     *pCaps->ShadeCaps     = WINED3DPSHADECAPS_SPECULARGOURAUDRGB |
2123                             WINED3DPSHADECAPS_COLORGOURAUDRGB    |
2124                             WINED3DPSHADECAPS_ALPHAFLATBLEND     |
2125                             WINED3DPSHADECAPS_ALPHAGOURAUDBLEND  |
2126                             WINED3DPSHADECAPS_COLORFLATRGB       |
2127                             WINED3DPSHADECAPS_FOGFLAT            |
2128                             WINED3DPSHADECAPS_FOGGOURAUD         |
2129                             WINED3DPSHADECAPS_SPECULARFLATRGB;
2130
2131     *pCaps->TextureCaps =  WINED3DPTEXTURECAPS_ALPHA              |
2132                            WINED3DPTEXTURECAPS_ALPHAPALETTE       |
2133                            WINED3DPTEXTURECAPS_BORDER             |
2134                            WINED3DPTEXTURECAPS_MIPMAP             |
2135                            WINED3DPTEXTURECAPS_PROJECTED          |
2136                            WINED3DPTEXTURECAPS_PERSPECTIVE;
2137
2138     if( !GL_SUPPORT(ARB_TEXTURE_NON_POWER_OF_TWO)) {
2139         *pCaps->TextureCaps |= WINED3DPTEXTURECAPS_POW2 |
2140                                 WINED3DPTEXTURECAPS_NONPOW2CONDITIONAL;
2141     }
2142
2143     if( GL_SUPPORT(EXT_TEXTURE3D)) {
2144         *pCaps->TextureCaps |=  WINED3DPTEXTURECAPS_VOLUMEMAP      |
2145                                 WINED3DPTEXTURECAPS_MIPVOLUMEMAP   |
2146                                 WINED3DPTEXTURECAPS_VOLUMEMAP_POW2;
2147     }
2148
2149     if (GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
2150         *pCaps->TextureCaps |= WINED3DPTEXTURECAPS_CUBEMAP     |
2151                              WINED3DPTEXTURECAPS_MIPCUBEMAP    |
2152                              WINED3DPTEXTURECAPS_CUBEMAP_POW2;
2153
2154     }
2155
2156     *pCaps->TextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR       |
2157                                 WINED3DPTFILTERCAPS_MAGFPOINT        |
2158                                 WINED3DPTFILTERCAPS_MINFLINEAR       |
2159                                 WINED3DPTFILTERCAPS_MINFPOINT        |
2160                                 WINED3DPTFILTERCAPS_MIPFLINEAR       |
2161                                 WINED3DPTFILTERCAPS_MIPFPOINT        |
2162                                 WINED3DPTFILTERCAPS_LINEAR           |
2163                                 WINED3DPTFILTERCAPS_LINEARMIPLINEAR  |
2164                                 WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
2165                                 WINED3DPTFILTERCAPS_MIPLINEAR        |
2166                                 WINED3DPTFILTERCAPS_MIPNEAREST       |
2167                                 WINED3DPTFILTERCAPS_NEAREST;
2168
2169     if (GL_SUPPORT(EXT_TEXTURE_FILTER_ANISOTROPIC)) {
2170         *pCaps->TextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC |
2171                                      WINED3DPTFILTERCAPS_MINFANISOTROPIC;
2172     }
2173
2174     if (GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
2175         *pCaps->CubeTextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR       |
2176                                         WINED3DPTFILTERCAPS_MAGFPOINT        |
2177                                         WINED3DPTFILTERCAPS_MINFLINEAR       |
2178                                         WINED3DPTFILTERCAPS_MINFPOINT        |
2179                                         WINED3DPTFILTERCAPS_MIPFLINEAR       |
2180                                         WINED3DPTFILTERCAPS_MIPFPOINT        |
2181                                         WINED3DPTFILTERCAPS_LINEAR           |
2182                                         WINED3DPTFILTERCAPS_LINEARMIPLINEAR  |
2183                                         WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
2184                                         WINED3DPTFILTERCAPS_MIPLINEAR        |
2185                                         WINED3DPTFILTERCAPS_MIPNEAREST       |
2186                                         WINED3DPTFILTERCAPS_NEAREST;
2187
2188         if (GL_SUPPORT(EXT_TEXTURE_FILTER_ANISOTROPIC)) {
2189             *pCaps->CubeTextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC |
2190                                             WINED3DPTFILTERCAPS_MINFANISOTROPIC;
2191         }
2192     } else
2193         *pCaps->CubeTextureFilterCaps = 0;
2194
2195     if (GL_SUPPORT(EXT_TEXTURE3D)) {
2196         *pCaps->VolumeTextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR       |
2197                                           WINED3DPTFILTERCAPS_MAGFPOINT        |
2198                                           WINED3DPTFILTERCAPS_MINFLINEAR       |
2199                                           WINED3DPTFILTERCAPS_MINFPOINT        |
2200                                           WINED3DPTFILTERCAPS_MIPFLINEAR       |
2201                                           WINED3DPTFILTERCAPS_MIPFPOINT        |
2202                                           WINED3DPTFILTERCAPS_LINEAR           |
2203                                           WINED3DPTFILTERCAPS_LINEARMIPLINEAR  |
2204                                           WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
2205                                           WINED3DPTFILTERCAPS_MIPLINEAR        |
2206                                           WINED3DPTFILTERCAPS_MIPNEAREST       |
2207                                           WINED3DPTFILTERCAPS_NEAREST;
2208     } else
2209         *pCaps->VolumeTextureFilterCaps = 0;
2210
2211     *pCaps->TextureAddressCaps =  WINED3DPTADDRESSCAPS_INDEPENDENTUV |
2212                                   WINED3DPTADDRESSCAPS_CLAMP  |
2213                                   WINED3DPTADDRESSCAPS_WRAP;
2214
2215     if (GL_SUPPORT(ARB_TEXTURE_BORDER_CLAMP)) {
2216         *pCaps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_BORDER;
2217     }
2218     if (GL_SUPPORT(ARB_TEXTURE_MIRRORED_REPEAT)) {
2219         *pCaps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRROR;
2220     }
2221     if (GL_SUPPORT(ATI_TEXTURE_MIRROR_ONCE)) {
2222         *pCaps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRRORONCE;
2223     }
2224
2225     if (GL_SUPPORT(EXT_TEXTURE3D)) {
2226         *pCaps->VolumeTextureAddressCaps =  WINED3DPTADDRESSCAPS_INDEPENDENTUV |
2227                                             WINED3DPTADDRESSCAPS_CLAMP  |
2228                                             WINED3DPTADDRESSCAPS_WRAP;
2229         if (GL_SUPPORT(ARB_TEXTURE_BORDER_CLAMP)) {
2230             *pCaps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_BORDER;
2231         }
2232         if (GL_SUPPORT(ARB_TEXTURE_MIRRORED_REPEAT)) {
2233             *pCaps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRROR;
2234         }
2235         if (GL_SUPPORT(ATI_TEXTURE_MIRROR_ONCE)) {
2236             *pCaps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRRORONCE;
2237         }
2238     } else
2239         *pCaps->VolumeTextureAddressCaps = 0;
2240
2241     *pCaps->LineCaps = WINED3DLINECAPS_TEXTURE |
2242                        WINED3DLINECAPS_ZTEST;
2243                       /* FIXME: Add
2244                         WINED3DLINECAPS_BLEND
2245                         WINED3DLINECAPS_ALPHACMP
2246                         WINED3DLINECAPS_FOG */
2247
2248     *pCaps->MaxTextureWidth  = GL_LIMITS(texture_size);
2249     *pCaps->MaxTextureHeight = GL_LIMITS(texture_size);
2250
2251     if(GL_SUPPORT(EXT_TEXTURE3D))
2252         *pCaps->MaxVolumeExtent = GL_LIMITS(texture3d_size);
2253     else
2254         *pCaps->MaxVolumeExtent = 0;
2255
2256     *pCaps->MaxTextureRepeat = 32768;
2257     *pCaps->MaxTextureAspectRatio = GL_LIMITS(texture_size);
2258     *pCaps->MaxVertexW = 1.0;
2259
2260     *pCaps->GuardBandLeft = 0;
2261     *pCaps->GuardBandTop = 0;
2262     *pCaps->GuardBandRight = 0;
2263     *pCaps->GuardBandBottom = 0;
2264
2265     *pCaps->ExtentsAdjust = 0;
2266
2267     *pCaps->StencilCaps =  WINED3DSTENCILCAPS_DECRSAT |
2268                            WINED3DSTENCILCAPS_INCRSAT |
2269                            WINED3DSTENCILCAPS_INVERT  |
2270                            WINED3DSTENCILCAPS_KEEP    |
2271                            WINED3DSTENCILCAPS_REPLACE |
2272                            WINED3DSTENCILCAPS_ZERO;
2273     if (GL_SUPPORT(EXT_STENCIL_WRAP)) {
2274       *pCaps->StencilCaps |= WINED3DSTENCILCAPS_DECR  |
2275                              WINED3DSTENCILCAPS_INCR;
2276     }
2277     if ( This->dxVersion > 8 &&
2278         ( GL_SUPPORT(EXT_STENCIL_TWO_SIDE) ||
2279             GL_SUPPORT(ATI_SEPARATE_STENCIL) ) ) {
2280         *pCaps->StencilCaps |= WINED3DSTENCILCAPS_TWOSIDED;
2281     }
2282
2283     *pCaps->FVFCaps = WINED3DFVFCAPS_PSIZE | 0x0008; /* 8 texture coords */
2284
2285     *pCaps->TextureOpCaps =  WINED3DTEXOPCAPS_ADD         |
2286                              WINED3DTEXOPCAPS_ADDSIGNED   |
2287                              WINED3DTEXOPCAPS_ADDSIGNED2X |
2288                              WINED3DTEXOPCAPS_MODULATE    |
2289                              WINED3DTEXOPCAPS_MODULATE2X  |
2290                              WINED3DTEXOPCAPS_MODULATE4X  |
2291                              WINED3DTEXOPCAPS_SELECTARG1  |
2292                              WINED3DTEXOPCAPS_SELECTARG2  |
2293                              WINED3DTEXOPCAPS_DISABLE;
2294
2295     if (GL_SUPPORT(ARB_TEXTURE_ENV_COMBINE) ||
2296         GL_SUPPORT(EXT_TEXTURE_ENV_COMBINE) ||
2297         GL_SUPPORT(NV_TEXTURE_ENV_COMBINE4)) {
2298         *pCaps->TextureOpCaps |= WINED3DTEXOPCAPS_BLENDDIFFUSEALPHA |
2299                                 WINED3DTEXOPCAPS_BLENDTEXTUREALPHA  |
2300                                 WINED3DTEXOPCAPS_BLENDFACTORALPHA   |
2301                                 WINED3DTEXOPCAPS_BLENDCURRENTALPHA  |
2302                                 WINED3DTEXOPCAPS_LERP               |
2303                                 WINED3DTEXOPCAPS_SUBTRACT;
2304     }
2305     if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3) ||
2306          GL_SUPPORT(NV_TEXTURE_ENV_COMBINE4)) {
2307         *pCaps->TextureOpCaps |= WINED3DTEXOPCAPS_ADDSMOOTH             |
2308                                 WINED3DTEXOPCAPS_MULTIPLYADD            |
2309                                 WINED3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR |
2310                                 WINED3DTEXOPCAPS_MODULATECOLOR_ADDALPHA |
2311                                 WINED3DTEXOPCAPS_BLENDTEXTUREALPHAPM;
2312     }
2313     if (GL_SUPPORT(ARB_TEXTURE_ENV_DOT3))
2314         *pCaps->TextureOpCaps |= WINED3DTEXOPCAPS_DOTPRODUCT3;
2315
2316     if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
2317         *pCaps->TextureOpCaps |= WINED3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR |
2318                                  WINED3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA;
2319     }
2320
2321     if(GL_SUPPORT(ATI_ENVMAP_BUMPMAP)) {
2322         *pCaps->TextureOpCaps |= WINED3DTEXOPCAPS_BUMPENVMAP;
2323     } else if(GL_SUPPORT(NV_TEXTURE_SHADER2)) {
2324         /* Bump mapping is supported already in NV_TEXTURE_SHADER, but that extension does
2325          * not support 3D textures. This asks for trouble if an app uses both bump mapping
2326          * and 3D textures. It also allows us to keep the code simpler by having texture
2327          * shaders constantly enabled.
2328          */
2329         *pCaps->TextureOpCaps |= WINED3DTEXOPCAPS_BUMPENVMAP;
2330         /* TODO: Luminance bump map? */
2331     }
2332 #if 0
2333     /* FIXME: Add
2334     *pCaps->TextureOpCaps |= WINED3DTEXOPCAPS_BUMPENVMAPLUMINANCE
2335                              WINED3DTEXOPCAPS_PREMODULATE */
2336 #endif
2337
2338     *pCaps->MaxTextureBlendStages   = GL_LIMITS(texture_stages);
2339     *pCaps->MaxSimultaneousTextures = GL_LIMITS(textures);
2340     *pCaps->MaxUserClipPlanes       = GL_LIMITS(clipplanes);
2341     *pCaps->MaxActiveLights         = GL_LIMITS(lights);
2342
2343     *pCaps->MaxVertexBlendMatrices      = GL_LIMITS(blends);
2344     *pCaps->MaxVertexBlendMatrixIndex   = 0;
2345
2346     *pCaps->MaxAnisotropy   = GL_LIMITS(anisotropy);
2347     *pCaps->MaxPointSize    = GL_LIMITS(pointsize);
2348
2349
2350     *pCaps->VertexProcessingCaps = WINED3DVTXPCAPS_DIRECTIONALLIGHTS |
2351                                    WINED3DVTXPCAPS_MATERIALSOURCE7   |
2352                                    WINED3DVTXPCAPS_POSITIONALLIGHTS  |
2353                                    WINED3DVTXPCAPS_LOCALVIEWER       |
2354                                    WINED3DVTXPCAPS_VERTEXFOG         |
2355                                    WINED3DVTXPCAPS_TEXGEN;
2356                                   /* FIXME: Add
2357                                      D3DVTXPCAPS_TWEENING, D3DVTXPCAPS_TEXGEN_SPHEREMAP */
2358
2359     *pCaps->MaxPrimitiveCount   = 0xFFFFF; /* For now set 2^20-1 which is used by most >=Geforce3/Radeon8500 cards */
2360     *pCaps->MaxVertexIndex      = 0xFFFFF;
2361     *pCaps->MaxStreams          = MAX_STREAMS;
2362     *pCaps->MaxStreamStride     = 1024;
2363
2364     if (vs_selected_mode == SHADER_GLSL) {
2365         /* Nvidia Geforce6/7 or Ati R4xx/R5xx cards with GLSL support, support VS 3.0 but older Nvidia/Ati
2366            models with GLSL support only support 2.0. In case of nvidia we can detect VS 2.0 support using
2367            vs_nv_version which is based on NV_vertex_program. For Ati cards there's no easy way, so for
2368            now only support 2.0/3.0 detection on Nvidia GeforceFX cards and default to 3.0 for everything else */
2369         if(GLINFO_LOCATION.vs_nv_version == VS_VERSION_20)
2370             *pCaps->VertexShaderVersion = WINED3DVS_VERSION(2,0);
2371         else
2372             *pCaps->VertexShaderVersion = WINED3DVS_VERSION(3,0);
2373         TRACE_(d3d_caps)("Hardware vertex shader version 3.0 enabled (GLSL)\n");
2374     } else if (vs_selected_mode == SHADER_ARB) {
2375         *pCaps->VertexShaderVersion = WINED3DVS_VERSION(1,1);
2376         TRACE_(d3d_caps)("Hardware vertex shader version 1.1 enabled (ARB_PROGRAM)\n");
2377     } else {
2378         *pCaps->VertexShaderVersion  = 0;
2379         TRACE_(d3d_caps)("Vertex shader functionality not available\n");
2380     }
2381
2382     *pCaps->MaxVertexShaderConst = GL_LIMITS(vshader_constantsF);
2383
2384     if (ps_selected_mode == SHADER_GLSL) {
2385         /* See the comment about VS2.0/VS3.0 detection as we do the same here but then based on NV_fragment_program
2386            in case of GeforceFX cards. */
2387         if(GLINFO_LOCATION.ps_nv_version == PS_VERSION_20)
2388             *pCaps->PixelShaderVersion = WINED3DPS_VERSION(2,0);
2389         else
2390             *pCaps->PixelShaderVersion = WINED3DPS_VERSION(3,0);
2391         /* FIXME: The following line is card dependent. -8.0 to 8.0 is the
2392          * Direct3D minimum requirement.
2393          *
2394          * Both GL_ARB_fragment_program and GLSL require a "maximum representable magnitude"
2395          * of colors to be 2^10, and 2^32 for other floats. Should we use 1024 here?
2396          *
2397          * The problem is that the refrast clamps temporary results in the shader to
2398          * [-MaxValue;+MaxValue]. If the card's max value is bigger than the one we advertize here,
2399          * then applications may miss the clamping behavior. On the other hand, if it is smaller,
2400          * the shader will generate incorrect results too. Unfortunately, GL deliberately doesn't
2401          * offer a way to query this.
2402          */
2403         *pCaps->PixelShader1xMaxValue = 8.0;
2404         TRACE_(d3d_caps)("Hardware pixel shader version 3.0 enabled (GLSL)\n");
2405     } else if (ps_selected_mode == SHADER_ARB) {
2406         *pCaps->PixelShaderVersion    = WINED3DPS_VERSION(1,4);
2407         *pCaps->PixelShader1xMaxValue = 8.0;
2408         TRACE_(d3d_caps)("Hardware pixel shader version 1.4 enabled (ARB_PROGRAM)\n");
2409     } else {
2410         *pCaps->PixelShaderVersion    = 0;
2411         *pCaps->PixelShader1xMaxValue = 0.0;
2412         TRACE_(d3d_caps)("Pixel shader functionality not available\n");
2413     }
2414
2415     /* ------------------------------------------------
2416        The following fields apply to d3d9 only
2417        ------------------------------------------------ */
2418     if (This->dxVersion > 8) {
2419         /* d3d9.dll sets D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES here because StretchRects is implemented in d3d9 */
2420         *pCaps->DevCaps2                          = WINED3DDEVCAPS2_STREAMOFFSET;
2421         /* TODO: VS3.0 needs at least D3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET */
2422         *pCaps->MaxNpatchTessellationLevel        = 0;
2423         *pCaps->MasterAdapterOrdinal              = 0;
2424         *pCaps->AdapterOrdinalInGroup             = 0;
2425         *pCaps->NumberOfAdaptersInGroup           = 1;
2426
2427         if(*pCaps->VertexShaderVersion >= WINED3DVS_VERSION(2,0)) {
2428             /* OpenGL supports all the formats below, perhaps not always
2429              * without conversion, but it supports them.
2430              * Further GLSL doesn't seem to have an official unsigned type so
2431              * don't advertise it yet as I'm not sure how we handle it.
2432              * We might need to add some clamping in the shader engine to
2433              * support it.
2434              * TODO: WINED3DDTCAPS_USHORT2N, WINED3DDTCAPS_USHORT4N, WINED3DDTCAPS_UDEC3, WINED3DDTCAPS_DEC3N */
2435             *pCaps->DeclTypes = WINED3DDTCAPS_UBYTE4    |
2436                                 WINED3DDTCAPS_UBYTE4N   |
2437                                 WINED3DDTCAPS_SHORT2N   |
2438                                 WINED3DDTCAPS_SHORT4N;
2439             if (GL_SUPPORT(NV_HALF_FLOAT)) {
2440                 *pCaps->DeclTypes |=
2441                                 WINED3DDTCAPS_FLOAT16_2 |
2442                                 WINED3DDTCAPS_FLOAT16_4;
2443             }
2444         } else
2445             *pCaps->DeclTypes                         = 0;
2446
2447         *pCaps->NumSimultaneousRTs = GL_LIMITS(buffers);
2448
2449
2450         *pCaps->StretchRectFilterCaps             = WINED3DPTFILTERCAPS_MINFPOINT  |
2451                                                     WINED3DPTFILTERCAPS_MAGFPOINT  |
2452                                                     WINED3DPTFILTERCAPS_MINFLINEAR |
2453                                                     WINED3DPTFILTERCAPS_MAGFLINEAR;
2454         *pCaps->VertexTextureFilterCaps           = 0;
2455
2456         if(*pCaps->VertexShaderVersion == WINED3DVS_VERSION(3,0)) {
2457             /* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering)
2458                use the VS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum VS3.0 value. */
2459             *pCaps->VS20Caps.Caps                     = WINED3DVS20CAPS_PREDICATION;
2460             *pCaps->VS20Caps.DynamicFlowControlDepth  = WINED3DVS20_MAX_DYNAMICFLOWCONTROLDEPTH; /* VS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
2461             *pCaps->VS20Caps.NumTemps                 = max(32, GLINFO_LOCATION.vs_arb_max_temps);
2462             *pCaps->VS20Caps.StaticFlowControlDepth   = WINED3DVS20_MAX_STATICFLOWCONTROLDEPTH ; /* level of nesting in loops / if-statements; VS 3.0 requires MAX (4) */
2463
2464             *pCaps->MaxVShaderInstructionsExecuted    = 65535; /* VS 3.0 needs at least 65535, some cards even use 2^32-1 */
2465             *pCaps->MaxVertexShader30InstructionSlots = max(512, GLINFO_LOCATION.vs_arb_max_instructions);
2466         } else if(*pCaps->VertexShaderVersion == WINED3DVS_VERSION(2,0)) {
2467             *pCaps->VS20Caps.Caps                     = 0;
2468             *pCaps->VS20Caps.DynamicFlowControlDepth  = WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH;
2469             *pCaps->VS20Caps.NumTemps                 = max(12, GLINFO_LOCATION.vs_arb_max_temps);
2470             *pCaps->VS20Caps.StaticFlowControlDepth   = 1;
2471
2472             *pCaps->MaxVShaderInstructionsExecuted    = 65535;
2473             *pCaps->MaxVertexShader30InstructionSlots = 0;
2474         } else { /* VS 1.x */
2475             *pCaps->VS20Caps.Caps                     = 0;
2476             *pCaps->VS20Caps.DynamicFlowControlDepth  = 0;
2477             *pCaps->VS20Caps.NumTemps                 = 0;
2478             *pCaps->VS20Caps.StaticFlowControlDepth   = 0;
2479
2480             *pCaps->MaxVShaderInstructionsExecuted    = 0;
2481             *pCaps->MaxVertexShader30InstructionSlots = 0;
2482         }
2483
2484         if(*pCaps->PixelShaderVersion == WINED3DPS_VERSION(3,0)) {
2485             /* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering)
2486                use the PS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum PS 3.0 value. */
2487
2488             /* 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 */
2489             *pCaps->PS20Caps.Caps                     = WINED3DPS20CAPS_ARBITRARYSWIZZLE     |
2490                                                         WINED3DPS20CAPS_GRADIENTINSTRUCTIONS |
2491                                                         WINED3DPS20CAPS_PREDICATION          |
2492                                                         WINED3DPS20CAPS_NODEPENDENTREADLIMIT |
2493                                                         WINED3DPS20CAPS_NOTEXINSTRUCTIONLIMIT;
2494             *pCaps->PS20Caps.DynamicFlowControlDepth  = WINED3DPS20_MAX_DYNAMICFLOWCONTROLDEPTH; /* PS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
2495             *pCaps->PS20Caps.NumTemps                 = max(32, GLINFO_LOCATION.ps_arb_max_temps);
2496             *pCaps->PS20Caps.StaticFlowControlDepth   = WINED3DPS20_MAX_STATICFLOWCONTROLDEPTH; /* PS 3.0 requires MAX_STATICFLOWCONTROLDEPTH (4) */
2497             *pCaps->PS20Caps.NumInstructionSlots      = WINED3DPS20_MAX_NUMINSTRUCTIONSLOTS; /* PS 3.0 requires MAX_NUMINSTRUCTIONSLOTS (512) */
2498
2499             *pCaps->MaxPShaderInstructionsExecuted    = 65535;
2500             *pCaps->MaxPixelShader30InstructionSlots  = max(WINED3DMIN30SHADERINSTRUCTIONS, GLINFO_LOCATION.ps_arb_max_instructions);
2501         } else if(*pCaps->PixelShaderVersion == WINED3DPS_VERSION(2,0)) {
2502             /* Below we assume PS2.0 specs, not extended 2.0a(GeforceFX)/2.0b(Radeon R3xx) ones */
2503             *pCaps->PS20Caps.Caps                     = 0;
2504             *pCaps->PS20Caps.DynamicFlowControlDepth  = 0; /* WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH = 0 */
2505             *pCaps->PS20Caps.NumTemps                 = max(12, GLINFO_LOCATION.ps_arb_max_temps);
2506             *pCaps->PS20Caps.StaticFlowControlDepth   = WINED3DPS20_MIN_STATICFLOWCONTROLDEPTH; /* Minumum: 1 */
2507             *pCaps->PS20Caps.NumInstructionSlots      = WINED3DPS20_MIN_NUMINSTRUCTIONSLOTS; /* Minimum number (64 ALU + 32 Texture), a GeforceFX uses 512 */
2508
2509             *pCaps->MaxPShaderInstructionsExecuted    = 512; /* Minimum value, a GeforceFX uses 1024 */
2510             *pCaps->MaxPixelShader30InstructionSlots  = 0;
2511         } else { /* PS 1.x */
2512             *pCaps->PS20Caps.Caps                     = 0;
2513             *pCaps->PS20Caps.DynamicFlowControlDepth  = 0;
2514             *pCaps->PS20Caps.NumTemps                 = 0;
2515             *pCaps->PS20Caps.StaticFlowControlDepth   = 0;
2516             *pCaps->PS20Caps.NumInstructionSlots      = 0;
2517
2518             *pCaps->MaxPShaderInstructionsExecuted    = 0;
2519             *pCaps->MaxPixelShader30InstructionSlots  = 0;
2520         }
2521     }
2522
2523     return WINED3D_OK;
2524 }
2525
2526 static unsigned int glsl_program_key_hash(void *key) {
2527     glsl_program_key_t *k = (glsl_program_key_t *)key;
2528
2529     unsigned int hash = k->vshader | k->pshader << 16;
2530     hash += ~(hash << 15);
2531     hash ^=  (hash >> 10);
2532     hash +=  (hash << 3);
2533     hash ^=  (hash >> 6);
2534     hash += ~(hash << 11);
2535     hash ^=  (hash >> 16);
2536
2537     return hash;
2538 }
2539
2540 static BOOL glsl_program_key_compare(void *keya, void *keyb) {
2541     glsl_program_key_t *ka = (glsl_program_key_t *)keya;
2542     glsl_program_key_t *kb = (glsl_program_key_t *)keyb;
2543
2544     return ka->vshader == kb->vshader && ka->pshader == kb->pshader;
2545 }
2546
2547 /* Note due to structure differences between dx8 and dx9 D3DPRESENT_PARAMETERS,
2548    and fields being inserted in the middle, a new structure is used in place    */
2549 static HRESULT  WINAPI IWineD3DImpl_CreateDevice(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType, HWND hFocusWindow,
2550                                            DWORD BehaviourFlags, IWineD3DDevice** ppReturnedDeviceInterface,
2551                                            IUnknown *parent) {
2552
2553     IWineD3DDeviceImpl *object  = NULL;
2554     IWineD3DImpl       *This    = (IWineD3DImpl *)iface;
2555     HDC hDC;
2556     int i;
2557
2558     /* Validate the adapter number. If no adapters are available(no GL), ignore the adapter
2559      * number and create a device without a 3D adapter for 2D only operation.
2560      */
2561     if (IWineD3D_GetAdapterCount(iface) && Adapter >= IWineD3D_GetAdapterCount(iface)) {
2562         return WINED3DERR_INVALIDCALL;
2563     }
2564
2565     /* Create a WineD3DDevice object */
2566     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IWineD3DDeviceImpl));
2567     *ppReturnedDeviceInterface = (IWineD3DDevice *)object;
2568     TRACE("Created WineD3DDevice object @ %p\n", object);
2569     if (NULL == object) {
2570       return WINED3DERR_OUTOFVIDEOMEMORY;
2571     }
2572
2573     /* Set up initial COM information */
2574     object->lpVtbl  = &IWineD3DDevice_Vtbl;
2575     object->ref     = 1;
2576     object->wineD3D = iface;
2577     object->adapter = numAdapters ? &Adapters[Adapter] : NULL;
2578     IWineD3D_AddRef(object->wineD3D);
2579     object->parent  = parent;
2580
2581     if(This->dxVersion == 7) {
2582         object->surface_alignment = 8;
2583     } else {
2584         object->surface_alignment = 4;
2585     }
2586
2587     /* Set the state up as invalid until the device is fully created */
2588     object->state   = WINED3DERR_DRIVERINTERNALERROR;
2589
2590     TRACE("(%p)->(Adptr:%d, DevType: %x, FocusHwnd: %p, BehFlags: %x, RetDevInt: %p)\n", This, Adapter, DeviceType,
2591           hFocusWindow, BehaviourFlags, ppReturnedDeviceInterface);
2592
2593     /* Save the creation parameters */
2594     object->createParms.AdapterOrdinal = Adapter;
2595     object->createParms.DeviceType     = DeviceType;
2596     object->createParms.hFocusWindow   = hFocusWindow;
2597     object->createParms.BehaviorFlags  = BehaviourFlags;
2598
2599     /* Initialize other useful values */
2600     object->adapterNo                    = Adapter;
2601     object->devType                      = DeviceType;
2602
2603     select_shader_mode(&GLINFO_LOCATION, DeviceType, &object->ps_selected_mode, &object->vs_selected_mode);
2604     if (object->ps_selected_mode == SHADER_GLSL || object->vs_selected_mode == SHADER_GLSL) {
2605         object->shader_backend = &glsl_shader_backend;
2606         object->glsl_program_lookup = hash_table_create(&glsl_program_key_hash, &glsl_program_key_compare);
2607     } else if (object->ps_selected_mode == SHADER_ARB || object->vs_selected_mode == SHADER_ARB) {
2608         object->shader_backend = &arb_program_shader_backend;
2609     } else {
2610         object->shader_backend = &none_shader_backend;
2611     }
2612
2613     /* set the state of the device to valid */
2614     object->state = WINED3D_OK;
2615
2616     /* Get the initial screen setup for ddraw */
2617     object->ddraw_width = GetSystemMetrics(SM_CXSCREEN);
2618     object->ddraw_height = GetSystemMetrics(SM_CYSCREEN);
2619     hDC = GetDC(0);
2620     object->ddraw_format = pixelformat_for_depth(GetDeviceCaps(hDC, BITSPIXEL) * GetDeviceCaps(hDC, PLANES));
2621     ReleaseDC(0, hDC);
2622
2623     for(i = 0; i < PATCHMAP_SIZE; i++) {
2624         list_init(&object->patches[i]);
2625     }
2626     return WINED3D_OK;
2627 }
2628 #undef GLINFO_LOCATION
2629
2630 static HRESULT WINAPI IWineD3DImpl_GetParent(IWineD3D *iface, IUnknown **pParent) {
2631     IWineD3DImpl *This = (IWineD3DImpl *)iface;
2632     IUnknown_AddRef(This->parent);
2633     *pParent = This->parent;
2634     return WINED3D_OK;
2635 }
2636
2637 ULONG WINAPI D3DCB_DefaultDestroySurface(IWineD3DSurface *pSurface) {
2638     IUnknown* surfaceParent;
2639     TRACE("(%p) call back\n", pSurface);
2640
2641     /* Now, release the parent, which will take care of cleaning up the surface for us */
2642     IWineD3DSurface_GetParent(pSurface, &surfaceParent);
2643     IUnknown_Release(surfaceParent);
2644     return IUnknown_Release(surfaceParent);
2645 }
2646
2647 ULONG WINAPI D3DCB_DefaultDestroyVolume(IWineD3DVolume *pVolume) {
2648     IUnknown* volumeParent;
2649     TRACE("(%p) call back\n", pVolume);
2650
2651     /* Now, release the parent, which will take care of cleaning up the volume for us */
2652     IWineD3DVolume_GetParent(pVolume, &volumeParent);
2653     IUnknown_Release(volumeParent);
2654     return IUnknown_Release(volumeParent);
2655 }
2656
2657 #define PUSH1(att)        attribs[nAttribs++] = (att);
2658 #define GLINFO_LOCATION (Adapters[0].gl_info)
2659 BOOL InitAdapters(void) {
2660     static HMODULE mod_gl;
2661     BOOL ret;
2662     int ps_selected_mode, vs_selected_mode;
2663
2664     /* No need to hold any lock. The calling library makes sure only one thread calls
2665      * wined3d simultaneously
2666      */
2667     if(numAdapters > 0) return TRUE;
2668
2669     TRACE("Initializing adapters\n");
2670
2671     if(!mod_gl) {
2672 #ifdef USE_WIN32_OPENGL
2673 #define USE_GL_FUNC(pfn) pfn = (void*)GetProcAddress(mod_gl, #pfn);
2674         mod_gl = LoadLibraryA("opengl32.dll");
2675         if(!mod_gl) {
2676             ERR("Can't load opengl32.dll!\n");
2677             return FALSE;
2678         }
2679 #else
2680 #define USE_GL_FUNC(pfn) pfn = (void*)pwglGetProcAddress(#pfn);
2681         /* To bypass the opengl32 thunks load wglGetProcAddress from gdi32 (glXGetProcAddress wrapper) instead of opengl32's */
2682         mod_gl = GetModuleHandleA("gdi32.dll");
2683 #endif
2684     }
2685
2686 /* Load WGL core functions from opengl32.dll */
2687 #define USE_WGL_FUNC(pfn) p##pfn = (void*)GetProcAddress(mod_gl, #pfn);
2688     WGL_FUNCS_GEN;
2689 #undef USE_WGL_FUNC
2690
2691     if(!pwglGetProcAddress) {
2692         ERR("Unable to load wglGetProcAddress!\n");
2693         return FALSE;
2694     }
2695
2696 /* Dynamically load all GL core functions */
2697     GL_FUNCS_GEN;
2698 #undef USE_GL_FUNC
2699
2700     /* For now only one default adapter */
2701     {
2702         int iPixelFormat;
2703         int attribs[8];
2704         int values[8];
2705         int nAttribs = 0;
2706         int res;
2707         WineD3D_PixelFormat *cfgs;
2708         int attribute;
2709         DISPLAY_DEVICEW DisplayDevice;
2710         HDC hdc;
2711
2712         TRACE("Initializing default adapter\n");
2713         Adapters[0].monitorPoint.x = -1;
2714         Adapters[0].monitorPoint.y = -1;
2715
2716         if (!WineD3D_CreateFakeGLContext()) {
2717             ERR("Failed to get a gl context for default adapter\n");
2718             HeapFree(GetProcessHeap(), 0, Adapters);
2719             WineD3D_ReleaseFakeGLContext();
2720             return FALSE;
2721         }
2722
2723         ret = IWineD3DImpl_FillGLCaps(&Adapters[0].gl_info);
2724         if(!ret) {
2725             ERR("Failed to initialize gl caps for default adapter\n");
2726             HeapFree(GetProcessHeap(), 0, Adapters);
2727             WineD3D_ReleaseFakeGLContext();
2728             return FALSE;
2729         }
2730         ret = initPixelFormats(&Adapters[0].gl_info);
2731         if(!ret) {
2732             ERR("Failed to init gl formats\n");
2733             HeapFree(GetProcessHeap(), 0, Adapters);
2734             WineD3D_ReleaseFakeGLContext();
2735             return FALSE;
2736         }
2737
2738         hdc = pwglGetCurrentDC();
2739         if(!hdc) {
2740             ERR("Failed to get gl HDC\n");
2741             HeapFree(GetProcessHeap(), 0, Adapters);
2742             WineD3D_ReleaseFakeGLContext();
2743             return FALSE;
2744         }
2745
2746         Adapters[0].driver = "Display";
2747         Adapters[0].description = "Direct3D HAL";
2748
2749         /* Use the VideoRamSize registry setting when set */
2750         if(wined3d_settings.emulated_textureram)
2751             Adapters[0].TextureRam = wined3d_settings.emulated_textureram;
2752         else
2753             Adapters[0].TextureRam = Adapters[0].gl_info.vidmem;
2754         Adapters[0].UsedTextureRam = 0;
2755         TRACE("Emulating %dMB of texture ram\n", Adapters[0].TextureRam);
2756
2757         /* Initialize the Adapter's DeviceName which is required for ChangeDisplaySettings and friends */
2758         DisplayDevice.cb = sizeof(DisplayDevice);
2759         EnumDisplayDevicesW(NULL, 0 /* Adapter 0 = iDevNum 0 */, &DisplayDevice, 0);
2760         TRACE("DeviceName: %s\n", debugstr_w(DisplayDevice.DeviceName));
2761         strcpyW(Adapters[0].DeviceName, DisplayDevice.DeviceName);
2762
2763         attribute = WGL_NUMBER_PIXEL_FORMATS_ARB;
2764         GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc, 0, 0, 1, &attribute, &Adapters[0].nCfgs));
2765
2766         Adapters[0].cfgs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, Adapters[0].nCfgs *sizeof(WineD3D_PixelFormat));
2767         cfgs = Adapters[0].cfgs;
2768         PUSH1(WGL_RED_BITS_ARB)
2769         PUSH1(WGL_GREEN_BITS_ARB)
2770         PUSH1(WGL_BLUE_BITS_ARB)
2771         PUSH1(WGL_ALPHA_BITS_ARB)
2772         PUSH1(WGL_DEPTH_BITS_ARB)
2773         PUSH1(WGL_STENCIL_BITS_ARB)
2774
2775         for(iPixelFormat=1; iPixelFormat<=Adapters[0].nCfgs; iPixelFormat++) {
2776             res = GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc, iPixelFormat, 0, nAttribs, attribs, values));
2777
2778             if(!res)
2779                 continue;
2780
2781             /* Cache the pixel format */
2782             cfgs->iPixelFormat = iPixelFormat;
2783             cfgs->redSize = values[0];
2784             cfgs->greenSize = values[1];
2785             cfgs->blueSize = values[2];
2786             cfgs->alphaSize = values[3];
2787             cfgs->depthSize = values[4];
2788             cfgs->stencilSize = values[5];
2789
2790             TRACE("iPixelFormat=%d, RGBA=%d/%d/%d/%d, depth=%d, stencil=%d\n", cfgs->iPixelFormat, cfgs->redSize, cfgs->greenSize, cfgs->blueSize, cfgs->alphaSize, cfgs->depthSize, cfgs->stencilSize);
2791             cfgs++;
2792         }
2793         WineD3D_ReleaseFakeGLContext();
2794
2795         select_shader_mode(&Adapters[0].gl_info, WINED3DDEVTYPE_HAL, &ps_selected_mode, &vs_selected_mode);
2796         select_shader_max_constants(ps_selected_mode, vs_selected_mode, &Adapters[0].gl_info);
2797
2798     }
2799     numAdapters = 1;
2800     TRACE("%d adapters successfully initialized\n", numAdapters);
2801
2802     return TRUE;
2803 }
2804 #undef PUSH1
2805 #undef GLINFO_LOCATION
2806
2807 /**********************************************************
2808  * IWineD3D VTbl follows
2809  **********************************************************/
2810
2811 const IWineD3DVtbl IWineD3D_Vtbl =
2812 {
2813     /* IUnknown */
2814     IWineD3DImpl_QueryInterface,
2815     IWineD3DImpl_AddRef,
2816     IWineD3DImpl_Release,
2817     /* IWineD3D */
2818     IWineD3DImpl_GetParent,
2819     IWineD3DImpl_GetAdapterCount,
2820     IWineD3DImpl_RegisterSoftwareDevice,
2821     IWineD3DImpl_GetAdapterMonitor,
2822     IWineD3DImpl_GetAdapterModeCount,
2823     IWineD3DImpl_EnumAdapterModes,
2824     IWineD3DImpl_GetAdapterDisplayMode,
2825     IWineD3DImpl_GetAdapterIdentifier,
2826     IWineD3DImpl_CheckDeviceMultiSampleType,
2827     IWineD3DImpl_CheckDepthStencilMatch,
2828     IWineD3DImpl_CheckDeviceType,
2829     IWineD3DImpl_CheckDeviceFormat,
2830     IWineD3DImpl_CheckDeviceFormatConversion,
2831     IWineD3DImpl_GetDeviceCaps,
2832     IWineD3DImpl_CreateDevice
2833 };