git.oblomov.eu Git - wine/blob - dlls/wined3d/directx.c

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