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