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