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

   1 /*
   2  * Utility functions for the WineD3D Library
   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 2006-2008 Henri Verbeet
   9  * Copyright 2007-2008 Stefan Dösinger for CodeWeavers
  10  * Copyright 2009 Henri Verbeet for CodeWeavers
  11  *
  12  * This library is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU Lesser General Public
  14  * License as published by the Free Software Foundation; either
  15  * version 2.1 of the License, or (at your option) any later version.
  16  *
  17  * This library is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  * Lesser General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Lesser General Public
  23  * License along with this library; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  25  */
  26
  27 #include "config.h"
  28 #include "wined3d_private.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
  31
  32 struct StaticPixelFormatDesc
  33 {
  34     WINED3DFORMAT format;
  35     DWORD alphaMask, redMask, greenMask, blueMask;
  36     UINT bpp;
  37     short depthSize, stencilSize;
  38 };
  39
  40 /*****************************************************************************
  41  * Pixel format array
  42  *
  43  * For the formats WINED3DFMT_A32B32G32R32F, WINED3DFMT_A16B16G16R16F,
  44  * and WINED3DFMT_A16B16G16R16 do not have correct alpha masks, because the
  45  * high masks do not fit into the 32 bit values needed for ddraw. It is only
  46  * used for ddraw mostly, and to figure out if the format has alpha at all, so
  47  * setting a mask like 0x1 for those surfaces is correct. The 64 and 128 bit
  48  * formats are not usable in 2D rendering because ddraw doesn't support them.
  49  */
  50 static const struct StaticPixelFormatDesc formats[] =
  51 {
  52   /* WINED3DFORMAT                       alphamask    redmask    greenmask    bluemask     bpp    depth  stencil */
  53     {WINED3DFMT_UNKNOWN,                    0x0,        0x0,        0x0,        0x0,        0,      0,      0},
  54     /* FourCC formats */
  55     {WINED3DFMT_UYVY,                       0x0,        0x0,        0x0,        0x0,        2,      0,      0},
  56     {WINED3DFMT_YUY2,                       0x0,        0x0,        0x0,        0x0,        2,      0,      0},
  57     {WINED3DFMT_YV12,                       0x0,        0x0,        0x0,        0x0,        1,      0,      0},
  58     {WINED3DFMT_DXT1,                       0x0,        0x0,        0x0,        0x0,        1,      0,      0},
  59     {WINED3DFMT_DXT2,                       0x0,        0x0,        0x0,        0x0,        1,      0,      0},
  60     {WINED3DFMT_DXT3,                       0x0,        0x0,        0x0,        0x0,        1,      0,      0},
  61     {WINED3DFMT_DXT4,                       0x0,        0x0,        0x0,        0x0,        1,      0,      0},
  62     {WINED3DFMT_DXT5,                       0x0,        0x0,        0x0,        0x0,        1,      0,      0},
  63     {WINED3DFMT_MULTI2_ARGB8,               0x0,        0x0,        0x0,        0x0,        1/*?*/, 0,      0},
  64     {WINED3DFMT_G8R8_G8B8,                  0x0,        0x0,        0x0,        0x0,        1/*?*/, 0,      0},
  65     {WINED3DFMT_R8G8_B8G8,                  0x0,        0x0,        0x0,        0x0,        1/*?*/, 0,      0},
  66     /* IEEE formats */
  67     {WINED3DFMT_R32_FLOAT,                  0x0,        0x0,        0x0,        0x0,        4,      0,      0},
  68     {WINED3DFMT_R32G32_FLOAT,               0x0,        0x0,        0x0,        0x0,        8,      0,      0},
  69     {WINED3DFMT_R32G32B32_FLOAT,            0x0,        0x0,        0x0,        0x0,        12,     0,      0},
  70     {WINED3DFMT_R32G32B32A32_FLOAT,         0x1,        0x0,        0x0,        0x0,        16,     0,      0},
  71     /* Hmm? */
  72     {WINED3DFMT_R8G8_SNORM_Cx,              0x0,        0x0,        0x0,        0x0,        2,      0,      0},
  73     /* Float */
  74     {WINED3DFMT_R16_FLOAT,                  0x0,        0x0,        0x0,        0x0,        2,      0,      0},
  75     {WINED3DFMT_R16G16_FLOAT,               0x0,        0x0,        0x0,        0x0,        4,      0,      0},
  76     {WINED3DFMT_R16G16_SINT,                0x0,        0x0,        0x0,        0x0,        4,      0,      0},
  77     {WINED3DFMT_R16G16B16A16_FLOAT,         0x1,        0x0,        0x0,        0x0,        8,      0,      0},
  78     {WINED3DFMT_R16G16B16A16_SINT,          0x1,        0x0,        0x0,        0x0,        8,      0,      0},
  79     /* Palettized formats */
  80     {WINED3DFMT_P8_UINT_A8_UNORM,           0x0000ff00, 0x0,        0x0,        0x0,        2,      0,      0},
  81     {WINED3DFMT_P8_UINT,                    0x0,        0x0,        0x0,        0x0,        1,      0,      0},
  82     /* Standard ARGB formats. */
  83     {WINED3DFMT_B8G8R8_UNORM,               0x0,        0x00ff0000, 0x0000ff00, 0x000000ff, 3,      0,      0},
  84     {WINED3DFMT_B8G8R8A8_UNORM,             0xff000000, 0x00ff0000, 0x0000ff00, 0x000000ff, 4,      0,      0},
  85     {WINED3DFMT_B8G8R8X8_UNORM,             0x0,        0x00ff0000, 0x0000ff00, 0x000000ff, 4,      0,      0},
  86     {WINED3DFMT_B5G6R5_UNORM,               0x0,        0x0000f800, 0x000007e0, 0x0000001f, 2,      0,      0},
  87     {WINED3DFMT_B5G5R5X1_UNORM,             0x0,        0x00007c00, 0x000003e0, 0x0000001f, 2,      0,      0},
  88     {WINED3DFMT_B5G5R5A1_UNORM,             0x00008000, 0x00007c00, 0x000003e0, 0x0000001f, 2,      0,      0},
  89     {WINED3DFMT_B4G4R4A4_UNORM,             0x0000f000, 0x00000f00, 0x000000f0, 0x0000000f, 2,      0,      0},
  90     {WINED3DFMT_B2G3R3_UNORM,               0x0,        0x000000e0, 0x0000001c, 0x00000003, 1,      0,      0},
  91     {WINED3DFMT_A8_UNORM,                   0x000000ff, 0x0,        0x0,        0x0,        1,      0,      0},
  92     {WINED3DFMT_B2G3R3A8_UNORM,             0x0000ff00, 0x000000e0, 0x0000001c, 0x00000003, 2,      0,      0},
  93     {WINED3DFMT_B4G4R4X4_UNORM,             0x0,        0x00000f00, 0x000000f0, 0x0000000f, 2,      0,      0},
  94     {WINED3DFMT_R10G10B10A2_UNORM,          0xc0000000, 0x000003ff, 0x000ffc00, 0x3ff00000, 4,      0,      0},
  95     {WINED3DFMT_R10G10B10A2_UINT,           0xc0000000, 0x000003ff, 0x000ffc00, 0x3ff00000, 4,      0,      0},
  96     {WINED3DFMT_R10G10B10A2_SNORM,          0xc0000000, 0x000003ff, 0x000ffc00, 0x3ff00000, 4,      0,      0},
  97     {WINED3DFMT_R8G8B8A8_UNORM,             0xff000000, 0x000000ff, 0x0000ff00, 0x00ff0000, 4,      0,      0},
  98     {WINED3DFMT_R8G8B8A8_UINT,              0xff000000, 0x000000ff, 0x0000ff00, 0x00ff0000, 4,      0,      0},
  99     {WINED3DFMT_R8G8B8X8_UNORM,             0x0,        0x000000ff, 0x0000ff00, 0x00ff0000, 4,      0,      0},
 100     {WINED3DFMT_R16G16_UNORM,               0x0,        0x0000ffff, 0xffff0000, 0x0,        4,      0,      0},
 101     {WINED3DFMT_B10G10R10A2_UNORM,          0xc0000000, 0x3ff00000, 0x000ffc00, 0x000003ff, 4,      0,      0},
 102     {WINED3DFMT_R16G16B16A16_UNORM,         0x1,        0x0000ffff, 0xffff0000, 0x0,        8,      0,      0},
 103     /* Luminance */
 104     {WINED3DFMT_L8_UNORM,                   0x0,        0x0,        0x0,        0x0,        1,      0,      0},
 105     {WINED3DFMT_L8A8_UNORM,                 0x0000ff00, 0x0,        0x0,        0x0,        2,      0,      0},
 106     {WINED3DFMT_L4A4_UNORM,                 0x000000f0, 0x0,        0x0,        0x0,        1,      0,      0},
 107     {WINED3DFMT_L16_UNORM,                  0x0,        0x0,        0x0,        0x0,        2,      16,     0},
 108     /* Bump mapping stuff */
 109     {WINED3DFMT_R8G8_SNORM,                 0x0,        0x0,        0x0,        0x0,        2,      0,      0},
 110     {WINED3DFMT_R5G5_SNORM_L6_UNORM,        0x0,        0x0,        0x0,        0x0,        2,      0,      0},
 111     {WINED3DFMT_R8G8_SNORM_L8X8_UNORM,      0x0,        0x0,        0x0,        0x0,        4,      0,      0},
 112     {WINED3DFMT_R8G8B8A8_SNORM,             0x0,        0x0,        0x0,        0x0,        4,      0,      0},
 113     {WINED3DFMT_R16G16_SNORM,               0x0,        0x0,        0x0,        0x0,        4,      0,      0},
 114     {WINED3DFMT_R10G11B11_SNORM,            0x0,        0x0,        0x0,        0x0,        4,      0,      0},
 115     {WINED3DFMT_R10G10B10_SNORM_A2_UNORM,   0xb0000000, 0x0,        0x0,        0x0,        4,      0,      0},
 116     /* Depth stencil formats */
 117     {WINED3DFMT_D16_LOCKABLE,               0x0,        0x0,        0x0,        0x0,        2,      16,     0},
 118     {WINED3DFMT_D32_UNORM,                  0x0,        0x0,        0x0,        0x0,        4,      32,     0},
 119     {WINED3DFMT_S1_UINT_D15_UNORM,          0x0,        0x0,        0x0,        0x0,        2,      15,     1},
 120     {WINED3DFMT_D24_UNORM_S8_UINT,          0x0,        0x0,        0x0,        0x0,        4,      24,     8},
 121     {WINED3DFMT_X8D24_UNORM,                0x0,        0x0,        0x0,        0x0,        4,      24,     0},
 122     {WINED3DFMT_S4X4_UINT_D24_UNORM,        0x0,        0x0,        0x0,        0x0,        4,      24,     4},
 123     {WINED3DFMT_D16_UNORM,                  0x0,        0x0,        0x0,        0x0,        2,      16,     0},
 124     {WINED3DFMT_D32_FLOAT,                  0x0,        0x0,        0x0,        0x0,        4,      32,     0},
 125     {WINED3DFMT_S8_UINT_D24_FLOAT,          0x0,        0x0,        0x0,        0x0,        4,      24,     8},
 126     {WINED3DFMT_VERTEXDATA,                 0x0,        0x0,        0x0,        0x0,        0,      0,      0},
 127     {WINED3DFMT_R16_UINT,                   0x0,        0x0,        0x0,        0x0,        2,      0,      0},
 128     {WINED3DFMT_R32_UINT,                   0x0,        0x0,        0x0,        0x0,        4,      0,      0},
 129     {WINED3DFMT_R16G16B16A16_SNORM,         0x0,        0x0,        0x0,        0x0,        8,      0,      0},
 130     /* Vendor-specific formats */
 131     {WINED3DFMT_ATI2N,                      0x0,        0x0,        0x0,        0x0,        1,      0,      0},
 132     {WINED3DFMT_NVHU,                       0x0,        0x0,        0x0,        0x0,        2,      0,      0},
 133     {WINED3DFMT_NVHS,                       0x0,        0x0,        0x0,        0x0,        2,      0,      0},
 134 };
 135
 136 struct wined3d_format_base_flags
 137 {
 138     WINED3DFORMAT format;
 139     DWORD flags;
 140 };
 141
 142 static const struct wined3d_format_base_flags format_base_flags[] =
 143 {
 144     {WINED3DFMT_UYVY,               WINED3DFMT_FLAG_FOURCC},
 145     {WINED3DFMT_YUY2,               WINED3DFMT_FLAG_FOURCC},
 146     {WINED3DFMT_YV12,               WINED3DFMT_FLAG_FOURCC},
 147     {WINED3DFMT_DXT1,               WINED3DFMT_FLAG_FOURCC},
 148     {WINED3DFMT_DXT2,               WINED3DFMT_FLAG_FOURCC},
 149     {WINED3DFMT_DXT3,               WINED3DFMT_FLAG_FOURCC},
 150     {WINED3DFMT_DXT4,               WINED3DFMT_FLAG_FOURCC},
 151     {WINED3DFMT_DXT5,               WINED3DFMT_FLAG_FOURCC},
 152     {WINED3DFMT_MULTI2_ARGB8,       WINED3DFMT_FLAG_FOURCC},
 153     {WINED3DFMT_G8R8_G8B8,          WINED3DFMT_FLAG_FOURCC},
 154     {WINED3DFMT_R8G8_B8G8,          WINED3DFMT_FLAG_FOURCC},
 155     {WINED3DFMT_P8_UINT,            WINED3DFMT_FLAG_GETDC},
 156     {WINED3DFMT_B8G8R8_UNORM,       WINED3DFMT_FLAG_GETDC},
 157     {WINED3DFMT_B8G8R8A8_UNORM,     WINED3DFMT_FLAG_GETDC},
 158     {WINED3DFMT_B8G8R8X8_UNORM,     WINED3DFMT_FLAG_GETDC},
 159     {WINED3DFMT_B5G6R5_UNORM,       WINED3DFMT_FLAG_GETDC},
 160     {WINED3DFMT_B5G5R5X1_UNORM,     WINED3DFMT_FLAG_GETDC},
 161     {WINED3DFMT_B5G5R5A1_UNORM,     WINED3DFMT_FLAG_GETDC},
 162     {WINED3DFMT_B4G4R4A4_UNORM,     WINED3DFMT_FLAG_GETDC},
 163     {WINED3DFMT_B4G4R4X4_UNORM,     WINED3DFMT_FLAG_GETDC},
 164     {WINED3DFMT_R8G8B8A8_UNORM,     WINED3DFMT_FLAG_GETDC},
 165     {WINED3DFMT_R8G8B8X8_UNORM,     WINED3DFMT_FLAG_GETDC},
 166     {WINED3DFMT_ATI2N,              WINED3DFMT_FLAG_FOURCC},
 167     {WINED3DFMT_NVHU,               WINED3DFMT_FLAG_FOURCC},
 168     {WINED3DFMT_NVHS,               WINED3DFMT_FLAG_FOURCC},
 169     {WINED3DFMT_R32_FLOAT,          WINED3DFMT_FLAG_FLOAT},
 170     {WINED3DFMT_R32G32_FLOAT,       WINED3DFMT_FLAG_FLOAT},
 171     {WINED3DFMT_R32G32B32_FLOAT,    WINED3DFMT_FLAG_FLOAT},
 172     {WINED3DFMT_R32G32B32A32_FLOAT, WINED3DFMT_FLAG_FLOAT},
 173     {WINED3DFMT_R16_FLOAT,          WINED3DFMT_FLAG_FLOAT},
 174     {WINED3DFMT_R16G16_FLOAT,       WINED3DFMT_FLAG_FLOAT},
 175     {WINED3DFMT_R16G16B16A16_FLOAT, WINED3DFMT_FLAG_FLOAT},
 176     {WINED3DFMT_D32_FLOAT,          WINED3DFMT_FLAG_FLOAT},
 177     {WINED3DFMT_S8_UINT_D24_FLOAT,  WINED3DFMT_FLAG_FLOAT},
 178 };
 179
 180 struct wined3d_format_compression_info
 181 {
 182     WINED3DFORMAT format;
 183     UINT block_width;
 184     UINT block_height;
 185     UINT block_byte_count;
 186 };
 187
 188 static const struct wined3d_format_compression_info format_compression_info[] =
 189 {
 190     {WINED3DFMT_DXT1,   4,  4,  8},
 191     {WINED3DFMT_DXT2,   4,  4,  16},
 192     {WINED3DFMT_DXT3,   4,  4,  16},
 193     {WINED3DFMT_DXT4,   4,  4,  16},
 194     {WINED3DFMT_DXT5,   4,  4,  16},
 195     {WINED3DFMT_ATI2N,  1,  1,  1},
 196 };
 197
 198 struct wined3d_format_vertex_info
 199 {
 200     WINED3DFORMAT format;
 201     enum wined3d_ffp_emit_idx emit_idx;
 202     GLint component_count;
 203     GLenum gl_vtx_type;
 204     GLint gl_vtx_format;
 205     GLboolean gl_normalized;
 206     unsigned int component_size;
 207 };
 208
 209 static const struct wined3d_format_vertex_info format_vertex_info[] =
 210 {
 211     {WINED3DFMT_R32_FLOAT,          WINED3D_FFP_EMIT_FLOAT1,    1, GL_FLOAT,          1, GL_FALSE, sizeof(float)},
 212     {WINED3DFMT_R32G32_FLOAT,       WINED3D_FFP_EMIT_FLOAT2,    2, GL_FLOAT,          2, GL_FALSE, sizeof(float)},
 213     {WINED3DFMT_R32G32B32_FLOAT,    WINED3D_FFP_EMIT_FLOAT3,    3, GL_FLOAT,          3, GL_FALSE, sizeof(float)},
 214     {WINED3DFMT_R32G32B32A32_FLOAT, WINED3D_FFP_EMIT_FLOAT4,    4, GL_FLOAT,          4, GL_FALSE, sizeof(float)},
 215     {WINED3DFMT_B8G8R8A8_UNORM,     WINED3D_FFP_EMIT_D3DCOLOR,  4, GL_UNSIGNED_BYTE,  4, GL_TRUE,  sizeof(BYTE)},
 216     {WINED3DFMT_R8G8B8A8_UINT,      WINED3D_FFP_EMIT_UBYTE4,    4, GL_UNSIGNED_BYTE,  4, GL_FALSE, sizeof(BYTE)},
 217     {WINED3DFMT_R16G16_SINT,        WINED3D_FFP_EMIT_SHORT2,    2, GL_SHORT,          2, GL_FALSE, sizeof(short int)},
 218     {WINED3DFMT_R16G16B16A16_SINT,  WINED3D_FFP_EMIT_SHORT4,    4, GL_SHORT,          4, GL_FALSE, sizeof(short int)},
 219     {WINED3DFMT_R8G8B8A8_UNORM,     WINED3D_FFP_EMIT_UBYTE4N,   4, GL_UNSIGNED_BYTE,  4, GL_TRUE,  sizeof(BYTE)},
 220     {WINED3DFMT_R16G16_SNORM,       WINED3D_FFP_EMIT_SHORT2N,   2, GL_SHORT,          2, GL_TRUE,  sizeof(short int)},
 221     {WINED3DFMT_R16G16B16A16_SNORM, WINED3D_FFP_EMIT_SHORT4N,   4, GL_SHORT,          4, GL_TRUE,  sizeof(short int)},
 222     {WINED3DFMT_R16G16_UNORM,       WINED3D_FFP_EMIT_USHORT2N,  2, GL_UNSIGNED_SHORT, 2, GL_TRUE,  sizeof(short int)},
 223     {WINED3DFMT_R16G16B16A16_UNORM, WINED3D_FFP_EMIT_USHORT4N,  4, GL_UNSIGNED_SHORT, 4, GL_TRUE,  sizeof(short int)},
 224     {WINED3DFMT_R10G10B10A2_UINT,   WINED3D_FFP_EMIT_UDEC3,     3, GL_UNSIGNED_SHORT, 3, GL_FALSE, sizeof(short int)},
 225     {WINED3DFMT_R10G10B10A2_SNORM,  WINED3D_FFP_EMIT_DEC3N,     3, GL_SHORT,          3, GL_TRUE,  sizeof(short int)},
 226     {WINED3DFMT_R16G16_FLOAT,       WINED3D_FFP_EMIT_FLOAT16_2, 2, GL_FLOAT,          2, GL_FALSE, sizeof(GLhalfNV)},
 227     {WINED3DFMT_R16G16B16A16_FLOAT, WINED3D_FFP_EMIT_FLOAT16_4, 4, GL_FLOAT,          4, GL_FALSE, sizeof(GLhalfNV)}
 228 };
 229
 230 struct wined3d_format_texture_info
 231 {
 232     WINED3DFORMAT format;
 233     GLint gl_internal;
 234     GLint gl_srgb_internal;
 235     GLint gl_rt_internal;
 236     GLint gl_format;
 237     GLint gl_type;
 238     unsigned int conv_byte_count;
 239     unsigned int flags;
 240     GL_SupportedExt extension;
 241     void (*convert)(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height);
 242 };
 243
 244 static void convert_l4a4_unorm(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
 245 {
 246     /* WINED3DFMT_L4A4_UNORM exists as an internal gl format, but for some reason there is not
 247      * format+type combination to load it. Thus convert it to A8L8, then load it
 248      * with A4L4 internal, but A8L8 format+type
 249      */
 250     unsigned int x, y;
 251     const unsigned char *Source;
 252     unsigned char *Dest;
 253     UINT outpitch = pitch * 2;
 254
 255     for(y = 0; y < height; y++) {
 256         Source = src + y * pitch;
 257         Dest = dst + y * outpitch;
 258         for (x = 0; x < width; x++ ) {
 259             unsigned char color = (*Source++);
 260             /* A */ Dest[1] = (color & 0xf0) << 0;
 261             /* L */ Dest[0] = (color & 0x0f) << 4;
 262             Dest += 2;
 263         }
 264     }
 265 }
 266
 267 static void convert_r5g5_snorm_l6_unorm(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
 268 {
 269     unsigned int x, y;
 270     const WORD *Source;
 271
 272     for(y = 0; y < height; y++)
 273     {
 274         unsigned short *Dest_s = (unsigned short *) (dst + y * pitch);
 275         Source = (const WORD *)(src + y * pitch);
 276         for (x = 0; x < width; x++ )
 277         {
 278             short color = (*Source++);
 279             unsigned char l = ((color >> 10) & 0xfc);
 280                     short v = ((color >>  5) & 0x3e);
 281                     short u = ((color      ) & 0x1f);
 282             short v_conv = v + 16;
 283             short u_conv = u + 16;
 284
 285             *Dest_s = ((v_conv << 11) & 0xf800) | ((l << 5) & 0x7e0) | (u_conv & 0x1f);
 286             Dest_s += 1;
 287         }
 288     }
 289 }
 290
 291 static void convert_r5g5_snorm_l6_unorm_nv(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
 292 {
 293     unsigned int x, y;
 294     const WORD *Source;
 295     unsigned char *Dest;
 296     UINT outpitch = (pitch * 3)/2;
 297
 298     /* This makes the gl surface bigger(24 bit instead of 16), but it works with
 299      * fixed function and shaders without further conversion once the surface is
 300      * loaded
 301      */
 302     for(y = 0; y < height; y++) {
 303         Source = (const WORD *)(src + y * pitch);
 304         Dest = dst + y * outpitch;
 305         for (x = 0; x < width; x++ ) {
 306             short color = (*Source++);
 307             unsigned char l = ((color >> 10) & 0xfc);
 308                      char v = ((color >>  5) & 0x3e);
 309                      char u = ((color      ) & 0x1f);
 310
 311             /* 8 bits destination, 6 bits source, 8th bit is the sign. gl ignores the sign
 312              * and doubles the positive range. Thus shift left only once, gl does the 2nd
 313              * shift. GL reads a signed value and converts it into an unsigned value.
 314              */
 315             /* M */ Dest[2] = l << 1;
 316
 317             /* Those are read as signed, but kept signed. Just left-shift 3 times to scale
 318              * from 5 bit values to 8 bit values.
 319              */
 320             /* V */ Dest[1] = v << 3;
 321             /* U */ Dest[0] = u << 3;
 322             Dest += 3;
 323         }
 324     }
 325 }
 326
 327 static void convert_r8g8_snorm(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
 328 {
 329     unsigned int x, y;
 330     const short *Source;
 331     unsigned char *Dest;
 332     UINT outpitch = (pitch * 3)/2;
 333
 334     for(y = 0; y < height; y++)
 335     {
 336         Source = (const short *)(src + y * pitch);
 337         Dest = dst + y * outpitch;
 338         for (x = 0; x < width; x++ )
 339         {
 340             long color = (*Source++);
 341             /* B */ Dest[0] = 0xff;
 342             /* G */ Dest[1] = (color >> 8) + 128; /* V */
 343             /* R */ Dest[2] = (color) + 128;      /* U */
 344             Dest += 3;
 345         }
 346     }
 347 }
 348
 349 static void convert_r8g8_snorm_l8x8_unorm(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
 350 {
 351     unsigned int x, y;
 352     const DWORD *Source;
 353     unsigned char *Dest;
 354
 355     /* Doesn't work correctly with the fixed function pipeline, but can work in
 356      * shaders if the shader is adjusted. (There's no use for this format in gl's
 357      * standard fixed function pipeline anyway).
 358      */
 359     for(y = 0; y < height; y++)
 360     {
 361         Source = (const DWORD *)(src + y * pitch);
 362         Dest = dst + y * pitch;
 363         for (x = 0; x < width; x++ )
 364         {
 365             long color = (*Source++);
 366             /* B */ Dest[0] = ((color >> 16) & 0xff);       /* L */
 367             /* G */ Dest[1] = ((color >> 8 ) & 0xff) + 128; /* V */
 368             /* R */ Dest[2] = (color         & 0xff) + 128; /* U */
 369             Dest += 4;
 370         }
 371     }
 372 }
 373
 374 static void convert_r8g8_snorm_l8x8_unorm_nv(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
 375 {
 376     unsigned int x, y;
 377     const DWORD *Source;
 378     unsigned char *Dest;
 379
 380     /* This implementation works with the fixed function pipeline and shaders
 381      * without further modification after converting the surface.
 382      */
 383     for(y = 0; y < height; y++)
 384     {
 385         Source = (const DWORD *)(src + y * pitch);
 386         Dest = dst + y * pitch;
 387         for (x = 0; x < width; x++ )
 388         {
 389             long color = (*Source++);
 390             /* L */ Dest[2] = ((color >> 16) & 0xff);   /* L */
 391             /* V */ Dest[1] = ((color >> 8 ) & 0xff);   /* V */
 392             /* U */ Dest[0] = (color         & 0xff);   /* U */
 393             /* I */ Dest[3] = 255;                      /* X */
 394             Dest += 4;
 395         }
 396     }
 397 }
 398
 399 static void convert_r8g8b8a8_snorm(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
 400 {
 401     unsigned int x, y;
 402     const DWORD *Source;
 403     unsigned char *Dest;
 404
 405     for(y = 0; y < height; y++)
 406     {
 407         Source = (const DWORD *)(src + y * pitch);
 408         Dest = dst + y * pitch;
 409         for (x = 0; x < width; x++ )
 410         {
 411             long color = (*Source++);
 412             /* B */ Dest[0] = ((color >> 16) & 0xff) + 128; /* W */
 413             /* G */ Dest[1] = ((color >> 8 ) & 0xff) + 128; /* V */
 414             /* R */ Dest[2] = (color         & 0xff) + 128; /* U */
 415             /* A */ Dest[3] = ((color >> 24) & 0xff) + 128; /* Q */
 416             Dest += 4;
 417         }
 418     }
 419 }
 420
 421 static void convert_r16g16_snorm(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
 422 {
 423     unsigned int x, y;
 424     const DWORD *Source;
 425     unsigned short *Dest;
 426     UINT outpitch = (pitch * 3)/2;
 427
 428     for(y = 0; y < height; y++)
 429     {
 430         Source = (const DWORD *)(src + y * pitch);
 431         Dest = (unsigned short *) (dst + y * outpitch);
 432         for (x = 0; x < width; x++ )
 433         {
 434             DWORD color = (*Source++);
 435             /* B */ Dest[0] = 0xffff;
 436             /* G */ Dest[1] = (color >> 16) + 32768; /* V */
 437             /* R */ Dest[2] = (color      ) + 32768; /* U */
 438             Dest += 3;
 439         }
 440     }
 441 }
 442
 443 static void convert_r16g16(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
 444 {
 445     unsigned int x, y;
 446     const WORD *Source;
 447     WORD *Dest;
 448     UINT outpitch = (pitch * 3)/2;
 449
 450     for(y = 0; y < height; y++)
 451     {
 452         Source = (const WORD *)(src + y * pitch);
 453         Dest = (WORD *) (dst + y * outpitch);
 454         for (x = 0; x < width; x++ )
 455         {
 456             WORD green = (*Source++);
 457             WORD red = (*Source++);
 458             Dest[0] = green;
 459             Dest[1] = red;
 460             /* Strictly speaking not correct for R16G16F, but it doesn't matter because the
 461              * shader overwrites it anyway
 462              */
 463             Dest[2] = 0xffff;
 464             Dest += 3;
 465         }
 466     }
 467 }
 468
 469 static void convert_r32g32_float(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
 470 {
 471     unsigned int x, y;
 472     const float *Source;
 473     float *Dest;
 474     UINT outpitch = (pitch * 3)/2;
 475
 476     for(y = 0; y < height; y++)
 477     {
 478         Source = (const float *)(src + y * pitch);
 479         Dest = (float *) (dst + y * outpitch);
 480         for (x = 0; x < width; x++ )
 481         {
 482             float green = (*Source++);
 483             float red = (*Source++);
 484             Dest[0] = green;
 485             Dest[1] = red;
 486             Dest[2] = 1.0f;
 487             Dest += 3;
 488         }
 489     }
 490 }
 491
 492 static void convert_s1_uint_d15_unorm(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
 493 {
 494     unsigned int x, y;
 495     UINT outpitch = pitch * 2;
 496
 497     for (y = 0; y < height; ++y)
 498     {
 499         const WORD *source = (const WORD *)(src + y * pitch);
 500         DWORD *dest = (DWORD *)(dst + y * outpitch);
 501
 502         for (x = 0; x < width; ++x)
 503         {
 504             /* The depth data is normalized, so needs to be scaled,
 505              * the stencil data isn't.  Scale depth data by
 506              *      (2^24-1)/(2^15-1) ~~ (2^9 + 2^-6). */
 507             WORD d15 = source[x] >> 1;
 508             DWORD d24 = (d15 << 9) + (d15 >> 6);
 509             dest[x] = (d24 << 8) | (source[x] & 0x1);
 510         }
 511     }
 512 }
 513
 514 static void convert_s4x4_uint_d24_unorm(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
 515 {
 516     unsigned int x, y;
 517
 518     for (y = 0; y < height; ++y)
 519     {
 520         const DWORD *source = (const DWORD *)(src + y * pitch);
 521         DWORD *dest = (DWORD *)(dst + y * pitch);
 522
 523         for (x = 0; x < width; ++x)
 524         {
 525             /* Just need to clear out the X4 part. */
 526             dest[x] = source[x] & ~0xf0;
 527         }
 528     }
 529 }
 530
 531 static void convert_s8_uint_d24_float(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
 532 {
 533     unsigned int x, y;
 534     UINT outpitch = pitch * 2;
 535
 536     for (y = 0; y < height; ++y)
 537     {
 538         const DWORD *source = (const DWORD *)(src + y * pitch);
 539         float *dest_f = (float *)(dst + y * outpitch);
 540         DWORD *dest_s = (DWORD *)(dst + y * outpitch);
 541
 542         for (x = 0; x < width; ++x)
 543         {
 544             dest_f[x * 2] = float_24_to_32((source[x] & 0xffffff00) >> 8);
 545             dest_s[x * 2 + 1] = source[x] & 0xff;
 546         }
 547     }
 548 }
 549
 550 static const struct wined3d_format_texture_info format_texture_info[] =
 551 {
 552     /* WINED3DFORMAT                    internal                          srgbInternal                       rtInternal
 553             format                      type
 554             flags
 555             extension */
 556     /* FourCC formats */
 557     /* GL_APPLE_ycbcr_422 claims that its '2YUV' format, which is supported via the UNSIGNED_SHORT_8_8_REV_APPLE type
 558      * is equivalent to 'UYVY' format on Windows, and the 'YUVS' via UNSIGNED_SHORT_8_8_APPLE equates to 'YUY2'. The
 559      * d3d9 test however shows that the opposite is true. Since the extension is from 2002, it predates the x86 based
 560      * Macs, so probably the endianess differs. This could be tested as soon as we have a Windows and MacOS on a big
 561      * endian machine
 562      */
 563     {WINED3DFMT_UYVY,                   GL_LUMINANCE_ALPHA,               GL_LUMINANCE_ALPHA,                     0,
 564             GL_LUMINANCE_ALPHA,         GL_UNSIGNED_BYTE,                 0,
 565             WINED3DFMT_FLAG_FILTERING,
 566             WINED3D_GL_EXT_NONE,        NULL},
 567     {WINED3DFMT_UYVY,                   GL_RGB,                           GL_RGB,                                 0,
 568             GL_YCBCR_422_APPLE,         UNSIGNED_SHORT_8_8_APPLE,         0,
 569             WINED3DFMT_FLAG_FILTERING,
 570             APPLE_YCBCR_422,            NULL},
 571     {WINED3DFMT_YUY2,                   GL_LUMINANCE_ALPHA,               GL_LUMINANCE_ALPHA,                     0,
 572             GL_LUMINANCE_ALPHA,         GL_UNSIGNED_BYTE,                 0,
 573             WINED3DFMT_FLAG_FILTERING,
 574             WINED3D_GL_EXT_NONE,        NULL},
 575     {WINED3DFMT_YUY2,                   GL_RGB,                           GL_RGB,                                 0,
 576             GL_YCBCR_422_APPLE,         UNSIGNED_SHORT_8_8_REV_APPLE,     0,
 577             WINED3DFMT_FLAG_FILTERING,
 578             APPLE_YCBCR_422,            NULL},
 579     {WINED3DFMT_YV12,                   GL_ALPHA,                         GL_ALPHA,                               0,
 580             GL_ALPHA,                   GL_UNSIGNED_BYTE,                 0,
 581             WINED3DFMT_FLAG_FILTERING,
 582             WINED3D_GL_EXT_NONE,        NULL},
 583     {WINED3DFMT_DXT1,                   GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, 0,
 584             GL_RGBA,                    GL_UNSIGNED_BYTE,                 0,
 585             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
 586             EXT_TEXTURE_COMPRESSION_S3TC, NULL},
 587     {WINED3DFMT_DXT2,                   GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, 0,
 588             GL_RGBA,                    GL_UNSIGNED_BYTE,                 0,
 589             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
 590             EXT_TEXTURE_COMPRESSION_S3TC, NULL},
 591     {WINED3DFMT_DXT3,                   GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, 0,
 592             GL_RGBA,                    GL_UNSIGNED_BYTE,                 0,
 593             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
 594             EXT_TEXTURE_COMPRESSION_S3TC, NULL},
 595     {WINED3DFMT_DXT4,                   GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, 0,
 596             GL_RGBA,                    GL_UNSIGNED_BYTE,                 0,
 597             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
 598             EXT_TEXTURE_COMPRESSION_S3TC, NULL},
 599     {WINED3DFMT_DXT5,                   GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, 0,
 600             GL_RGBA,                    GL_UNSIGNED_BYTE,                 0,
 601             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
 602             EXT_TEXTURE_COMPRESSION_S3TC, NULL},
 603     /* IEEE formats */
 604     {WINED3DFMT_R32_FLOAT,              GL_RGB32F_ARB,                    GL_RGB32F_ARB,                          0,
 605             GL_RED,                     GL_FLOAT,                         0,
 606             WINED3DFMT_FLAG_RENDERTARGET,
 607             ARB_TEXTURE_FLOAT,          NULL},
 608     {WINED3DFMT_R32_FLOAT,              GL_R32F,                          GL_R32F,                                0,
 609             GL_RED,                     GL_FLOAT,                         0,
 610             WINED3DFMT_FLAG_RENDERTARGET,
 611             ARB_TEXTURE_RG,             NULL},
 612     {WINED3DFMT_R32G32_FLOAT,           GL_RGB32F_ARB,                    GL_RGB32F_ARB,                          0,
 613             GL_RGB,                     GL_FLOAT,                         12,
 614             WINED3DFMT_FLAG_RENDERTARGET,
 615             ARB_TEXTURE_FLOAT,          &convert_r32g32_float},
 616     {WINED3DFMT_R32G32_FLOAT,           GL_RG32F,                         GL_RG32F,                               0,
 617             GL_RG,                      GL_FLOAT,                         0,
 618             WINED3DFMT_FLAG_RENDERTARGET,
 619             ARB_TEXTURE_RG,             NULL},
 620     {WINED3DFMT_R32G32B32A32_FLOAT,     GL_RGBA32F_ARB,                   GL_RGBA32F_ARB,                         0,
 621             GL_RGBA,                    GL_FLOAT,                         0,
 622             WINED3DFMT_FLAG_RENDERTARGET,
 623             ARB_TEXTURE_FLOAT,          NULL},
 624     /* Float */
 625     {WINED3DFMT_R16_FLOAT,              GL_RGB16F_ARB,                    GL_RGB16F_ARB,                          0,
 626             GL_RED,                     GL_HALF_FLOAT_ARB,                0,
 627             WINED3DFMT_FLAG_RENDERTARGET,
 628             ARB_TEXTURE_FLOAT,          NULL},
 629     {WINED3DFMT_R16_FLOAT,              GL_R16F,                          GL_R16F,                                0,
 630             GL_RED,                     GL_HALF_FLOAT_ARB,                0,
 631             WINED3DFMT_FLAG_RENDERTARGET,
 632             ARB_TEXTURE_RG,             NULL},
 633     {WINED3DFMT_R16G16_FLOAT,           GL_RGB16F_ARB,                    GL_RGB16F_ARB,                          0,
 634             GL_RGB,                     GL_HALF_FLOAT_ARB,                6,
 635             WINED3DFMT_FLAG_RENDERTARGET,
 636             ARB_TEXTURE_FLOAT,          &convert_r16g16},
 637     {WINED3DFMT_R16G16_FLOAT,           GL_RG16F,                         GL_RG16F,                               0,
 638             GL_RG,                      GL_HALF_FLOAT_ARB,                0,
 639             WINED3DFMT_FLAG_RENDERTARGET,
 640             ARB_TEXTURE_RG,             NULL},
 641     {WINED3DFMT_R16G16B16A16_FLOAT,     GL_RGBA16F_ARB,                   GL_RGBA16F_ARB,                         0,
 642             GL_RGBA,                    GL_HALF_FLOAT_ARB,                0,
 643             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_RENDERTARGET,
 644             ARB_TEXTURE_FLOAT,          NULL},
 645     /* Palettized formats */
 646     {WINED3DFMT_P8_UINT,                GL_RGBA,                          GL_RGBA,                                0,
 647             GL_ALPHA,                   GL_UNSIGNED_BYTE,                 0,
 648             0,
 649             ARB_FRAGMENT_PROGRAM,       NULL},
 650     {WINED3DFMT_P8_UINT,                GL_COLOR_INDEX8_EXT,              GL_COLOR_INDEX8_EXT,                    0,
 651             GL_COLOR_INDEX,             GL_UNSIGNED_BYTE,                 0,
 652             0,
 653             EXT_PALETTED_TEXTURE,       NULL},
 654     /* Standard ARGB formats */
 655     {WINED3DFMT_B8G8R8_UNORM,           GL_RGB8,                          GL_RGB8,                                0,
 656             GL_BGR,                     GL_UNSIGNED_BYTE,                 0,
 657             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET,
 658             WINED3D_GL_EXT_NONE,        NULL},
 659     {WINED3DFMT_B8G8R8A8_UNORM,         GL_RGBA8,                         GL_SRGB8_ALPHA8_EXT,                    0,
 660             GL_BGRA,                    GL_UNSIGNED_INT_8_8_8_8_REV,      0,
 661             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET,
 662             WINED3D_GL_EXT_NONE,        NULL},
 663     {WINED3DFMT_B8G8R8X8_UNORM,         GL_RGB8,                          GL_SRGB8_EXT,                           0,
 664             GL_BGRA,                    GL_UNSIGNED_INT_8_8_8_8_REV,      0,
 665             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET,
 666             WINED3D_GL_EXT_NONE,        NULL},
 667     {WINED3DFMT_B5G6R5_UNORM,           GL_RGB5,                          GL_RGB5,                          GL_RGB8,
 668             GL_RGB,                     GL_UNSIGNED_SHORT_5_6_5,          0,
 669             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET,
 670             WINED3D_GL_EXT_NONE,        NULL},
 671     {WINED3DFMT_B5G5R5X1_UNORM,         GL_RGB5,                          GL_RGB5_A1,                             0,
 672             GL_BGRA,                    GL_UNSIGNED_SHORT_1_5_5_5_REV,    0,
 673             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
 674             WINED3D_GL_EXT_NONE,        NULL},
 675     {WINED3DFMT_B5G5R5A1_UNORM,         GL_RGB5_A1,                       GL_RGB5_A1,                             0,
 676             GL_BGRA,                    GL_UNSIGNED_SHORT_1_5_5_5_REV,    0,
 677             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
 678             WINED3D_GL_EXT_NONE,        NULL},
 679     {WINED3DFMT_B4G4R4A4_UNORM,         GL_RGBA4,                         GL_SRGB8_ALPHA8_EXT,                    0,
 680             GL_BGRA,                    GL_UNSIGNED_SHORT_4_4_4_4_REV,    0,
 681             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
 682             WINED3D_GL_EXT_NONE,        NULL},
 683     {WINED3DFMT_B2G3R3_UNORM,           GL_R3_G3_B2,                      GL_R3_G3_B2,                            0,
 684             GL_RGB,                     GL_UNSIGNED_BYTE_3_3_2,           0,
 685             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING,
 686             WINED3D_GL_EXT_NONE,        NULL},
 687     {WINED3DFMT_A8_UNORM,               GL_ALPHA8,                        GL_ALPHA8,                              0,
 688             GL_ALPHA,                   GL_UNSIGNED_BYTE,                 0,
 689             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING,
 690             WINED3D_GL_EXT_NONE,        NULL},
 691     {WINED3DFMT_B4G4R4X4_UNORM,         GL_RGB4,                          GL_RGB4,                                0,
 692             GL_BGRA,                    GL_UNSIGNED_SHORT_4_4_4_4_REV,    0,
 693             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
 694             WINED3D_GL_EXT_NONE,        NULL},
 695     {WINED3DFMT_R10G10B10A2_UNORM,      GL_RGB10_A2,                      GL_RGB10_A2,                            0,
 696             GL_RGBA,                    GL_UNSIGNED_INT_2_10_10_10_REV,   0,
 697             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
 698             WINED3D_GL_EXT_NONE,        NULL},
 699     {WINED3DFMT_R8G8B8A8_UNORM,         GL_RGBA8,                         GL_RGBA8,                               0,
 700             GL_RGBA,                    GL_UNSIGNED_INT_8_8_8_8_REV,      0,
 701             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
 702             WINED3D_GL_EXT_NONE,        NULL},
 703     {WINED3DFMT_R8G8B8X8_UNORM,         GL_RGB8,                          GL_RGB8,                                0,
 704             GL_RGBA,                    GL_UNSIGNED_INT_8_8_8_8_REV,      0,
 705             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
 706             WINED3D_GL_EXT_NONE,        NULL},
 707     {WINED3DFMT_R16G16_UNORM,           GL_RGB16,                         GL_RGB16,                       GL_RGBA16,
 708             GL_RGB,                     GL_UNSIGNED_SHORT,                6,
 709             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
 710             WINED3D_GL_EXT_NONE,        &convert_r16g16},
 711     {WINED3DFMT_B10G10R10A2_UNORM,      GL_RGB10_A2,                      GL_RGB10_A2,                            0,
 712             GL_BGRA,                    GL_UNSIGNED_INT_2_10_10_10_REV,   0,
 713             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
 714             WINED3D_GL_EXT_NONE,        NULL},
 715     {WINED3DFMT_R16G16B16A16_UNORM,     GL_RGBA16,                        GL_RGBA16,                              0,
 716             GL_RGBA,                    GL_UNSIGNED_SHORT,                0,
 717             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET,
 718             WINED3D_GL_EXT_NONE,        NULL},
 719     /* Luminance */
 720     {WINED3DFMT_L8_UNORM,               GL_LUMINANCE8,                    GL_SLUMINANCE8_EXT,                     0,
 721             GL_LUMINANCE,               GL_UNSIGNED_BYTE,                 0,
 722             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
 723             WINED3D_GL_EXT_NONE,        NULL},
 724     {WINED3DFMT_L8A8_UNORM,             GL_LUMINANCE8_ALPHA8,             GL_SLUMINANCE8_ALPHA8_EXT,              0,
 725             GL_LUMINANCE_ALPHA,         GL_UNSIGNED_BYTE,                 0,
 726             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
 727             WINED3D_GL_EXT_NONE,        NULL},
 728     {WINED3DFMT_L4A4_UNORM,             GL_LUMINANCE4_ALPHA4,             GL_LUMINANCE4_ALPHA4,                   0,
 729             GL_LUMINANCE_ALPHA,         GL_UNSIGNED_BYTE,                 2,
 730             0,
 731             WINED3D_GL_EXT_NONE,        &convert_l4a4_unorm},
 732     /* Bump mapping stuff */
 733     {WINED3DFMT_R8G8_SNORM,             GL_RGB8,                          GL_RGB8,                                0,
 734             GL_BGR,                     GL_UNSIGNED_BYTE,                 3,
 735             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
 736             WINED3D_GL_EXT_NONE,        &convert_r8g8_snorm},
 737     {WINED3DFMT_R8G8_SNORM,             GL_DSDT8_NV,                      GL_DSDT8_NV,                            0,
 738             GL_DSDT_NV,                 GL_BYTE,                          0,
 739             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
 740             NV_TEXTURE_SHADER,          NULL},
 741     {WINED3DFMT_R5G5_SNORM_L6_UNORM,    GL_RGB5,                          GL_RGB5,                                0,
 742             GL_RGB,                     GL_UNSIGNED_SHORT_5_6_5,          2,
 743             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
 744             WINED3D_GL_EXT_NONE,        &convert_r5g5_snorm_l6_unorm},
 745     {WINED3DFMT_R5G5_SNORM_L6_UNORM,    GL_DSDT8_MAG8_NV,                 GL_DSDT8_MAG8_NV,                       0,
 746             GL_DSDT_MAG_NV,             GL_BYTE,                          3,
 747             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
 748             NV_TEXTURE_SHADER,          &convert_r5g5_snorm_l6_unorm_nv},
 749     {WINED3DFMT_R8G8_SNORM_L8X8_UNORM,  GL_RGB8,                          GL_RGB8,                                0,
 750             GL_BGRA,                    GL_UNSIGNED_INT_8_8_8_8_REV,      4,
 751             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
 752             WINED3D_GL_EXT_NONE,        &convert_r8g8_snorm_l8x8_unorm},
 753     {WINED3DFMT_R8G8_SNORM_L8X8_UNORM,  GL_DSDT8_MAG8_INTENSITY8_NV,      GL_DSDT8_MAG8_INTENSITY8_NV,            0,
 754             GL_DSDT_MAG_VIB_NV,         GL_UNSIGNED_INT_8_8_S8_S8_REV_NV, 4,
 755             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
 756             NV_TEXTURE_SHADER,          &convert_r8g8_snorm_l8x8_unorm_nv},
 757     {WINED3DFMT_R8G8B8A8_SNORM,         GL_RGBA8,                         GL_RGBA8,                               0,
 758             GL_BGRA,                    GL_UNSIGNED_BYTE,                 4,
 759             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
 760             WINED3D_GL_EXT_NONE,        &convert_r8g8b8a8_snorm},
 761     {WINED3DFMT_R8G8B8A8_SNORM,         GL_SIGNED_RGBA8_NV,               GL_SIGNED_RGBA8_NV,                     0,
 762             GL_RGBA,                    GL_BYTE,                          0,
 763             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
 764             NV_TEXTURE_SHADER,          NULL},
 765     {WINED3DFMT_R16G16_SNORM,           GL_RGB16,                         GL_RGB16,                               0,
 766             GL_BGR,                     GL_UNSIGNED_SHORT,                6,
 767             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
 768             WINED3D_GL_EXT_NONE,        &convert_r16g16_snorm},
 769     {WINED3DFMT_R16G16_SNORM,           GL_SIGNED_HILO16_NV,              GL_SIGNED_HILO16_NV,                    0,
 770             GL_HILO_NV,                 GL_SHORT,                         0,
 771             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
 772             NV_TEXTURE_SHADER,          NULL},
 773     /* Depth stencil formats */
 774     {WINED3DFMT_D16_LOCKABLE,           GL_DEPTH_COMPONENT24_ARB,         GL_DEPTH_COMPONENT24_ARB,               0,
 775             GL_DEPTH_COMPONENT,         GL_UNSIGNED_SHORT,                0,
 776             WINED3DFMT_FLAG_DEPTH,
 777             ARB_DEPTH_TEXTURE,          NULL},
 778     {WINED3DFMT_D32_UNORM,              GL_DEPTH_COMPONENT32_ARB,         GL_DEPTH_COMPONENT32_ARB,               0,
 779             GL_DEPTH_COMPONENT,         GL_UNSIGNED_INT,                  0,
 780             WINED3DFMT_FLAG_DEPTH,
 781             ARB_DEPTH_TEXTURE,          NULL},
 782     {WINED3DFMT_S1_UINT_D15_UNORM,      GL_DEPTH_COMPONENT24_ARB,         GL_DEPTH_COMPONENT24_ARB,               0,
 783             GL_DEPTH_COMPONENT,         GL_UNSIGNED_SHORT,                0,
 784             WINED3DFMT_FLAG_DEPTH,
 785             ARB_DEPTH_TEXTURE,          NULL},
 786     {WINED3DFMT_S1_UINT_D15_UNORM,      GL_DEPTH24_STENCIL8_EXT,          GL_DEPTH24_STENCIL8_EXT,                0,
 787             GL_DEPTH_STENCIL_EXT,       GL_UNSIGNED_INT_24_8_EXT,         4,
 788             WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL,
 789             EXT_PACKED_DEPTH_STENCIL,   &convert_s1_uint_d15_unorm},
 790     {WINED3DFMT_S1_UINT_D15_UNORM,      GL_DEPTH24_STENCIL8,              GL_DEPTH24_STENCIL8,                    0,
 791             GL_DEPTH_STENCIL,           GL_UNSIGNED_INT_24_8,             4,
 792             WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL,
 793             ARB_FRAMEBUFFER_OBJECT,     &convert_s1_uint_d15_unorm},
 794     {WINED3DFMT_D24_UNORM_S8_UINT,      GL_DEPTH_COMPONENT24_ARB,         GL_DEPTH_COMPONENT24_ARB,               0,
 795             GL_DEPTH_COMPONENT,         GL_UNSIGNED_INT,                  0,
 796             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_DEPTH,
 797             ARB_DEPTH_TEXTURE,          NULL},
 798     {WINED3DFMT_D24_UNORM_S8_UINT,      GL_DEPTH24_STENCIL8_EXT,          GL_DEPTH24_STENCIL8_EXT,                0,
 799             GL_DEPTH_STENCIL_EXT,       GL_UNSIGNED_INT_24_8_EXT,         0,
 800             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL,
 801             EXT_PACKED_DEPTH_STENCIL,   NULL},
 802     {WINED3DFMT_D24_UNORM_S8_UINT,      GL_DEPTH24_STENCIL8,              GL_DEPTH24_STENCIL8,                    0,
 803             GL_DEPTH_STENCIL,           GL_UNSIGNED_INT_24_8,             0,
 804             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL,
 805             ARB_FRAMEBUFFER_OBJECT,     NULL},
 806     {WINED3DFMT_X8D24_UNORM,            GL_DEPTH_COMPONENT24_ARB,         GL_DEPTH_COMPONENT24_ARB,               0,
 807             GL_DEPTH_COMPONENT,         GL_UNSIGNED_INT,                  0,
 808             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_DEPTH,
 809             ARB_DEPTH_TEXTURE,          NULL},
 810     {WINED3DFMT_S4X4_UINT_D24_UNORM,    GL_DEPTH_COMPONENT24_ARB,         GL_DEPTH_COMPONENT24_ARB,               0,
 811             GL_DEPTH_COMPONENT,         GL_UNSIGNED_INT,                  0,
 812             WINED3DFMT_FLAG_DEPTH,
 813             ARB_DEPTH_TEXTURE,          NULL},
 814     {WINED3DFMT_S4X4_UINT_D24_UNORM,    GL_DEPTH24_STENCIL8_EXT,          GL_DEPTH24_STENCIL8_EXT,                0,
 815             GL_DEPTH_STENCIL_EXT,       GL_UNSIGNED_INT_24_8_EXT,         4,
 816             WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL,
 817             EXT_PACKED_DEPTH_STENCIL,   &convert_s4x4_uint_d24_unorm},
 818     {WINED3DFMT_S4X4_UINT_D24_UNORM,    GL_DEPTH24_STENCIL8,              GL_DEPTH24_STENCIL8,                    0,
 819             GL_DEPTH_STENCIL,           GL_UNSIGNED_INT_24_8,             4,
 820             WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL,
 821             ARB_FRAMEBUFFER_OBJECT,     &convert_s4x4_uint_d24_unorm},
 822     {WINED3DFMT_D16_UNORM,              GL_DEPTH_COMPONENT24_ARB,         GL_DEPTH_COMPONENT24_ARB,               0,
 823             GL_DEPTH_COMPONENT,         GL_UNSIGNED_SHORT,                0,
 824             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_DEPTH,
 825             ARB_DEPTH_TEXTURE,          NULL},
 826     {WINED3DFMT_L16_UNORM,              GL_LUMINANCE16,                   GL_LUMINANCE16,                         0,
 827             GL_LUMINANCE,               GL_UNSIGNED_SHORT,                0,
 828             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
 829             WINED3D_GL_EXT_NONE,        NULL},
 830     {WINED3DFMT_D32_FLOAT,              GL_DEPTH_COMPONENT32F,            GL_DEPTH_COMPONENT32F,                  0,
 831             GL_DEPTH_COMPONENT,         GL_FLOAT,                         0,
 832             WINED3DFMT_FLAG_DEPTH,
 833             ARB_DEPTH_BUFFER_FLOAT,     NULL},
 834     {WINED3DFMT_S8_UINT_D24_FLOAT,      GL_DEPTH32F_STENCIL8,             GL_DEPTH32F_STENCIL8,                   0,
 835             GL_DEPTH_STENCIL,           GL_FLOAT_32_UNSIGNED_INT_24_8_REV, 8,
 836             WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL,
 837             ARB_DEPTH_BUFFER_FLOAT,     &convert_s8_uint_d24_float},
 838     /* Vendor-specific formats */
 839     {WINED3DFMT_ATI2N,                  GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI, GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI, 0,
 840             GL_LUMINANCE_ALPHA,         GL_UNSIGNED_BYTE,                 0,
 841             0,
 842             ATI_TEXTURE_COMPRESSION_3DC, NULL},
 843     {WINED3DFMT_ATI2N,                  GL_COMPRESSED_RED_GREEN_RGTC2_EXT, GL_COMPRESSED_RED_GREEN_RGTC2_EXT,     0,
 844             GL_LUMINANCE_ALPHA,         GL_UNSIGNED_BYTE,                 0,
 845             0,
 846             EXT_TEXTURE_COMPRESSION_RGTC, NULL},
 847 };
 848
 849 static inline int getFmtIdx(WINED3DFORMAT fmt) {
 850     /* First check if the format is at the position of its value.
 851      * This will catch the argb formats before the loop is entered
 852      */
 853     if(fmt < (sizeof(formats) / sizeof(formats[0])) && formats[fmt].format == fmt) {
 854         return fmt;
 855     } else {
 856         unsigned int i;
 857         for(i = 0; i < (sizeof(formats) / sizeof(formats[0])); i++) {
 858             if(formats[i].format == fmt) {
 859                 return i;
 860             }
 861         }
 862     }
 863     return -1;
 864 }
 865
 866 static BOOL init_format_base_info(struct wined3d_gl_info *gl_info)
 867 {
 868     UINT format_count = sizeof(formats) / sizeof(*formats);
 869     UINT i;
 870
 871     gl_info->gl_formats = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, format_count * sizeof(*gl_info->gl_formats));
 872     if (!gl_info->gl_formats)
 873     {
 874         ERR("Failed to allocate memory.\n");
 875         return FALSE;
 876     }
 877
 878     for (i = 0; i < format_count; ++i)
 879     {
 880         struct wined3d_format_desc *desc = &gl_info->gl_formats[i];
 881         desc->format = formats[i].format;
 882         desc->red_mask = formats[i].redMask;
 883         desc->green_mask = formats[i].greenMask;
 884         desc->blue_mask = formats[i].blueMask;
 885         desc->alpha_mask = formats[i].alphaMask;
 886         desc->byte_count = formats[i].bpp;
 887         desc->depth_size = formats[i].depthSize;
 888         desc->stencil_size = formats[i].stencilSize;
 889     }
 890
 891     for (i = 0; i < (sizeof(format_base_flags) / sizeof(*format_base_flags)); ++i)
 892     {
 893         int fmt_idx = getFmtIdx(format_base_flags[i].format);
 894
 895         if (fmt_idx == -1)
 896         {
 897             ERR("Format %s (%#x) not found.\n",
 898                     debug_d3dformat(format_base_flags[i].format), format_base_flags[i].format);
 899             HeapFree(GetProcessHeap(), 0, gl_info->gl_formats);
 900             return FALSE;
 901         }
 902
 903         gl_info->gl_formats[fmt_idx].Flags |= format_base_flags[i].flags;
 904     }
 905
 906     return TRUE;
 907 }
 908
 909 static BOOL init_format_compression_info(struct wined3d_gl_info *gl_info)
 910 {
 911     unsigned int i;
 912
 913     for (i = 0; i < (sizeof(format_compression_info) / sizeof(*format_compression_info)); ++i)
 914     {
 915         struct wined3d_format_desc *format_desc;
 916         int fmt_idx = getFmtIdx(format_compression_info[i].format);
 917
 918         if (fmt_idx == -1)
 919         {
 920             ERR("Format %s (%#x) not found.\n",
 921                     debug_d3dformat(format_compression_info[i].format), format_compression_info[i].format);
 922             return FALSE;
 923         }
 924
 925         format_desc = &gl_info->gl_formats[fmt_idx];
 926         format_desc->block_width = format_compression_info[i].block_width;
 927         format_desc->block_height = format_compression_info[i].block_height;
 928         format_desc->block_byte_count = format_compression_info[i].block_byte_count;
 929         format_desc->Flags |= WINED3DFMT_FLAG_COMPRESSED;
 930     }
 931
 932     return TRUE;
 933 }
 934
 935 /* Context activation is done by the caller. */
 936 static void check_fbo_compat(const struct wined3d_gl_info *gl_info, struct wined3d_format_desc *format_desc)
 937 {
 938     /* Check if the default internal format is supported as a frame buffer
 939      * target, otherwise fall back to the render target internal.
 940      *
 941      * Try to stick to the standard format if possible, this limits precision differences. */
 942     GLenum status;
 943     GLuint tex;
 944
 945     ENTER_GL();
 946
 947     while(glGetError());
 948     glDisable(GL_BLEND);
 949
 950     glGenTextures(1, &tex);
 951     glBindTexture(GL_TEXTURE_2D, tex);
 952
 953     glTexImage2D(GL_TEXTURE_2D, 0, format_desc->glInternal, 16, 16, 0,
 954             format_desc->glFormat, format_desc->glType, NULL);
 955     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 956     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 957
 958     gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0);
 959
 960     status = gl_info->fbo_ops.glCheckFramebufferStatus(GL_FRAMEBUFFER);
 961     checkGLcall("Framebuffer format check");
 962
 963     if (status == GL_FRAMEBUFFER_COMPLETE)
 964     {
 965         TRACE("Format %s is supported as FBO color attachment\n", debug_d3dformat(format_desc->format));
 966         format_desc->Flags |= WINED3DFMT_FLAG_FBO_ATTACHABLE;
 967         format_desc->rtInternal = format_desc->glInternal;
 968     }
 969     else
 970     {
 971         if (!format_desc->rtInternal)
 972         {
 973             if (format_desc->Flags & WINED3DFMT_FLAG_RENDERTARGET)
 974             {
 975                 FIXME("Format %s with rendertarget flag is not supported as FBO color attachment,"
 976                         " and no fallback specified.\n", debug_d3dformat(format_desc->format));
 977                 format_desc->Flags &= ~WINED3DFMT_FLAG_RENDERTARGET;
 978             }
 979             else
 980             {
 981                 TRACE("Format %s is not supported as FBO color attachment.\n", debug_d3dformat(format_desc->format));
 982             }
 983             format_desc->rtInternal = format_desc->glInternal;
 984         }
 985         else
 986         {
 987             TRACE("Format %s is not supported as FBO color attachment, trying rtInternal format as fallback.\n",
 988                     debug_d3dformat(format_desc->format));
 989
 990             while(glGetError());
 991
 992             gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
 993
 994             glTexImage2D(GL_TEXTURE_2D, 0, format_desc->rtInternal, 16, 16, 0,
 995                     format_desc->glFormat, format_desc->glType, NULL);
 996             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 997             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 998
 999             gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0);
1000
1001             status = gl_info->fbo_ops.glCheckFramebufferStatus(GL_FRAMEBUFFER);
1002             checkGLcall("Framebuffer format check");
1003
1004             if (status == GL_FRAMEBUFFER_COMPLETE)
1005             {
1006                 TRACE("Format %s rtInternal format is supported as FBO color attachment\n",
1007                         debug_d3dformat(format_desc->format));
1008             }
1009             else
1010             {
1011                 FIXME("Format %s rtInternal format is not supported as FBO color attachment.\n",
1012                         debug_d3dformat(format_desc->format));
1013                 format_desc->Flags &= ~WINED3DFMT_FLAG_RENDERTARGET;
1014             }
1015         }
1016     }
1017
1018     if (status == GL_FRAMEBUFFER_COMPLETE && format_desc->Flags & WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING)
1019     {
1020         GLuint rb;
1021
1022         if (gl_info->supported[ARB_FRAMEBUFFER_OBJECT]
1023                 || gl_info->supported[EXT_PACKED_DEPTH_STENCIL])
1024         {
1025             gl_info->fbo_ops.glGenRenderbuffers(1, &rb);
1026             gl_info->fbo_ops.glBindRenderbuffer(GL_RENDERBUFFER, rb);
1027             gl_info->fbo_ops.glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, 16, 16);
1028             gl_info->fbo_ops.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rb);
1029             gl_info->fbo_ops.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, rb);
1030             checkGLcall("RB attachment");
1031         }
1032
1033         glEnable(GL_BLEND);
1034         glClear(GL_COLOR_BUFFER_BIT);
1035         if (glGetError() == GL_INVALID_FRAMEBUFFER_OPERATION)
1036         {
1037             while(glGetError());
1038             TRACE("Format doesn't support post-pixelshader blending.\n");
1039             format_desc->Flags &= ~WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING;
1040         }
1041
1042         if (gl_info->supported[ARB_FRAMEBUFFER_OBJECT]
1043                 || gl_info->supported[EXT_PACKED_DEPTH_STENCIL])
1044         {
1045             gl_info->fbo_ops.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, 0);
1046             gl_info->fbo_ops.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, 0);
1047             gl_info->fbo_ops.glDeleteRenderbuffers(1, &rb);
1048             checkGLcall("RB cleanup");
1049         }
1050     }
1051
1052     glDeleteTextures(1, &tex);
1053
1054     LEAVE_GL();
1055 }
1056
1057 /* Context activation is done by the caller. */
1058 static void init_format_fbo_compat_info(struct wined3d_gl_info *gl_info)
1059 {
1060     unsigned int i;
1061     GLuint fbo;
1062
1063     if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
1064     {
1065         ENTER_GL();
1066
1067         gl_info->fbo_ops.glGenFramebuffers(1, &fbo);
1068         gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
1069
1070         LEAVE_GL();
1071     }
1072
1073     for (i = 0; i < sizeof(formats) / sizeof(*formats); ++i)
1074     {
1075         struct wined3d_format_desc *desc = &gl_info->gl_formats[i];
1076
1077         if (!desc->glInternal) continue;
1078
1079         if (desc->Flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL))
1080         {
1081             TRACE("Skipping format %s because it's a depth/stencil format.\n",
1082                     debug_d3dformat(desc->format));
1083             continue;
1084         }
1085
1086         if (desc->Flags & WINED3DFMT_FLAG_COMPRESSED)
1087         {
1088             TRACE("Skipping format %s because it's a compressed format.\n",
1089                     debug_d3dformat(desc->format));
1090             continue;
1091         }
1092
1093         if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
1094         {
1095             TRACE("Checking if format %s is supported as FBO color attachment...\n", debug_d3dformat(desc->format));
1096             check_fbo_compat(gl_info, desc);
1097         }
1098         else
1099         {
1100             desc->rtInternal = desc->glInternal;
1101         }
1102     }
1103
1104     if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
1105     {
1106         ENTER_GL();
1107
1108         gl_info->fbo_ops.glDeleteFramebuffers(1, &fbo);
1109
1110         LEAVE_GL();
1111     }
1112 }
1113
1114 static BOOL init_format_texture_info(struct wined3d_gl_info *gl_info)
1115 {
1116     unsigned int i;
1117
1118     for (i = 0; i < sizeof(format_texture_info) / sizeof(*format_texture_info); ++i)
1119     {
1120         int fmt_idx = getFmtIdx(format_texture_info[i].format);
1121         struct wined3d_format_desc *desc;
1122
1123         if (fmt_idx == -1)
1124         {
1125             ERR("Format %s (%#x) not found.\n",
1126                     debug_d3dformat(format_texture_info[i].format), format_texture_info[i].format);
1127             return FALSE;
1128         }
1129
1130         if (!gl_info->supported[format_texture_info[i].extension]) continue;
1131
1132         desc = &gl_info->gl_formats[fmt_idx];
1133         desc->glInternal = format_texture_info[i].gl_internal;
1134         desc->glGammaInternal = format_texture_info[i].gl_srgb_internal;
1135         desc->rtInternal = format_texture_info[i].gl_rt_internal;
1136         desc->glFormat = format_texture_info[i].gl_format;
1137         desc->glType = format_texture_info[i].gl_type;
1138         desc->color_fixup = COLOR_FIXUP_IDENTITY;
1139         desc->Flags |= format_texture_info[i].flags;
1140         desc->heightscale = 1.0f;
1141
1142         /* Texture conversion stuff */
1143         desc->convert = format_texture_info[i].convert;
1144         desc->conv_byte_count = format_texture_info[i].conv_byte_count;
1145     }
1146
1147     return TRUE;
1148 }
1149
1150 static BOOL color_match(DWORD c1, DWORD c2, BYTE max_diff)
1151 {
1152     if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
1153     c1 >>= 8; c2 >>= 8;
1154     if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
1155     c1 >>= 8; c2 >>= 8;
1156     if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
1157     c1 >>= 8; c2 >>= 8;
1158     if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
1159     return TRUE;
1160 }
1161
1162 /* A context is provided by the caller */
1163 static BOOL check_filter(const struct wined3d_gl_info *gl_info, GLenum internal)
1164 {
1165     GLuint tex, fbo, buffer;
1166     const DWORD data[] = {0x00000000, 0xffffffff};
1167     DWORD readback[16 * 1];
1168     BOOL ret = FALSE;
1169
1170     /* Render a filtered texture and see what happens. This is intended to detect the lack of
1171      * float16 filtering on ATI X1000 class cards. The drivers disable filtering instead of
1172      * falling back to software. If this changes in the future this code will get fooled and
1173      * apps might hit the software path due to incorrectly advertised caps.
1174      *
1175      * Its unlikely that this changes however. GL Games like Mass Effect depend on the filter
1176      * disable fallback, if Apple or ATI ever change the driver behavior they will break more
1177      * than Wine. The Linux binary <= r500 driver is not maintained any more anyway
1178      */
1179
1180     ENTER_GL();
1181     while(glGetError());
1182
1183     glGenTextures(1, &buffer);
1184     glBindTexture(GL_TEXTURE_2D, buffer);
1185     memset(readback, 0x7e, sizeof(readback));
1186     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 16, 1, 0, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, readback);
1187     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1188     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1189     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
1190     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1191     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
1192
1193     glGenTextures(1, &tex);
1194     glBindTexture(GL_TEXTURE_2D, tex);
1195     glTexImage2D(GL_TEXTURE_2D, 0, internal, 2, 1, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, data);
1196     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1197     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
1198     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
1199     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1200     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
1201     glEnable(GL_TEXTURE_2D);
1202
1203     gl_info->fbo_ops.glGenFramebuffers(1, &fbo);
1204     gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
1205     gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, buffer, 0);
1206     glDrawBuffer(GL_COLOR_ATTACHMENT0);
1207
1208     glViewport(0, 0, 16, 1);
1209     glDisable(GL_LIGHTING);
1210     glMatrixMode(GL_MODELVIEW);
1211     glLoadIdentity();
1212     glMatrixMode(GL_PROJECTION);
1213     glLoadIdentity();
1214
1215     glClearColor(0, 1, 0, 0);
1216     glClear(GL_COLOR_BUFFER_BIT);
1217
1218     glBegin(GL_TRIANGLE_STRIP);
1219     glTexCoord2f(0.0, 0.0);
1220     glVertex2f(-1.0f, -1.0f);
1221     glTexCoord2f(1.0, 0.0);
1222     glVertex2f(1.0f, -1.0f);
1223     glTexCoord2f(0.0, 1.0);
1224     glVertex2f(-1.0f, 1.0f);
1225     glTexCoord2f(1.0, 1.0);
1226     glVertex2f(1.0f, 1.0f);
1227     glEnd();
1228
1229     glBindTexture(GL_TEXTURE_2D, buffer);
1230     memset(readback, 0x7f, sizeof(readback));
1231     glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, readback);
1232     if(color_match(readback[6], 0xffffffff, 5) || color_match(readback[6], 0x00000000, 5) ||
1233        color_match(readback[9], 0xffffffff, 5) || color_match(readback[9], 0x00000000, 5))
1234     {
1235         TRACE("Read back colors 0x%08x and 0x%08x close to unfiltered color, asuming no filtering\n",
1236               readback[6], readback[9]);
1237         ret = FALSE;
1238     }
1239     else
1240     {
1241         TRACE("Read back colors are 0x%08x and 0x%08x, assuming texture is filtered\n",
1242               readback[6], readback[9]);
1243         ret = TRUE;
1244     }
1245
1246     gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, 0);
1247     gl_info->fbo_ops.glDeleteFramebuffers(1, &fbo);
1248     glDeleteTextures(1, &tex);
1249     glDeleteTextures(1, &buffer);
1250
1251     if(glGetError())
1252     {
1253         FIXME("Error during filtering test for format %x, returning no filtering\n", internal);
1254         ret = FALSE;
1255     }
1256     LEAVE_GL();
1257     return ret;
1258 }
1259
1260 static void init_format_filter_info(struct wined3d_gl_info *gl_info, enum wined3d_pci_vendor vendor)
1261 {
1262     struct wined3d_format_desc *desc;
1263     unsigned int fmt_idx, i;
1264     WINED3DFORMAT fmts16[] = {
1265         WINED3DFMT_R16_FLOAT,
1266         WINED3DFMT_R16G16_FLOAT,
1267         WINED3DFMT_R16G16B16A16_FLOAT,
1268     };
1269     BOOL filtered;
1270
1271     if(wined3d_settings.offscreen_rendering_mode != ORM_FBO)
1272     {
1273         WARN("No FBO support, or no FBO ORM, guessing filter info from GL caps\n");
1274         if (vendor == HW_VENDOR_NVIDIA && gl_info->supported[ARB_TEXTURE_FLOAT])
1275         {
1276             TRACE("Nvidia card with texture_float support: Assuming float16 blending\n");
1277             filtered = TRUE;
1278         }
1279         else if (gl_info->limits.glsl_varyings > 44)
1280         {
1281             TRACE("More than 44 GLSL varyings - assuming d3d10 card with float16 blending\n");
1282             filtered = TRUE;
1283         }
1284         else
1285         {
1286             TRACE("Assuming no float16 blending\n");
1287             filtered = FALSE;
1288         }
1289
1290         if(filtered)
1291         {
1292             for(i = 0; i < (sizeof(fmts16) / sizeof(*fmts16)); i++)
1293             {
1294                 fmt_idx = getFmtIdx(fmts16[i]);
1295                 gl_info->gl_formats[fmt_idx].Flags |= WINED3DFMT_FLAG_FILTERING;
1296             }
1297         }
1298         return;
1299     }
1300
1301     for(i = 0; i < (sizeof(fmts16) / sizeof(*fmts16)); i++)
1302     {
1303         fmt_idx = getFmtIdx(fmts16[i]);
1304         desc = &gl_info->gl_formats[fmt_idx];
1305         if(!desc->glInternal) continue; /* Not supported by GL */
1306
1307         filtered = check_filter(gl_info, gl_info->gl_formats[fmt_idx].glInternal);
1308         if(filtered)
1309         {
1310             TRACE("Format %s supports filtering\n", debug_d3dformat(fmts16[i]));
1311             desc->Flags |= WINED3DFMT_FLAG_FILTERING;
1312         }
1313         else
1314         {
1315             TRACE("Format %s does not support filtering\n", debug_d3dformat(fmts16[i]));
1316         }
1317     }
1318 }
1319
1320 static void apply_format_fixups(struct wined3d_gl_info *gl_info)
1321 {
1322     int idx;
1323
1324     idx = getFmtIdx(WINED3DFMT_R16_FLOAT);
1325     gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
1326             0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
1327
1328     idx = getFmtIdx(WINED3DFMT_R32_FLOAT);
1329     gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
1330             0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
1331
1332     idx = getFmtIdx(WINED3DFMT_R16G16_UNORM);
1333     gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
1334             0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
1335
1336     idx = getFmtIdx(WINED3DFMT_R16G16_FLOAT);
1337     gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
1338             0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
1339
1340     idx = getFmtIdx(WINED3DFMT_R32G32_FLOAT);
1341     gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
1342             0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
1343
1344     /* V8U8 is supported natively by GL_ATI_envmap_bumpmap and GL_NV_texture_shader.
1345      * V16U16 is only supported by GL_NV_texture_shader. The formats need fixup if
1346      * their extensions are not available. GL_ATI_envmap_bumpmap is not used because
1347      * the only driver that implements it(fglrx) has a buggy implementation.
1348      *
1349      * V8U8 and V16U16 need a fixup of the undefined blue channel. OpenGL
1350      * returns 0.0 when sampling from it, DirectX 1.0. So we always have in-shader
1351      * conversion for this format.
1352      */
1353     if (!gl_info->supported[NV_TEXTURE_SHADER])
1354     {
1355         idx = getFmtIdx(WINED3DFMT_R8G8_SNORM);
1356         gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
1357                 1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
1358         idx = getFmtIdx(WINED3DFMT_R16G16_SNORM);
1359         gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
1360                 1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
1361     }
1362     else
1363     {
1364         idx = getFmtIdx(WINED3DFMT_R8G8_SNORM);
1365         gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
1366                 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
1367
1368         idx = getFmtIdx(WINED3DFMT_R16G16_SNORM);
1369         gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
1370                 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
1371     }
1372
1373     if (!gl_info->supported[NV_TEXTURE_SHADER])
1374     {
1375         /* If GL_NV_texture_shader is not supported, those formats are converted, incompatibly
1376          * with each other
1377          */
1378         idx = getFmtIdx(WINED3DFMT_R5G5_SNORM_L6_UNORM);
1379         gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
1380                 1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Z, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE);
1381         idx = getFmtIdx(WINED3DFMT_R8G8_SNORM_L8X8_UNORM);
1382         gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
1383                 1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_Z, 0, CHANNEL_SOURCE_W);
1384         idx = getFmtIdx(WINED3DFMT_R8G8B8A8_SNORM);
1385         gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
1386                 1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Y, 1, CHANNEL_SOURCE_Z, 1, CHANNEL_SOURCE_W);
1387     }
1388     else
1389     {
1390         /* If GL_NV_texture_shader is supported, WINED3DFMT_L6V5U5 and WINED3DFMT_X8L8V8U8
1391          * are converted at surface loading time, but they do not need any modification in
1392          * the shader, thus they are compatible with all WINED3DFMT_UNKNOWN group formats.
1393          * WINED3DFMT_Q8W8V8U8 doesn't even need load-time conversion
1394          */
1395     }
1396
1397     if (gl_info->supported[EXT_TEXTURE_COMPRESSION_RGTC])
1398     {
1399         idx = getFmtIdx(WINED3DFMT_ATI2N);
1400         gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
1401                 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
1402     }
1403     else if (gl_info->supported[ATI_TEXTURE_COMPRESSION_3DC])
1404     {
1405         idx = getFmtIdx(WINED3DFMT_ATI2N);
1406         gl_info->gl_formats[idx].color_fixup= create_color_fixup_desc(
1407                 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_W, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
1408     }
1409
1410     if (!gl_info->supported[APPLE_YCBCR_422])
1411     {
1412         idx = getFmtIdx(WINED3DFMT_YUY2);
1413         gl_info->gl_formats[idx].color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_YUY2);
1414
1415         idx = getFmtIdx(WINED3DFMT_UYVY);
1416         gl_info->gl_formats[idx].color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_UYVY);
1417     }
1418
1419     idx = getFmtIdx(WINED3DFMT_YV12);
1420     gl_info->gl_formats[idx].heightscale = 1.5f;
1421     gl_info->gl_formats[idx].color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_YV12);
1422
1423     if (gl_info->supported[EXT_PALETTED_TEXTURE] || gl_info->supported[ARB_FRAGMENT_PROGRAM])
1424     {
1425         idx = getFmtIdx(WINED3DFMT_P8_UINT);
1426         gl_info->gl_formats[idx].color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_P8);
1427     }
1428
1429     if (gl_info->supported[ARB_VERTEX_ARRAY_BGRA])
1430     {
1431         idx = getFmtIdx(WINED3DFMT_B8G8R8A8_UNORM);
1432         gl_info->gl_formats[idx].gl_vtx_format = GL_BGRA;
1433     }
1434
1435     if (gl_info->supported[ARB_HALF_FLOAT_VERTEX])
1436     {
1437         /* Do not change the size of the type, it is CPU side. We have to change the GPU-side information though.
1438          * It is the job of the vertex buffer code to make sure that the vbos have the right format */
1439         idx = getFmtIdx(WINED3DFMT_R16G16_FLOAT);
1440         gl_info->gl_formats[idx].gl_vtx_type = GL_HALF_FLOAT; /* == GL_HALF_FLOAT_NV */
1441
1442         idx = getFmtIdx(WINED3DFMT_R16G16B16A16_FLOAT);
1443         gl_info->gl_formats[idx].gl_vtx_type = GL_HALF_FLOAT;
1444     }
1445 }
1446
1447 static BOOL init_format_vertex_info(struct wined3d_gl_info *gl_info)
1448 {
1449     unsigned int i;
1450
1451     for (i = 0; i < (sizeof(format_vertex_info) / sizeof(*format_vertex_info)); ++i)
1452     {
1453         struct wined3d_format_desc *format_desc;
1454         int fmt_idx = getFmtIdx(format_vertex_info[i].format);
1455
1456         if (fmt_idx == -1)
1457         {
1458             ERR("Format %s (%#x) not found.\n",
1459                     debug_d3dformat(format_vertex_info[i].format), format_vertex_info[i].format);
1460             return FALSE;
1461         }
1462
1463         format_desc = &gl_info->gl_formats[fmt_idx];
1464         format_desc->emit_idx = format_vertex_info[i].emit_idx;
1465         format_desc->component_count = format_vertex_info[i].component_count;
1466         format_desc->gl_vtx_type = format_vertex_info[i].gl_vtx_type;
1467         format_desc->gl_vtx_format = format_vertex_info[i].gl_vtx_format;
1468         format_desc->gl_normalized = format_vertex_info[i].gl_normalized;
1469         format_desc->component_size = format_vertex_info[i].component_size;
1470     }
1471
1472     return TRUE;
1473 }
1474
1475 BOOL initPixelFormatsNoGL(struct wined3d_gl_info *gl_info)
1476 {
1477     if (!init_format_base_info(gl_info)) return FALSE;
1478
1479     if (!init_format_compression_info(gl_info))
1480     {
1481         HeapFree(GetProcessHeap(), 0, gl_info->gl_formats);
1482         gl_info->gl_formats = NULL;
1483         return FALSE;
1484     }
1485
1486     return TRUE;
1487 }
1488
1489 /* Context activation is done by the caller. */
1490 BOOL initPixelFormats(struct wined3d_gl_info *gl_info, enum wined3d_pci_vendor vendor)
1491 {
1492     if (!init_format_base_info(gl_info)) return FALSE;
1493
1494     if (!init_format_compression_info(gl_info)) goto fail;
1495     if (!init_format_texture_info(gl_info)) goto fail;
1496     if (!init_format_vertex_info(gl_info)) goto fail;
1497
1498     apply_format_fixups(gl_info);
1499     init_format_fbo_compat_info(gl_info);
1500     init_format_filter_info(gl_info, vendor);
1501
1502     return TRUE;
1503
1504 fail:
1505     HeapFree(GetProcessHeap(), 0, gl_info->gl_formats);
1506     gl_info->gl_formats = NULL;
1507     return FALSE;
1508 }
1509
1510 const struct wined3d_format_desc *getFormatDescEntry(WINED3DFORMAT fmt, const struct wined3d_gl_info *gl_info)
1511 {
1512     int idx = getFmtIdx(fmt);
1513
1514     if(idx == -1) {
1515         FIXME("Can't find format %s(%d) in the format lookup table\n", debug_d3dformat(fmt), fmt);
1516         /* Get the caller a valid pointer */
1517         idx = getFmtIdx(WINED3DFMT_UNKNOWN);
1518     }
1519
1520     return &gl_info->gl_formats[idx];
1521 }
1522
1523 /*****************************************************************************
1524  * Trace formatting of useful values
1525  */
1526 const char* debug_d3dformat(WINED3DFORMAT fmt) {
1527   switch (fmt) {
1528 #define FMT_TO_STR(fmt) case fmt: return #fmt
1529     FMT_TO_STR(WINED3DFMT_UNKNOWN);
1530     FMT_TO_STR(WINED3DFMT_B8G8R8_UNORM);
1531     FMT_TO_STR(WINED3DFMT_B5G5R5X1_UNORM);
1532     FMT_TO_STR(WINED3DFMT_B4G4R4A4_UNORM);
1533     FMT_TO_STR(WINED3DFMT_B2G3R3_UNORM);
1534     FMT_TO_STR(WINED3DFMT_B2G3R3A8_UNORM);
1535     FMT_TO_STR(WINED3DFMT_B4G4R4X4_UNORM);
1536     FMT_TO_STR(WINED3DFMT_R8G8B8X8_UNORM);
1537     FMT_TO_STR(WINED3DFMT_B10G10R10A2_UNORM);
1538     FMT_TO_STR(WINED3DFMT_P8_UINT_A8_UNORM);
1539     FMT_TO_STR(WINED3DFMT_P8_UINT);
1540     FMT_TO_STR(WINED3DFMT_L8_UNORM);
1541     FMT_TO_STR(WINED3DFMT_L8A8_UNORM);
1542     FMT_TO_STR(WINED3DFMT_L4A4_UNORM);
1543     FMT_TO_STR(WINED3DFMT_R5G5_SNORM_L6_UNORM);
1544     FMT_TO_STR(WINED3DFMT_R8G8_SNORM_L8X8_UNORM);
1545     FMT_TO_STR(WINED3DFMT_R10G11B11_SNORM);
1546     FMT_TO_STR(WINED3DFMT_R10G10B10_SNORM_A2_UNORM);
1547     FMT_TO_STR(WINED3DFMT_UYVY);
1548     FMT_TO_STR(WINED3DFMT_YUY2);
1549     FMT_TO_STR(WINED3DFMT_YV12);
1550     FMT_TO_STR(WINED3DFMT_DXT1);
1551     FMT_TO_STR(WINED3DFMT_DXT2);
1552     FMT_TO_STR(WINED3DFMT_DXT3);
1553     FMT_TO_STR(WINED3DFMT_DXT4);
1554     FMT_TO_STR(WINED3DFMT_DXT5);
1555     FMT_TO_STR(WINED3DFMT_MULTI2_ARGB8);
1556     FMT_TO_STR(WINED3DFMT_G8R8_G8B8);
1557     FMT_TO_STR(WINED3DFMT_R8G8_B8G8);
1558     FMT_TO_STR(WINED3DFMT_D16_LOCKABLE);
1559     FMT_TO_STR(WINED3DFMT_D32_UNORM);
1560     FMT_TO_STR(WINED3DFMT_S1_UINT_D15_UNORM);
1561     FMT_TO_STR(WINED3DFMT_X8D24_UNORM);
1562     FMT_TO_STR(WINED3DFMT_S4X4_UINT_D24_UNORM);
1563     FMT_TO_STR(WINED3DFMT_L16_UNORM);
1564     FMT_TO_STR(WINED3DFMT_S8_UINT_D24_FLOAT);
1565     FMT_TO_STR(WINED3DFMT_VERTEXDATA);
1566     FMT_TO_STR(WINED3DFMT_R8G8_SNORM_Cx);
1567     FMT_TO_STR(WINED3DFMT_ATI2N);
1568     FMT_TO_STR(WINED3DFMT_NVHU);
1569     FMT_TO_STR(WINED3DFMT_NVHS);
1570     FMT_TO_STR(WINED3DFMT_R32G32B32A32_TYPELESS);
1571     FMT_TO_STR(WINED3DFMT_R32G32B32A32_FLOAT);
1572     FMT_TO_STR(WINED3DFMT_R32G32B32A32_UINT);
1573     FMT_TO_STR(WINED3DFMT_R32G32B32A32_SINT);
1574     FMT_TO_STR(WINED3DFMT_R32G32B32_TYPELESS);
1575     FMT_TO_STR(WINED3DFMT_R32G32B32_FLOAT);
1576     FMT_TO_STR(WINED3DFMT_R32G32B32_UINT);
1577     FMT_TO_STR(WINED3DFMT_R32G32B32_SINT);
1578     FMT_TO_STR(WINED3DFMT_R16G16B16A16_TYPELESS);
1579     FMT_TO_STR(WINED3DFMT_R16G16B16A16_FLOAT);
1580     FMT_TO_STR(WINED3DFMT_R16G16B16A16_UNORM);
1581     FMT_TO_STR(WINED3DFMT_R16G16B16A16_UINT);
1582     FMT_TO_STR(WINED3DFMT_R16G16B16A16_SNORM);
1583     FMT_TO_STR(WINED3DFMT_R16G16B16A16_SINT);
1584     FMT_TO_STR(WINED3DFMT_R32G32_TYPELESS);
1585     FMT_TO_STR(WINED3DFMT_R32G32_FLOAT);
1586     FMT_TO_STR(WINED3DFMT_R32G32_UINT);
1587     FMT_TO_STR(WINED3DFMT_R32G32_SINT);
1588     FMT_TO_STR(WINED3DFMT_R32G8X24_TYPELESS);
1589     FMT_TO_STR(WINED3DFMT_D32_FLOAT_S8X24_UINT);
1590     FMT_TO_STR(WINED3DFMT_R32_FLOAT_X8X24_TYPELESS);
1591     FMT_TO_STR(WINED3DFMT_X32_TYPELESS_G8X24_UINT);
1592     FMT_TO_STR(WINED3DFMT_R10G10B10A2_TYPELESS);
1593     FMT_TO_STR(WINED3DFMT_R10G10B10A2_UNORM);
1594     FMT_TO_STR(WINED3DFMT_R10G10B10A2_UINT);
1595     FMT_TO_STR(WINED3DFMT_R10G10B10A2_SNORM);
1596     FMT_TO_STR(WINED3DFMT_R11G11B10_FLOAT);
1597     FMT_TO_STR(WINED3DFMT_R8G8B8A8_TYPELESS);
1598     FMT_TO_STR(WINED3DFMT_R8G8B8A8_UNORM);
1599     FMT_TO_STR(WINED3DFMT_R8G8B8A8_UNORM_SRGB);
1600     FMT_TO_STR(WINED3DFMT_R8G8B8A8_UINT);
1601     FMT_TO_STR(WINED3DFMT_R8G8B8A8_SNORM);
1602     FMT_TO_STR(WINED3DFMT_R8G8B8A8_SINT);
1603     FMT_TO_STR(WINED3DFMT_R16G16_TYPELESS);
1604     FMT_TO_STR(WINED3DFMT_R16G16_FLOAT);
1605     FMT_TO_STR(WINED3DFMT_R16G16_UNORM);
1606     FMT_TO_STR(WINED3DFMT_R16G16_UINT);
1607     FMT_TO_STR(WINED3DFMT_R16G16_SNORM);
1608     FMT_TO_STR(WINED3DFMT_R16G16_SINT);
1609     FMT_TO_STR(WINED3DFMT_R32_TYPELESS);
1610     FMT_TO_STR(WINED3DFMT_D32_FLOAT);
1611     FMT_TO_STR(WINED3DFMT_R32_FLOAT);
1612     FMT_TO_STR(WINED3DFMT_R32_UINT);
1613     FMT_TO_STR(WINED3DFMT_R32_SINT);
1614     FMT_TO_STR(WINED3DFMT_R24G8_TYPELESS);
1615     FMT_TO_STR(WINED3DFMT_D24_UNORM_S8_UINT);
1616     FMT_TO_STR(WINED3DFMT_R24_UNORM_X8_TYPELESS);
1617     FMT_TO_STR(WINED3DFMT_X24_TYPELESS_G8_UINT);
1618     FMT_TO_STR(WINED3DFMT_R8G8_TYPELESS);
1619     FMT_TO_STR(WINED3DFMT_R8G8_UNORM);
1620     FMT_TO_STR(WINED3DFMT_R8G8_UINT);
1621     FMT_TO_STR(WINED3DFMT_R8G8_SNORM);
1622     FMT_TO_STR(WINED3DFMT_R8G8_SINT);
1623     FMT_TO_STR(WINED3DFMT_R16_TYPELESS);
1624     FMT_TO_STR(WINED3DFMT_R16_FLOAT);
1625     FMT_TO_STR(WINED3DFMT_D16_UNORM);
1626     FMT_TO_STR(WINED3DFMT_R16_UNORM);
1627     FMT_TO_STR(WINED3DFMT_R16_UINT);
1628     FMT_TO_STR(WINED3DFMT_R16_SNORM);
1629     FMT_TO_STR(WINED3DFMT_R16_SINT);
1630     FMT_TO_STR(WINED3DFMT_R8_TYPELESS);
1631     FMT_TO_STR(WINED3DFMT_R8_UNORM);
1632     FMT_TO_STR(WINED3DFMT_R8_UINT);
1633     FMT_TO_STR(WINED3DFMT_R8_SNORM);
1634     FMT_TO_STR(WINED3DFMT_R8_SINT);
1635     FMT_TO_STR(WINED3DFMT_A8_UNORM);
1636     FMT_TO_STR(WINED3DFMT_R1_UNORM);
1637     FMT_TO_STR(WINED3DFMT_R9G9B9E5_SHAREDEXP);
1638     FMT_TO_STR(WINED3DFMT_R8G8_B8G8_UNORM);
1639     FMT_TO_STR(WINED3DFMT_G8R8_G8B8_UNORM);
1640     FMT_TO_STR(WINED3DFMT_BC1_TYPELESS);
1641     FMT_TO_STR(WINED3DFMT_BC1_UNORM);
1642     FMT_TO_STR(WINED3DFMT_BC1_UNORM_SRGB);
1643     FMT_TO_STR(WINED3DFMT_BC2_TYPELESS);
1644     FMT_TO_STR(WINED3DFMT_BC2_UNORM);
1645     FMT_TO_STR(WINED3DFMT_BC2_UNORM_SRGB);
1646     FMT_TO_STR(WINED3DFMT_BC3_TYPELESS);
1647     FMT_TO_STR(WINED3DFMT_BC3_UNORM);
1648     FMT_TO_STR(WINED3DFMT_BC3_UNORM_SRGB);
1649     FMT_TO_STR(WINED3DFMT_BC4_TYPELESS);
1650     FMT_TO_STR(WINED3DFMT_BC4_UNORM);
1651     FMT_TO_STR(WINED3DFMT_BC4_SNORM);
1652     FMT_TO_STR(WINED3DFMT_BC5_TYPELESS);
1653     FMT_TO_STR(WINED3DFMT_BC5_UNORM);
1654     FMT_TO_STR(WINED3DFMT_BC5_SNORM);
1655     FMT_TO_STR(WINED3DFMT_B5G6R5_UNORM);
1656     FMT_TO_STR(WINED3DFMT_B5G5R5A1_UNORM);
1657     FMT_TO_STR(WINED3DFMT_B8G8R8A8_UNORM);
1658     FMT_TO_STR(WINED3DFMT_B8G8R8X8_UNORM);
1659 #undef FMT_TO_STR
1660   default:
1661     {
1662       char fourcc[5];
1663       fourcc[0] = (char)(fmt);
1664       fourcc[1] = (char)(fmt >> 8);
1665       fourcc[2] = (char)(fmt >> 16);
1666       fourcc[3] = (char)(fmt >> 24);
1667       fourcc[4] = 0;
1668       if( isprint(fourcc[0]) && isprint(fourcc[1]) && isprint(fourcc[2]) && isprint(fourcc[3]) )
1669         FIXME("Unrecognized %u (as fourcc: %s) WINED3DFORMAT!\n", fmt, fourcc);
1670       else
1671         FIXME("Unrecognized %u WINED3DFORMAT!\n", fmt);
1672     }
1673     return "unrecognized";
1674   }
1675 }
1676
1677 const char* debug_d3ddevicetype(WINED3DDEVTYPE devtype) {
1678   switch (devtype) {
1679 #define DEVTYPE_TO_STR(dev) case dev: return #dev
1680     DEVTYPE_TO_STR(WINED3DDEVTYPE_HAL);
1681     DEVTYPE_TO_STR(WINED3DDEVTYPE_REF);
1682     DEVTYPE_TO_STR(WINED3DDEVTYPE_SW);
1683 #undef DEVTYPE_TO_STR
1684   default:
1685     FIXME("Unrecognized %u WINED3DDEVTYPE!\n", devtype);
1686     return "unrecognized";
1687   }
1688 }
1689
1690 const char *debug_d3dusage(DWORD usage)
1691 {
1692     char buf[284];
1693
1694     buf[0] = '\0';
1695 #define WINED3DUSAGE_TO_STR(u) if (usage & u) { strcat(buf, " | "#u); usage &= ~u; }
1696     WINED3DUSAGE_TO_STR(WINED3DUSAGE_RENDERTARGET);
1697     WINED3DUSAGE_TO_STR(WINED3DUSAGE_DEPTHSTENCIL);
1698     WINED3DUSAGE_TO_STR(WINED3DUSAGE_WRITEONLY);
1699     WINED3DUSAGE_TO_STR(WINED3DUSAGE_SOFTWAREPROCESSING);
1700     WINED3DUSAGE_TO_STR(WINED3DUSAGE_DONOTCLIP);
1701     WINED3DUSAGE_TO_STR(WINED3DUSAGE_POINTS);
1702     WINED3DUSAGE_TO_STR(WINED3DUSAGE_RTPATCHES);
1703     WINED3DUSAGE_TO_STR(WINED3DUSAGE_NPATCHES);
1704     WINED3DUSAGE_TO_STR(WINED3DUSAGE_DYNAMIC);
1705     WINED3DUSAGE_TO_STR(WINED3DUSAGE_AUTOGENMIPMAP);
1706     WINED3DUSAGE_TO_STR(WINED3DUSAGE_DMAP);
1707 #undef WINED3DUSAGE_TO_STR
1708     if (usage) FIXME("Unrecognized usage flag(s) %#x\n", usage);
1709
1710     return buf[0] ? wine_dbg_sprintf("%s", &buf[3]) : "0";
1711 }
1712
1713 const char *debug_d3dusagequery(DWORD usagequery)
1714 {
1715     char buf[238];
1716
1717     buf[0] = '\0';
1718 #define WINED3DUSAGEQUERY_TO_STR(u) if (usagequery & u) { strcat(buf, " | "#u); usagequery &= ~u; }
1719     WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_FILTER);
1720     WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_LEGACYBUMPMAP);
1721     WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING);
1722     WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_SRGBREAD);
1723     WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_SRGBWRITE);
1724     WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_VERTEXTEXTURE);
1725     WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_WRAPANDMIP);
1726 #undef WINED3DUSAGEQUERY_TO_STR
1727     if (usagequery) FIXME("Unrecognized usage query flag(s) %#x\n", usagequery);
1728
1729     return buf[0] ? wine_dbg_sprintf("%s", &buf[3]) : "0";
1730 }
1731
1732 const char* debug_d3ddeclmethod(WINED3DDECLMETHOD method) {
1733     switch (method) {
1734 #define WINED3DDECLMETHOD_TO_STR(u) case u: return #u
1735         WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_DEFAULT);
1736         WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_PARTIALU);
1737         WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_PARTIALV);
1738         WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_CROSSUV);
1739         WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_UV);
1740         WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_LOOKUP);
1741         WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_LOOKUPPRESAMPLED);
1742 #undef WINED3DDECLMETHOD_TO_STR
1743         default:
1744             FIXME("Unrecognized %u declaration method!\n", method);
1745             return "unrecognized";
1746     }
1747 }
1748
1749 const char* debug_d3ddeclusage(BYTE usage) {
1750     switch (usage) {
1751 #define WINED3DDECLUSAGE_TO_STR(u) case u: return #u
1752         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_POSITION);
1753         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BLENDWEIGHT);
1754         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BLENDINDICES);
1755         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_NORMAL);
1756         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_PSIZE);
1757         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TEXCOORD);
1758         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TANGENT);
1759         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BINORMAL);
1760         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TESSFACTOR);
1761         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_POSITIONT);
1762         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_COLOR);
1763         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_FOG);
1764         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_DEPTH);
1765         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_SAMPLE);
1766 #undef WINED3DDECLUSAGE_TO_STR
1767         default:
1768             FIXME("Unrecognized %u declaration usage!\n", usage);
1769             return "unrecognized";
1770     }
1771 }
1772
1773 const char* debug_d3dresourcetype(WINED3DRESOURCETYPE res) {
1774   switch (res) {
1775 #define RES_TO_STR(res) case res: return #res
1776     RES_TO_STR(WINED3DRTYPE_SURFACE);
1777     RES_TO_STR(WINED3DRTYPE_VOLUME);
1778     RES_TO_STR(WINED3DRTYPE_TEXTURE);
1779     RES_TO_STR(WINED3DRTYPE_VOLUMETEXTURE);
1780     RES_TO_STR(WINED3DRTYPE_CUBETEXTURE);
1781     RES_TO_STR(WINED3DRTYPE_BUFFER);
1782 #undef  RES_TO_STR
1783   default:
1784     FIXME("Unrecognized %u WINED3DRESOURCETYPE!\n", res);
1785     return "unrecognized";
1786   }
1787 }
1788
1789 const char* debug_d3dprimitivetype(WINED3DPRIMITIVETYPE PrimitiveType) {
1790   switch (PrimitiveType) {
1791 #define PRIM_TO_STR(prim) case prim: return #prim
1792     PRIM_TO_STR(WINED3DPT_UNDEFINED);
1793     PRIM_TO_STR(WINED3DPT_POINTLIST);
1794     PRIM_TO_STR(WINED3DPT_LINELIST);
1795     PRIM_TO_STR(WINED3DPT_LINESTRIP);
1796     PRIM_TO_STR(WINED3DPT_TRIANGLELIST);
1797     PRIM_TO_STR(WINED3DPT_TRIANGLESTRIP);
1798     PRIM_TO_STR(WINED3DPT_TRIANGLEFAN);
1799     PRIM_TO_STR(WINED3DPT_LINELIST_ADJ);
1800     PRIM_TO_STR(WINED3DPT_LINESTRIP_ADJ);
1801     PRIM_TO_STR(WINED3DPT_TRIANGLELIST_ADJ);
1802     PRIM_TO_STR(WINED3DPT_TRIANGLESTRIP_ADJ);
1803 #undef  PRIM_TO_STR
1804   default:
1805     FIXME("Unrecognized %u WINED3DPRIMITIVETYPE!\n", PrimitiveType);
1806     return "unrecognized";
1807   }
1808 }
1809
1810 const char* debug_d3drenderstate(DWORD state) {
1811   switch (state) {
1812 #define D3DSTATE_TO_STR(u) case u: return #u
1813     D3DSTATE_TO_STR(WINED3DRS_ANTIALIAS                 );
1814     D3DSTATE_TO_STR(WINED3DRS_TEXTUREPERSPECTIVE        );
1815     D3DSTATE_TO_STR(WINED3DRS_WRAPU                     );
1816     D3DSTATE_TO_STR(WINED3DRS_WRAPV                     );
1817     D3DSTATE_TO_STR(WINED3DRS_ZENABLE                   );
1818     D3DSTATE_TO_STR(WINED3DRS_FILLMODE                  );
1819     D3DSTATE_TO_STR(WINED3DRS_SHADEMODE                 );
1820     D3DSTATE_TO_STR(WINED3DRS_LINEPATTERN               );
1821     D3DSTATE_TO_STR(WINED3DRS_MONOENABLE                );
1822     D3DSTATE_TO_STR(WINED3DRS_ROP2                      );
1823     D3DSTATE_TO_STR(WINED3DRS_PLANEMASK                 );
1824     D3DSTATE_TO_STR(WINED3DRS_ZWRITEENABLE              );
1825     D3DSTATE_TO_STR(WINED3DRS_ALPHATESTENABLE           );
1826     D3DSTATE_TO_STR(WINED3DRS_LASTPIXEL                 );
1827     D3DSTATE_TO_STR(WINED3DRS_SRCBLEND                  );
1828     D3DSTATE_TO_STR(WINED3DRS_DESTBLEND                 );
1829     D3DSTATE_TO_STR(WINED3DRS_CULLMODE                  );
1830     D3DSTATE_TO_STR(WINED3DRS_ZFUNC                     );
1831     D3DSTATE_TO_STR(WINED3DRS_ALPHAREF                  );
1832     D3DSTATE_TO_STR(WINED3DRS_ALPHAFUNC                 );
1833     D3DSTATE_TO_STR(WINED3DRS_DITHERENABLE              );
1834     D3DSTATE_TO_STR(WINED3DRS_ALPHABLENDENABLE          );
1835     D3DSTATE_TO_STR(WINED3DRS_FOGENABLE                 );
1836     D3DSTATE_TO_STR(WINED3DRS_SPECULARENABLE            );
1837     D3DSTATE_TO_STR(WINED3DRS_ZVISIBLE                  );
1838     D3DSTATE_TO_STR(WINED3DRS_SUBPIXEL                  );
1839     D3DSTATE_TO_STR(WINED3DRS_SUBPIXELX                 );
1840     D3DSTATE_TO_STR(WINED3DRS_STIPPLEDALPHA             );
1841     D3DSTATE_TO_STR(WINED3DRS_FOGCOLOR                  );
1842     D3DSTATE_TO_STR(WINED3DRS_FOGTABLEMODE              );
1843     D3DSTATE_TO_STR(WINED3DRS_FOGSTART                  );
1844     D3DSTATE_TO_STR(WINED3DRS_FOGEND                    );
1845     D3DSTATE_TO_STR(WINED3DRS_FOGDENSITY                );
1846     D3DSTATE_TO_STR(WINED3DRS_STIPPLEENABLE             );
1847     D3DSTATE_TO_STR(WINED3DRS_EDGEANTIALIAS             );
1848     D3DSTATE_TO_STR(WINED3DRS_COLORKEYENABLE            );
1849     D3DSTATE_TO_STR(WINED3DRS_MIPMAPLODBIAS             );
1850     D3DSTATE_TO_STR(WINED3DRS_ZBIAS                     );
1851     D3DSTATE_TO_STR(WINED3DRS_RANGEFOGENABLE            );
1852     D3DSTATE_TO_STR(WINED3DRS_ANISOTROPY                );
1853     D3DSTATE_TO_STR(WINED3DRS_FLUSHBATCH                );
1854     D3DSTATE_TO_STR(WINED3DRS_TRANSLUCENTSORTINDEPENDENT);
1855     D3DSTATE_TO_STR(WINED3DRS_STENCILENABLE             );
1856     D3DSTATE_TO_STR(WINED3DRS_STENCILFAIL               );
1857     D3DSTATE_TO_STR(WINED3DRS_STENCILZFAIL              );
1858     D3DSTATE_TO_STR(WINED3DRS_STENCILPASS               );
1859     D3DSTATE_TO_STR(WINED3DRS_STENCILFUNC               );
1860     D3DSTATE_TO_STR(WINED3DRS_STENCILREF                );
1861     D3DSTATE_TO_STR(WINED3DRS_STENCILMASK               );
1862     D3DSTATE_TO_STR(WINED3DRS_STENCILWRITEMASK          );
1863     D3DSTATE_TO_STR(WINED3DRS_TEXTUREFACTOR             );
1864     D3DSTATE_TO_STR(WINED3DRS_WRAP0                     );
1865     D3DSTATE_TO_STR(WINED3DRS_WRAP1                     );
1866     D3DSTATE_TO_STR(WINED3DRS_WRAP2                     );
1867     D3DSTATE_TO_STR(WINED3DRS_WRAP3                     );
1868     D3DSTATE_TO_STR(WINED3DRS_WRAP4                     );
1869     D3DSTATE_TO_STR(WINED3DRS_WRAP5                     );
1870     D3DSTATE_TO_STR(WINED3DRS_WRAP6                     );
1871     D3DSTATE_TO_STR(WINED3DRS_WRAP7                     );
1872     D3DSTATE_TO_STR(WINED3DRS_CLIPPING                  );
1873     D3DSTATE_TO_STR(WINED3DRS_LIGHTING                  );
1874     D3DSTATE_TO_STR(WINED3DRS_EXTENTS                   );
1875     D3DSTATE_TO_STR(WINED3DRS_AMBIENT                   );
1876     D3DSTATE_TO_STR(WINED3DRS_FOGVERTEXMODE             );
1877     D3DSTATE_TO_STR(WINED3DRS_COLORVERTEX               );
1878     D3DSTATE_TO_STR(WINED3DRS_LOCALVIEWER               );
1879     D3DSTATE_TO_STR(WINED3DRS_NORMALIZENORMALS          );
1880     D3DSTATE_TO_STR(WINED3DRS_COLORKEYBLENDENABLE       );
1881     D3DSTATE_TO_STR(WINED3DRS_DIFFUSEMATERIALSOURCE     );
1882     D3DSTATE_TO_STR(WINED3DRS_SPECULARMATERIALSOURCE    );
1883     D3DSTATE_TO_STR(WINED3DRS_AMBIENTMATERIALSOURCE     );
1884     D3DSTATE_TO_STR(WINED3DRS_EMISSIVEMATERIALSOURCE    );
1885     D3DSTATE_TO_STR(WINED3DRS_VERTEXBLEND               );
1886     D3DSTATE_TO_STR(WINED3DRS_CLIPPLANEENABLE           );
1887     D3DSTATE_TO_STR(WINED3DRS_SOFTWAREVERTEXPROCESSING  );
1888     D3DSTATE_TO_STR(WINED3DRS_POINTSIZE                 );
1889     D3DSTATE_TO_STR(WINED3DRS_POINTSIZE_MIN             );
1890     D3DSTATE_TO_STR(WINED3DRS_POINTSPRITEENABLE         );
1891     D3DSTATE_TO_STR(WINED3DRS_POINTSCALEENABLE          );
1892     D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_A              );
1893     D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_B              );
1894     D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_C              );
1895     D3DSTATE_TO_STR(WINED3DRS_MULTISAMPLEANTIALIAS      );
1896     D3DSTATE_TO_STR(WINED3DRS_MULTISAMPLEMASK           );
1897     D3DSTATE_TO_STR(WINED3DRS_PATCHEDGESTYLE            );
1898     D3DSTATE_TO_STR(WINED3DRS_PATCHSEGMENTS             );
1899     D3DSTATE_TO_STR(WINED3DRS_DEBUGMONITORTOKEN         );
1900     D3DSTATE_TO_STR(WINED3DRS_POINTSIZE_MAX             );
1901     D3DSTATE_TO_STR(WINED3DRS_INDEXEDVERTEXBLENDENABLE  );
1902     D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE          );
1903     D3DSTATE_TO_STR(WINED3DRS_TWEENFACTOR               );
1904     D3DSTATE_TO_STR(WINED3DRS_BLENDOP                   );
1905     D3DSTATE_TO_STR(WINED3DRS_POSITIONDEGREE            );
1906     D3DSTATE_TO_STR(WINED3DRS_NORMALDEGREE              );
1907     D3DSTATE_TO_STR(WINED3DRS_SCISSORTESTENABLE         );
1908     D3DSTATE_TO_STR(WINED3DRS_SLOPESCALEDEPTHBIAS       );
1909     D3DSTATE_TO_STR(WINED3DRS_ANTIALIASEDLINEENABLE     );
1910     D3DSTATE_TO_STR(WINED3DRS_MINTESSELLATIONLEVEL      );
1911     D3DSTATE_TO_STR(WINED3DRS_MAXTESSELLATIONLEVEL      );
1912     D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_X            );
1913     D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_Y            );
1914     D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_Z            );
1915     D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_W            );
1916     D3DSTATE_TO_STR(WINED3DRS_ENABLEADAPTIVETESSELLATION);
1917     D3DSTATE_TO_STR(WINED3DRS_TWOSIDEDSTENCILMODE       );
1918     D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILFAIL           );
1919     D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILZFAIL          );
1920     D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILPASS           );
1921     D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILFUNC           );
1922     D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE1         );
1923     D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE2         );
1924     D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE3         );
1925     D3DSTATE_TO_STR(WINED3DRS_BLENDFACTOR               );
1926     D3DSTATE_TO_STR(WINED3DRS_SRGBWRITEENABLE           );
1927     D3DSTATE_TO_STR(WINED3DRS_DEPTHBIAS                 );
1928     D3DSTATE_TO_STR(WINED3DRS_WRAP8                     );
1929     D3DSTATE_TO_STR(WINED3DRS_WRAP9                     );
1930     D3DSTATE_TO_STR(WINED3DRS_WRAP10                    );
1931     D3DSTATE_TO_STR(WINED3DRS_WRAP11                    );
1932     D3DSTATE_TO_STR(WINED3DRS_WRAP12                    );
1933     D3DSTATE_TO_STR(WINED3DRS_WRAP13                    );
1934     D3DSTATE_TO_STR(WINED3DRS_WRAP14                    );
1935     D3DSTATE_TO_STR(WINED3DRS_WRAP15                    );
1936     D3DSTATE_TO_STR(WINED3DRS_SEPARATEALPHABLENDENABLE  );
1937     D3DSTATE_TO_STR(WINED3DRS_SRCBLENDALPHA             );
1938     D3DSTATE_TO_STR(WINED3DRS_DESTBLENDALPHA            );
1939     D3DSTATE_TO_STR(WINED3DRS_BLENDOPALPHA              );
1940 #undef D3DSTATE_TO_STR
1941   default:
1942     FIXME("Unrecognized %u render state!\n", state);
1943     return "unrecognized";
1944   }
1945 }
1946
1947 const char* debug_d3dsamplerstate(DWORD state) {
1948   switch (state) {
1949 #define D3DSTATE_TO_STR(u) case u: return #u
1950     D3DSTATE_TO_STR(WINED3DSAMP_BORDERCOLOR  );
1951     D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSU     );
1952     D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSV     );
1953     D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSW     );
1954     D3DSTATE_TO_STR(WINED3DSAMP_MAGFILTER    );
1955     D3DSTATE_TO_STR(WINED3DSAMP_MINFILTER    );
1956     D3DSTATE_TO_STR(WINED3DSAMP_MIPFILTER    );
1957     D3DSTATE_TO_STR(WINED3DSAMP_MIPMAPLODBIAS);
1958     D3DSTATE_TO_STR(WINED3DSAMP_MAXMIPLEVEL  );
1959     D3DSTATE_TO_STR(WINED3DSAMP_MAXANISOTROPY);
1960     D3DSTATE_TO_STR(WINED3DSAMP_SRGBTEXTURE  );
1961     D3DSTATE_TO_STR(WINED3DSAMP_ELEMENTINDEX );
1962     D3DSTATE_TO_STR(WINED3DSAMP_DMAPOFFSET   );
1963 #undef D3DSTATE_TO_STR
1964   default:
1965     FIXME("Unrecognized %u sampler state!\n", state);
1966     return "unrecognized";
1967   }
1968 }
1969
1970 const char *debug_d3dtexturefiltertype(WINED3DTEXTUREFILTERTYPE filter_type) {
1971     switch (filter_type) {
1972 #define D3DTEXTUREFILTERTYPE_TO_STR(u) case u: return #u
1973         D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_NONE);
1974         D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_POINT);
1975         D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_LINEAR);
1976         D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_ANISOTROPIC);
1977         D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_FLATCUBIC);
1978         D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_GAUSSIANCUBIC);
1979         D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_PYRAMIDALQUAD);
1980         D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_GAUSSIANQUAD);
1981 #undef D3DTEXTUREFILTERTYPE_TO_STR
1982         default:
1983             FIXME("Unrecognied texture filter type 0x%08x\n", filter_type);
1984             return "unrecognized";
1985     }
1986 }
1987
1988 const char* debug_d3dtexturestate(DWORD state) {
1989   switch (state) {
1990 #define D3DSTATE_TO_STR(u) case u: return #u
1991     D3DSTATE_TO_STR(WINED3DTSS_COLOROP               );
1992     D3DSTATE_TO_STR(WINED3DTSS_COLORARG1             );
1993     D3DSTATE_TO_STR(WINED3DTSS_COLORARG2             );
1994     D3DSTATE_TO_STR(WINED3DTSS_ALPHAOP               );
1995     D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG1             );
1996     D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG2             );
1997     D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT00          );
1998     D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT01          );
1999     D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT10          );
2000     D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT11          );
2001     D3DSTATE_TO_STR(WINED3DTSS_TEXCOORDINDEX         );
2002     D3DSTATE_TO_STR(WINED3DTSS_BUMPENVLSCALE         );
2003     D3DSTATE_TO_STR(WINED3DTSS_BUMPENVLOFFSET        );
2004     D3DSTATE_TO_STR(WINED3DTSS_TEXTURETRANSFORMFLAGS );
2005     D3DSTATE_TO_STR(WINED3DTSS_COLORARG0             );
2006     D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG0             );
2007     D3DSTATE_TO_STR(WINED3DTSS_RESULTARG             );
2008     D3DSTATE_TO_STR(WINED3DTSS_CONSTANT              );
2009 #undef D3DSTATE_TO_STR
2010   default:
2011     FIXME("Unrecognized %u texture state!\n", state);
2012     return "unrecognized";
2013   }
2014 }
2015
2016 const char* debug_d3dtop(WINED3DTEXTUREOP d3dtop) {
2017     switch (d3dtop) {
2018 #define D3DTOP_TO_STR(u) case u: return #u
2019         D3DTOP_TO_STR(WINED3DTOP_DISABLE);
2020         D3DTOP_TO_STR(WINED3DTOP_SELECTARG1);
2021         D3DTOP_TO_STR(WINED3DTOP_SELECTARG2);
2022         D3DTOP_TO_STR(WINED3DTOP_MODULATE);
2023         D3DTOP_TO_STR(WINED3DTOP_MODULATE2X);
2024         D3DTOP_TO_STR(WINED3DTOP_MODULATE4X);
2025         D3DTOP_TO_STR(WINED3DTOP_ADD);
2026         D3DTOP_TO_STR(WINED3DTOP_ADDSIGNED);
2027         D3DTOP_TO_STR(WINED3DTOP_ADDSIGNED2X);
2028         D3DTOP_TO_STR(WINED3DTOP_SUBTRACT);
2029         D3DTOP_TO_STR(WINED3DTOP_ADDSMOOTH);
2030         D3DTOP_TO_STR(WINED3DTOP_BLENDDIFFUSEALPHA);
2031         D3DTOP_TO_STR(WINED3DTOP_BLENDTEXTUREALPHA);
2032         D3DTOP_TO_STR(WINED3DTOP_BLENDFACTORALPHA);
2033         D3DTOP_TO_STR(WINED3DTOP_BLENDTEXTUREALPHAPM);
2034         D3DTOP_TO_STR(WINED3DTOP_BLENDCURRENTALPHA);
2035         D3DTOP_TO_STR(WINED3DTOP_PREMODULATE);
2036         D3DTOP_TO_STR(WINED3DTOP_MODULATEALPHA_ADDCOLOR);
2037         D3DTOP_TO_STR(WINED3DTOP_MODULATECOLOR_ADDALPHA);
2038         D3DTOP_TO_STR(WINED3DTOP_MODULATEINVALPHA_ADDCOLOR);
2039         D3DTOP_TO_STR(WINED3DTOP_MODULATEINVCOLOR_ADDALPHA);
2040         D3DTOP_TO_STR(WINED3DTOP_BUMPENVMAP);
2041         D3DTOP_TO_STR(WINED3DTOP_BUMPENVMAPLUMINANCE);
2042         D3DTOP_TO_STR(WINED3DTOP_DOTPRODUCT3);
2043         D3DTOP_TO_STR(WINED3DTOP_MULTIPLYADD);
2044         D3DTOP_TO_STR(WINED3DTOP_LERP);
2045 #undef D3DTOP_TO_STR
2046         default:
2047             FIXME("Unrecognized %u WINED3DTOP\n", d3dtop);
2048             return "unrecognized";
2049     }
2050 }
2051
2052 const char* debug_d3dtstype(WINED3DTRANSFORMSTATETYPE tstype) {
2053     switch (tstype) {
2054 #define TSTYPE_TO_STR(tstype) case tstype: return #tstype
2055     TSTYPE_TO_STR(WINED3DTS_VIEW);
2056     TSTYPE_TO_STR(WINED3DTS_PROJECTION);
2057     TSTYPE_TO_STR(WINED3DTS_TEXTURE0);
2058     TSTYPE_TO_STR(WINED3DTS_TEXTURE1);
2059     TSTYPE_TO_STR(WINED3DTS_TEXTURE2);
2060     TSTYPE_TO_STR(WINED3DTS_TEXTURE3);
2061     TSTYPE_TO_STR(WINED3DTS_TEXTURE4);
2062     TSTYPE_TO_STR(WINED3DTS_TEXTURE5);
2063     TSTYPE_TO_STR(WINED3DTS_TEXTURE6);
2064     TSTYPE_TO_STR(WINED3DTS_TEXTURE7);
2065     TSTYPE_TO_STR(WINED3DTS_WORLDMATRIX(0));
2066 #undef TSTYPE_TO_STR
2067     default:
2068         if (tstype > 256 && tstype < 512) {
2069             FIXME("WINED3DTS_WORLDMATRIX(%u). 1..255 not currently supported\n", tstype);
2070             return ("WINED3DTS_WORLDMATRIX > 0");
2071         }
2072         FIXME("Unrecognized %u WINED3DTS\n", tstype);
2073         return "unrecognized";
2074     }
2075 }
2076
2077 const char *debug_d3dstate(DWORD state)
2078 {
2079     if (STATE_IS_RENDER(state))
2080         return wine_dbg_sprintf("STATE_RENDER(%s)", debug_d3drenderstate(state - STATE_RENDER(0)));
2081     if (STATE_IS_TEXTURESTAGE(state))
2082     {
2083         DWORD texture_stage = (state - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1);
2084         DWORD texture_state = state - STATE_TEXTURESTAGE(texture_stage, 0);
2085         return wine_dbg_sprintf("STATE_TEXTURESTAGE(%#x, %s)",
2086                 texture_stage, debug_d3dtexturestate(texture_state));
2087     }
2088     if (STATE_IS_SAMPLER(state))
2089         return wine_dbg_sprintf("STATE_SAMPLER(%#x)", state - STATE_SAMPLER(0));
2090     if (STATE_IS_PIXELSHADER(state))
2091         return "STATE_PIXELSHADER";
2092     if (STATE_IS_TRANSFORM(state))
2093         return wine_dbg_sprintf("STATE_TRANSFORM(%s)", debug_d3dtstype(state - STATE_TRANSFORM(0)));
2094     if (STATE_IS_STREAMSRC(state))
2095         return "STATE_STREAMSRC";
2096     if (STATE_IS_INDEXBUFFER(state))
2097         return "STATE_INDEXBUFFER";
2098     if (STATE_IS_VDECL(state))
2099         return "STATE_VDECL";
2100     if (STATE_IS_VSHADER(state))
2101         return "STATE_VSHADER";
2102     if (STATE_IS_VIEWPORT(state))
2103         return "STATE_VIEWPORT";
2104     if (STATE_IS_VERTEXSHADERCONSTANT(state))
2105         return "STATE_VERTEXSHADERCONSTANT";
2106     if (STATE_IS_PIXELSHADERCONSTANT(state))
2107         return "STATE_PIXELSHADERCONSTANT";
2108     if (STATE_IS_ACTIVELIGHT(state))
2109         return wine_dbg_sprintf("STATE_ACTIVELIGHT(%#x)", state - STATE_ACTIVELIGHT(0));
2110     if (STATE_IS_SCISSORRECT(state))
2111         return "STATE_SCISSORRECT";
2112     if (STATE_IS_CLIPPLANE(state))
2113         return wine_dbg_sprintf("STATE_CLIPPLANE(%#x)", state - STATE_CLIPPLANE(0));
2114     if (STATE_IS_MATERIAL(state))
2115         return "STATE_MATERIAL";
2116     if (STATE_IS_FRONTFACE(state))
2117         return "STATE_FRONTFACE";
2118
2119     return wine_dbg_sprintf("UNKNOWN_STATE(%#x)", state);
2120 }
2121
2122 const char* debug_d3dpool(WINED3DPOOL Pool) {
2123   switch (Pool) {
2124 #define POOL_TO_STR(p) case p: return #p
2125     POOL_TO_STR(WINED3DPOOL_DEFAULT);
2126     POOL_TO_STR(WINED3DPOOL_MANAGED);
2127     POOL_TO_STR(WINED3DPOOL_SYSTEMMEM);
2128     POOL_TO_STR(WINED3DPOOL_SCRATCH);
2129 #undef  POOL_TO_STR
2130   default:
2131     FIXME("Unrecognized %u WINED3DPOOL!\n", Pool);
2132     return "unrecognized";
2133   }
2134 }
2135
2136 const char *debug_fbostatus(GLenum status) {
2137     switch(status) {
2138 #define FBOSTATUS_TO_STR(u) case u: return #u
2139         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_COMPLETE);
2140         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT);
2141         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT);
2142         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT);
2143         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT);
2144         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER);
2145         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER);
2146         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE);
2147         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_UNSUPPORTED);
2148         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_UNDEFINED);
2149 #undef FBOSTATUS_TO_STR
2150         default:
2151             FIXME("Unrecognied FBO status 0x%08x\n", status);
2152             return "unrecognized";
2153     }
2154 }
2155
2156 const char *debug_glerror(GLenum error) {
2157     switch(error) {
2158 #define GLERROR_TO_STR(u) case u: return #u
2159         GLERROR_TO_STR(GL_NO_ERROR);
2160         GLERROR_TO_STR(GL_INVALID_ENUM);
2161         GLERROR_TO_STR(GL_INVALID_VALUE);
2162         GLERROR_TO_STR(GL_INVALID_OPERATION);
2163         GLERROR_TO_STR(GL_STACK_OVERFLOW);
2164         GLERROR_TO_STR(GL_STACK_UNDERFLOW);
2165         GLERROR_TO_STR(GL_OUT_OF_MEMORY);
2166         GLERROR_TO_STR(GL_INVALID_FRAMEBUFFER_OPERATION);
2167 #undef GLERROR_TO_STR
2168         default:
2169             FIXME("Unrecognied GL error 0x%08x\n", error);
2170             return "unrecognized";
2171     }
2172 }
2173
2174 const char *debug_d3dbasis(WINED3DBASISTYPE basis) {
2175     switch(basis) {
2176         case WINED3DBASIS_BEZIER:       return "WINED3DBASIS_BEZIER";
2177         case WINED3DBASIS_BSPLINE:      return "WINED3DBASIS_BSPLINE";
2178         case WINED3DBASIS_INTERPOLATE:  return "WINED3DBASIS_INTERPOLATE";
2179         default:                        return "unrecognized";
2180     }
2181 }
2182
2183 const char *debug_d3ddegree(WINED3DDEGREETYPE degree) {
2184     switch(degree) {
2185         case WINED3DDEGREE_LINEAR:      return "WINED3DDEGREE_LINEAR";
2186         case WINED3DDEGREE_QUADRATIC:   return "WINED3DDEGREE_QUADRATIC";
2187         case WINED3DDEGREE_CUBIC:       return "WINED3DDEGREE_CUBIC";
2188         case WINED3DDEGREE_QUINTIC:     return "WINED3DDEGREE_QUINTIC";
2189         default:                        return "unrecognized";
2190     }
2191 }
2192
2193 static const char *debug_fixup_channel_source(enum fixup_channel_source source)
2194 {
2195     switch(source)
2196     {
2197 #define WINED3D_TO_STR(x) case x: return #x
2198         WINED3D_TO_STR(CHANNEL_SOURCE_ZERO);
2199         WINED3D_TO_STR(CHANNEL_SOURCE_ONE);
2200         WINED3D_TO_STR(CHANNEL_SOURCE_X);
2201         WINED3D_TO_STR(CHANNEL_SOURCE_Y);
2202         WINED3D_TO_STR(CHANNEL_SOURCE_Z);
2203         WINED3D_TO_STR(CHANNEL_SOURCE_W);
2204         WINED3D_TO_STR(CHANNEL_SOURCE_COMPLEX0);
2205         WINED3D_TO_STR(CHANNEL_SOURCE_COMPLEX1);
2206 #undef WINED3D_TO_STR
2207         default:
2208             FIXME("Unrecognized fixup_channel_source %#x\n", source);
2209             return "unrecognized";
2210     }
2211 }
2212
2213 static const char *debug_complex_fixup(enum complex_fixup fixup)
2214 {
2215     switch(fixup)
2216     {
2217 #define WINED3D_TO_STR(x) case x: return #x
2218         WINED3D_TO_STR(COMPLEX_FIXUP_YUY2);
2219         WINED3D_TO_STR(COMPLEX_FIXUP_UYVY);
2220         WINED3D_TO_STR(COMPLEX_FIXUP_YV12);
2221         WINED3D_TO_STR(COMPLEX_FIXUP_P8);
2222 #undef WINED3D_TO_STR
2223         default:
2224             FIXME("Unrecognized complex fixup %#x\n", fixup);
2225             return "unrecognized";
2226     }
2227 }
2228
2229 void dump_color_fixup_desc(struct color_fixup_desc fixup)
2230 {
2231     if (is_complex_fixup(fixup))
2232     {
2233         TRACE("\tComplex: %s\n", debug_complex_fixup(get_complex_fixup(fixup)));
2234         return;
2235     }
2236
2237     TRACE("\tX: %s%s\n", debug_fixup_channel_source(fixup.x_source), fixup.x_sign_fixup ? ", SIGN_FIXUP" : "");
2238     TRACE("\tY: %s%s\n", debug_fixup_channel_source(fixup.y_source), fixup.y_sign_fixup ? ", SIGN_FIXUP" : "");
2239     TRACE("\tZ: %s%s\n", debug_fixup_channel_source(fixup.z_source), fixup.z_sign_fixup ? ", SIGN_FIXUP" : "");
2240     TRACE("\tW: %s%s\n", debug_fixup_channel_source(fixup.w_source), fixup.w_sign_fixup ? ", SIGN_FIXUP" : "");
2241 }
2242
2243 const char *debug_surflocation(DWORD flag) {
2244     char buf[128];
2245
2246     buf[0] = 0;
2247     if(flag & SFLAG_INSYSMEM) strcat(buf, " | SFLAG_INSYSMEM");
2248     if(flag & SFLAG_INDRAWABLE) strcat(buf, " | SFLAG_INDRAWABLE");
2249     if(flag & SFLAG_INTEXTURE) strcat(buf, " | SFLAG_INTEXTURE");
2250     if(flag & SFLAG_INSRGBTEX) strcat(buf, " | SFLAG_INSRGBTEX");
2251     return wine_dbg_sprintf("%s", buf[0] ? buf + 3 : "0");
2252 }
2253
2254 /*****************************************************************************
2255  * Useful functions mapping GL <-> D3D values
2256  */
2257 GLenum StencilOp(DWORD op) {
2258     switch(op) {
2259     case WINED3DSTENCILOP_KEEP    : return GL_KEEP;
2260     case WINED3DSTENCILOP_ZERO    : return GL_ZERO;
2261     case WINED3DSTENCILOP_REPLACE : return GL_REPLACE;
2262     case WINED3DSTENCILOP_INCRSAT : return GL_INCR;
2263     case WINED3DSTENCILOP_DECRSAT : return GL_DECR;
2264     case WINED3DSTENCILOP_INVERT  : return GL_INVERT;
2265     case WINED3DSTENCILOP_INCR    : return GL_INCR_WRAP_EXT;
2266     case WINED3DSTENCILOP_DECR    : return GL_DECR_WRAP_EXT;
2267     default:
2268         FIXME("Unrecognized stencil op %d\n", op);
2269         return GL_KEEP;
2270     }
2271 }
2272
2273 GLenum CompareFunc(DWORD func) {
2274     switch ((WINED3DCMPFUNC)func) {
2275     case WINED3DCMP_NEVER        : return GL_NEVER;
2276     case WINED3DCMP_LESS         : return GL_LESS;
2277     case WINED3DCMP_EQUAL        : return GL_EQUAL;
2278     case WINED3DCMP_LESSEQUAL    : return GL_LEQUAL;
2279     case WINED3DCMP_GREATER      : return GL_GREATER;
2280     case WINED3DCMP_NOTEQUAL     : return GL_NOTEQUAL;
2281     case WINED3DCMP_GREATEREQUAL : return GL_GEQUAL;
2282     case WINED3DCMP_ALWAYS       : return GL_ALWAYS;
2283     default:
2284         FIXME("Unrecognized WINED3DCMPFUNC value %d\n", func);
2285         return 0;
2286     }
2287 }
2288
2289 BOOL is_invalid_op(IWineD3DDeviceImpl *This, int stage, WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3) {
2290     if (op == WINED3DTOP_DISABLE) return FALSE;
2291     if (This->stateBlock->textures[stage]) return FALSE;
2292
2293     if ((arg1 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
2294             && op != WINED3DTOP_SELECTARG2) return TRUE;
2295     if ((arg2 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
2296             && op != WINED3DTOP_SELECTARG1) return TRUE;
2297     if ((arg3 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
2298             && (op == WINED3DTOP_MULTIPLYADD || op == WINED3DTOP_LERP)) return TRUE;
2299
2300     return FALSE;
2301 }
2302
2303 /* Setup this textures matrix according to the texture flags*/
2304 /* GL locking is done by the caller (state handler) */
2305 void set_texture_matrix(const float *smat, DWORD flags, BOOL calculatedCoords, BOOL transformed,
2306         WINED3DFORMAT vtx_fmt, BOOL ffp_proj_control)
2307 {
2308     float mat[16];
2309
2310     glMatrixMode(GL_TEXTURE);
2311     checkGLcall("glMatrixMode(GL_TEXTURE)");
2312
2313     if (flags == WINED3DTTFF_DISABLE || flags == WINED3DTTFF_COUNT1 || transformed) {
2314         glLoadIdentity();
2315         checkGLcall("glLoadIdentity()");
2316         return;
2317     }
2318
2319     if (flags == (WINED3DTTFF_COUNT1|WINED3DTTFF_PROJECTED)) {
2320         ERR("Invalid texture transform flags: WINED3DTTFF_COUNT1|WINED3DTTFF_PROJECTED\n");
2321         return;
2322     }
2323
2324     memcpy(mat, smat, 16 * sizeof(float));
2325
2326     if (flags & WINED3DTTFF_PROJECTED) {
2327         if(!ffp_proj_control) {
2328             switch (flags & ~WINED3DTTFF_PROJECTED) {
2329             case WINED3DTTFF_COUNT2:
2330                 mat[3] = mat[1], mat[7] = mat[5], mat[11] = mat[9], mat[15] = mat[13];
2331                 mat[1] = mat[5] = mat[9] = mat[13] = 0;
2332                 break;
2333             case WINED3DTTFF_COUNT3:
2334                 mat[3] = mat[2], mat[7] = mat[6], mat[11] = mat[10], mat[15] = mat[14];
2335                 mat[2] = mat[6] = mat[10] = mat[14] = 0;
2336                 break;
2337             }
2338         }
2339     } else { /* under directx the R/Z coord can be used for translation, under opengl we use the Q coord instead */
2340         if(!calculatedCoords) {
2341             switch(vtx_fmt)
2342             {
2343                 case WINED3DFMT_R32_FLOAT:
2344                     /* Direct3D passes the default 1.0 in the 2nd coord, while gl passes it in the 4th.
2345                      * swap 2nd and 4th coord. No need to store the value of mat[12] in mat[4] because
2346                      * the input value to the transformation will be 0, so the matrix value is irrelevant
2347                      */
2348                     mat[12] = mat[4];
2349                     mat[13] = mat[5];
2350                     mat[14] = mat[6];
2351                     mat[15] = mat[7];
2352                     break;
2353                 case WINED3DFMT_R32G32_FLOAT:
2354                     /* See above, just 3rd and 4th coord
2355                     */
2356                     mat[12] = mat[8];
2357                     mat[13] = mat[9];
2358                     mat[14] = mat[10];
2359                     mat[15] = mat[11];
2360                     break;
2361                 case WINED3DFMT_R32G32B32_FLOAT: /* Opengl defaults match dx defaults */
2362                 case WINED3DFMT_R32G32B32A32_FLOAT: /* No defaults apply, all app defined */
2363
2364                 /* This is to prevent swapping the matrix lines and put the default 4th coord = 1.0
2365                  * into a bad place. The division elimination below will apply to make sure the
2366                  * 1.0 doesn't do anything bad. The caller will set this value if the stride is 0
2367                  */
2368                 case WINED3DFMT_UNKNOWN: /* No texture coords, 0/0/0/1 defaults are passed */
2369                     break;
2370                 default:
2371                     FIXME("Unexpected fixed function texture coord input\n");
2372             }
2373         }
2374         if(!ffp_proj_control) {
2375             switch (flags & ~WINED3DTTFF_PROJECTED) {
2376                 /* case WINED3DTTFF_COUNT1: Won't ever get here */
2377                 case WINED3DTTFF_COUNT2: mat[2] = mat[6] = mat[10] = mat[14] = 0;
2378                 /* OpenGL divides the first 3 vertex coord by the 4th by default,
2379                 * which is essentially the same as D3DTTFF_PROJECTED. Make sure that
2380                 * the 4th coord evaluates to 1.0 to eliminate that.
2381                 *
2382                 * If the fixed function pipeline is used, the 4th value remains unused,
2383                 * so there is no danger in doing this. With vertex shaders we have a
2384                 * problem. Should an app hit that problem, the code here would have to
2385                 * check for pixel shaders, and the shader has to undo the default gl divide.
2386                 *
2387                 * A more serious problem occurs if the app passes 4 coordinates in, and the
2388                 * 4th is != 1.0(opengl default). This would have to be fixed in drawStridedSlow
2389                 * or a replacement shader
2390                 */
2391                 default: mat[3] = mat[7] = mat[11] = 0; mat[15] = 1;
2392             }
2393         }
2394     }
2395
2396     glLoadMatrixf(mat);
2397     checkGLcall("glLoadMatrixf(mat)");
2398 }
2399
2400 /* This small helper function is used to convert a bitmask into the number of masked bits */
2401 unsigned int count_bits(unsigned int mask)
2402 {
2403     unsigned int count;
2404     for (count = 0; mask; ++count)
2405     {
2406         mask &= mask - 1;
2407     }
2408     return count;
2409 }
2410
2411 /* Helper function for retrieving color info for ChoosePixelFormat and wglChoosePixelFormatARB.
2412  * The later function requires individual color components. */
2413 BOOL getColorBits(const struct wined3d_format_desc *format_desc,
2414         short *redSize, short *greenSize, short *blueSize, short *alphaSize, short *totalSize)
2415 {
2416     TRACE("fmt: %s\n", debug_d3dformat(format_desc->format));
2417     switch(format_desc->format)
2418     {
2419         case WINED3DFMT_B8G8R8X8_UNORM:
2420         case WINED3DFMT_B8G8R8_UNORM:
2421         case WINED3DFMT_B8G8R8A8_UNORM:
2422         case WINED3DFMT_R8G8B8A8_UNORM:
2423         case WINED3DFMT_B10G10R10A2_UNORM:
2424         case WINED3DFMT_B5G5R5X1_UNORM:
2425         case WINED3DFMT_B5G5R5A1_UNORM:
2426         case WINED3DFMT_B5G6R5_UNORM:
2427         case WINED3DFMT_B4G4R4X4_UNORM:
2428         case WINED3DFMT_B4G4R4A4_UNORM:
2429         case WINED3DFMT_B2G3R3_UNORM:
2430         case WINED3DFMT_P8_UINT_A8_UNORM:
2431         case WINED3DFMT_P8_UINT:
2432             break;
2433         default:
2434             ERR("Unsupported format: %s\n", debug_d3dformat(format_desc->format));
2435             return FALSE;
2436     }
2437
2438     *redSize = count_bits(format_desc->red_mask);
2439     *greenSize = count_bits(format_desc->green_mask);
2440     *blueSize = count_bits(format_desc->blue_mask);
2441     *alphaSize = count_bits(format_desc->alpha_mask);
2442     *totalSize = *redSize + *greenSize + *blueSize + *alphaSize;
2443
2444     TRACE("Returning red:  %d, green: %d, blue: %d, alpha: %d, total: %d for fmt=%s\n",
2445             *redSize, *greenSize, *blueSize, *alphaSize, *totalSize, debug_d3dformat(format_desc->format));
2446     return TRUE;
2447 }
2448
2449 /* Helper function for retrieving depth/stencil info for ChoosePixelFormat and wglChoosePixelFormatARB */
2450 BOOL getDepthStencilBits(const struct wined3d_format_desc *format_desc, short *depthSize, short *stencilSize)
2451 {
2452     TRACE("fmt: %s\n", debug_d3dformat(format_desc->format));
2453     switch(format_desc->format)
2454     {
2455         case WINED3DFMT_D16_LOCKABLE:
2456         case WINED3DFMT_D16_UNORM:
2457         case WINED3DFMT_S1_UINT_D15_UNORM:
2458         case WINED3DFMT_X8D24_UNORM:
2459         case WINED3DFMT_S4X4_UINT_D24_UNORM:
2460         case WINED3DFMT_D24_UNORM_S8_UINT:
2461         case WINED3DFMT_S8_UINT_D24_FLOAT:
2462         case WINED3DFMT_D32_UNORM:
2463         case WINED3DFMT_D32_FLOAT:
2464             break;
2465         default:
2466             FIXME("Unsupported stencil format: %s\n", debug_d3dformat(format_desc->format));
2467             return FALSE;
2468     }
2469
2470     *depthSize = format_desc->depth_size;
2471     *stencilSize = format_desc->stencil_size;
2472
2473     TRACE("Returning depthSize: %d and stencilSize: %d for fmt=%s\n",
2474             *depthSize, *stencilSize, debug_d3dformat(format_desc->format));
2475     return TRUE;
2476 }
2477
2478 DWORD color_convert_argb_to_fmt(DWORD color, WINED3DFORMAT destfmt)
2479 {
2480     unsigned int r, g, b, a;
2481     DWORD ret;
2482
2483     if (destfmt == WINED3DFMT_B8G8R8A8_UNORM
2484             || destfmt == WINED3DFMT_B8G8R8X8_UNORM
2485             || destfmt == WINED3DFMT_B8G8R8_UNORM)
2486         return color;
2487
2488     TRACE("Converting color %08x to format %s\n", color, debug_d3dformat(destfmt));
2489
2490     a = (color & 0xff000000) >> 24;
2491     r = (color & 0x00ff0000) >> 16;
2492     g = (color & 0x0000ff00) >>  8;
2493     b = (color & 0x000000ff) >>  0;
2494
2495     switch(destfmt)
2496     {
2497         case WINED3DFMT_B5G6R5_UNORM:
2498             if(r == 0xff && g == 0xff && b == 0xff) return 0xffff;
2499             r = (r * 32) / 256;
2500             g = (g * 64) / 256;
2501             b = (b * 32) / 256;
2502             ret  = r << 11;
2503             ret |= g << 5;
2504             ret |= b;
2505             TRACE("Returning %08x\n", ret);
2506             return ret;
2507
2508         case WINED3DFMT_B5G5R5X1_UNORM:
2509         case WINED3DFMT_B5G5R5A1_UNORM:
2510             a = (a *  2) / 256;
2511             r = (r * 32) / 256;
2512             g = (g * 32) / 256;
2513             b = (b * 32) / 256;
2514             ret  = a << 15;
2515             ret |= r << 10;
2516             ret |= g <<  5;
2517             ret |= b <<  0;
2518             TRACE("Returning %08x\n", ret);
2519             return ret;
2520
2521         case WINED3DFMT_A8_UNORM:
2522             TRACE("Returning %08x\n", a);
2523             return a;
2524
2525         case WINED3DFMT_B4G4R4X4_UNORM:
2526         case WINED3DFMT_B4G4R4A4_UNORM:
2527             a = (a * 16) / 256;
2528             r = (r * 16) / 256;
2529             g = (g * 16) / 256;
2530             b = (b * 16) / 256;
2531             ret  = a << 12;
2532             ret |= r <<  8;
2533             ret |= g <<  4;
2534             ret |= b <<  0;
2535             TRACE("Returning %08x\n", ret);
2536             return ret;
2537
2538         case WINED3DFMT_B2G3R3_UNORM:
2539             r = (r * 8) / 256;
2540             g = (g * 8) / 256;
2541             b = (b * 4) / 256;
2542             ret  = r <<  5;
2543             ret |= g <<  2;
2544             ret |= b <<  0;
2545             TRACE("Returning %08x\n", ret);
2546             return ret;
2547
2548         case WINED3DFMT_R8G8B8X8_UNORM:
2549         case WINED3DFMT_R8G8B8A8_UNORM:
2550             ret  = a << 24;
2551             ret |= b << 16;
2552             ret |= g <<  8;
2553             ret |= r <<  0;
2554             TRACE("Returning %08x\n", ret);
2555             return ret;
2556
2557         case WINED3DFMT_B10G10R10A2_UNORM:
2558             a = (a *    4) / 256;
2559             r = (r * 1024) / 256;
2560             g = (g * 1024) / 256;
2561             b = (b * 1024) / 256;
2562             ret  = a << 30;
2563             ret |= r << 20;
2564             ret |= g << 10;
2565             ret |= b <<  0;
2566             TRACE("Returning %08x\n", ret);
2567             return ret;
2568
2569         case WINED3DFMT_R10G10B10A2_UNORM:
2570             a = (a *    4) / 256;
2571             r = (r * 1024) / 256;
2572             g = (g * 1024) / 256;
2573             b = (b * 1024) / 256;
2574             ret  = a << 30;
2575             ret |= b << 20;
2576             ret |= g << 10;
2577             ret |= r <<  0;
2578             TRACE("Returning %08x\n", ret);
2579             return ret;
2580
2581         default:
2582             FIXME("Add a COLORFILL conversion for format %s\n", debug_d3dformat(destfmt));
2583             return 0;
2584     }
2585 }
2586
2587 /* DirectDraw stuff */
2588 WINED3DFORMAT pixelformat_for_depth(DWORD depth) {
2589     switch(depth) {
2590         case 8:  return WINED3DFMT_P8_UINT;
2591         case 15: return WINED3DFMT_B5G5R5X1_UNORM;
2592         case 16: return WINED3DFMT_B5G6R5_UNORM;
2593         case 24: return WINED3DFMT_B8G8R8X8_UNORM; /* Robots needs 24bit to be WINED3DFMT_B8G8R8X8_UNORM */
2594         case 32: return WINED3DFMT_B8G8R8X8_UNORM; /* EVE online and the Fur demo need 32bit AdapterDisplayMode to return WINED3DFMT_B8G8R8X8_UNORM */
2595         default: return WINED3DFMT_UNKNOWN;
2596     }
2597 }
2598
2599 void multiply_matrix(WINED3DMATRIX *dest, const WINED3DMATRIX *src1, const WINED3DMATRIX *src2) {
2600     WINED3DMATRIX temp;
2601
2602     /* Now do the multiplication 'by hand'.
2603        I know that all this could be optimised, but this will be done later :-) */
2604     temp.u.s._11 = (src1->u.s._11 * src2->u.s._11) + (src1->u.s._21 * src2->u.s._12) + (src1->u.s._31 * src2->u.s._13) + (src1->u.s._41 * src2->u.s._14);
2605     temp.u.s._21 = (src1->u.s._11 * src2->u.s._21) + (src1->u.s._21 * src2->u.s._22) + (src1->u.s._31 * src2->u.s._23) + (src1->u.s._41 * src2->u.s._24);
2606     temp.u.s._31 = (src1->u.s._11 * src2->u.s._31) + (src1->u.s._21 * src2->u.s._32) + (src1->u.s._31 * src2->u.s._33) + (src1->u.s._41 * src2->u.s._34);
2607     temp.u.s._41 = (src1->u.s._11 * src2->u.s._41) + (src1->u.s._21 * src2->u.s._42) + (src1->u.s._31 * src2->u.s._43) + (src1->u.s._41 * src2->u.s._44);
2608
2609     temp.u.s._12 = (src1->u.s._12 * src2->u.s._11) + (src1->u.s._22 * src2->u.s._12) + (src1->u.s._32 * src2->u.s._13) + (src1->u.s._42 * src2->u.s._14);
2610     temp.u.s._22 = (src1->u.s._12 * src2->u.s._21) + (src1->u.s._22 * src2->u.s._22) + (src1->u.s._32 * src2->u.s._23) + (src1->u.s._42 * src2->u.s._24);
2611     temp.u.s._32 = (src1->u.s._12 * src2->u.s._31) + (src1->u.s._22 * src2->u.s._32) + (src1->u.s._32 * src2->u.s._33) + (src1->u.s._42 * src2->u.s._34);
2612     temp.u.s._42 = (src1->u.s._12 * src2->u.s._41) + (src1->u.s._22 * src2->u.s._42) + (src1->u.s._32 * src2->u.s._43) + (src1->u.s._42 * src2->u.s._44);
2613
2614     temp.u.s._13 = (src1->u.s._13 * src2->u.s._11) + (src1->u.s._23 * src2->u.s._12) + (src1->u.s._33 * src2->u.s._13) + (src1->u.s._43 * src2->u.s._14);
2615     temp.u.s._23 = (src1->u.s._13 * src2->u.s._21) + (src1->u.s._23 * src2->u.s._22) + (src1->u.s._33 * src2->u.s._23) + (src1->u.s._43 * src2->u.s._24);
2616     temp.u.s._33 = (src1->u.s._13 * src2->u.s._31) + (src1->u.s._23 * src2->u.s._32) + (src1->u.s._33 * src2->u.s._33) + (src1->u.s._43 * src2->u.s._34);
2617     temp.u.s._43 = (src1->u.s._13 * src2->u.s._41) + (src1->u.s._23 * src2->u.s._42) + (src1->u.s._33 * src2->u.s._43) + (src1->u.s._43 * src2->u.s._44);
2618
2619     temp.u.s._14 = (src1->u.s._14 * src2->u.s._11) + (src1->u.s._24 * src2->u.s._12) + (src1->u.s._34 * src2->u.s._13) + (src1->u.s._44 * src2->u.s._14);
2620     temp.u.s._24 = (src1->u.s._14 * src2->u.s._21) + (src1->u.s._24 * src2->u.s._22) + (src1->u.s._34 * src2->u.s._23) + (src1->u.s._44 * src2->u.s._24);
2621     temp.u.s._34 = (src1->u.s._14 * src2->u.s._31) + (src1->u.s._24 * src2->u.s._32) + (src1->u.s._34 * src2->u.s._33) + (src1->u.s._44 * src2->u.s._34);
2622     temp.u.s._44 = (src1->u.s._14 * src2->u.s._41) + (src1->u.s._24 * src2->u.s._42) + (src1->u.s._34 * src2->u.s._43) + (src1->u.s._44 * src2->u.s._44);
2623
2624     /* And copy the new matrix in the good storage.. */
2625     memcpy(dest, &temp, 16 * sizeof(float));
2626 }
2627
2628 DWORD get_flexible_vertex_size(DWORD d3dvtVertexType) {
2629     DWORD size = 0;
2630     int i;
2631     int numTextures = (d3dvtVertexType & WINED3DFVF_TEXCOUNT_MASK) >> WINED3DFVF_TEXCOUNT_SHIFT;
2632
2633     if (d3dvtVertexType & WINED3DFVF_NORMAL) size += 3 * sizeof(float);
2634     if (d3dvtVertexType & WINED3DFVF_DIFFUSE) size += sizeof(DWORD);
2635     if (d3dvtVertexType & WINED3DFVF_SPECULAR) size += sizeof(DWORD);
2636     if (d3dvtVertexType & WINED3DFVF_PSIZE) size += sizeof(DWORD);
2637     switch (d3dvtVertexType & WINED3DFVF_POSITION_MASK) {
2638         case WINED3DFVF_XYZ:    size += 3 * sizeof(float); break;
2639         case WINED3DFVF_XYZRHW: size += 4 * sizeof(float); break;
2640         case WINED3DFVF_XYZB1:  size += 4 * sizeof(float); break;
2641         case WINED3DFVF_XYZB2:  size += 5 * sizeof(float); break;
2642         case WINED3DFVF_XYZB3:  size += 6 * sizeof(float); break;
2643         case WINED3DFVF_XYZB4:  size += 7 * sizeof(float); break;
2644         case WINED3DFVF_XYZB5:  size += 8 * sizeof(float); break;
2645         case WINED3DFVF_XYZW:   size += 4 * sizeof(float); break;
2646         default: ERR("Unexpected position mask\n");
2647     }
2648     for (i = 0; i < numTextures; i++) {
2649         size += GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType, i) * sizeof(float);
2650     }
2651
2652     return size;
2653 }
2654
2655 void gen_ffp_frag_op(IWineD3DStateBlockImpl *stateblock, struct ffp_frag_settings *settings, BOOL ignore_textype) {
2656 #define ARG1 0x01
2657 #define ARG2 0x02
2658 #define ARG0 0x04
2659     static const unsigned char args[WINED3DTOP_LERP + 1] = {
2660         /* undefined                        */  0,
2661         /* D3DTOP_DISABLE                   */  0,
2662         /* D3DTOP_SELECTARG1                */  ARG1,
2663         /* D3DTOP_SELECTARG2                */  ARG2,
2664         /* D3DTOP_MODULATE                  */  ARG1 | ARG2,
2665         /* D3DTOP_MODULATE2X                */  ARG1 | ARG2,
2666         /* D3DTOP_MODULATE4X                */  ARG1 | ARG2,
2667         /* D3DTOP_ADD                       */  ARG1 | ARG2,
2668         /* D3DTOP_ADDSIGNED                 */  ARG1 | ARG2,
2669         /* D3DTOP_ADDSIGNED2X               */  ARG1 | ARG2,
2670         /* D3DTOP_SUBTRACT                  */  ARG1 | ARG2,
2671         /* D3DTOP_ADDSMOOTH                 */  ARG1 | ARG2,
2672         /* D3DTOP_BLENDDIFFUSEALPHA         */  ARG1 | ARG2,
2673         /* D3DTOP_BLENDTEXTUREALPHA         */  ARG1 | ARG2,
2674         /* D3DTOP_BLENDFACTORALPHA          */  ARG1 | ARG2,
2675         /* D3DTOP_BLENDTEXTUREALPHAPM       */  ARG1 | ARG2,
2676         /* D3DTOP_BLENDCURRENTALPHA         */  ARG1 | ARG2,
2677         /* D3DTOP_PREMODULATE               */  ARG1 | ARG2,
2678         /* D3DTOP_MODULATEALPHA_ADDCOLOR    */  ARG1 | ARG2,
2679         /* D3DTOP_MODULATECOLOR_ADDALPHA    */  ARG1 | ARG2,
2680         /* D3DTOP_MODULATEINVALPHA_ADDCOLOR */  ARG1 | ARG2,
2681         /* D3DTOP_MODULATEINVCOLOR_ADDALPHA */  ARG1 | ARG2,
2682         /* D3DTOP_BUMPENVMAP                */  ARG1 | ARG2,
2683         /* D3DTOP_BUMPENVMAPLUMINANCE       */  ARG1 | ARG2,
2684         /* D3DTOP_DOTPRODUCT3               */  ARG1 | ARG2,
2685         /* D3DTOP_MULTIPLYADD               */  ARG1 | ARG2 | ARG0,
2686         /* D3DTOP_LERP                      */  ARG1 | ARG2 | ARG0
2687     };
2688     unsigned int i;
2689     DWORD ttff;
2690     DWORD cop, aop, carg0, carg1, carg2, aarg0, aarg1, aarg2;
2691     IWineD3DDeviceImpl *device = stateblock->device;
2692     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
2693
2694     for (i = 0; i < gl_info->limits.texture_stages; ++i)
2695     {
2696         IWineD3DBaseTextureImpl *texture;
2697         settings->op[i].padding = 0;
2698         if(stateblock->textureState[i][WINED3DTSS_COLOROP] == WINED3DTOP_DISABLE) {
2699             settings->op[i].cop = WINED3DTOP_DISABLE;
2700             settings->op[i].aop = WINED3DTOP_DISABLE;
2701             settings->op[i].carg0 = settings->op[i].carg1 = settings->op[i].carg2 = ARG_UNUSED;
2702             settings->op[i].aarg0 = settings->op[i].aarg1 = settings->op[i].aarg2 = ARG_UNUSED;
2703             settings->op[i].color_fixup = COLOR_FIXUP_IDENTITY;
2704             settings->op[i].dst = resultreg;
2705             settings->op[i].tex_type = tex_1d;
2706             settings->op[i].projected = proj_none;
2707             i++;
2708             break;
2709         }
2710
2711         texture = (IWineD3DBaseTextureImpl *) stateblock->textures[i];
2712         if(texture) {
2713             settings->op[i].color_fixup = texture->resource.format_desc->color_fixup;
2714             if(ignore_textype) {
2715                 settings->op[i].tex_type = tex_1d;
2716             } else {
2717                 switch (IWineD3DBaseTexture_GetTextureDimensions((IWineD3DBaseTexture *)texture)) {
2718                     case GL_TEXTURE_1D:
2719                         settings->op[i].tex_type = tex_1d;
2720                         break;
2721                     case GL_TEXTURE_2D:
2722                         settings->op[i].tex_type = tex_2d;
2723                         break;
2724                     case GL_TEXTURE_3D:
2725                         settings->op[i].tex_type = tex_3d;
2726                         break;
2727                     case GL_TEXTURE_CUBE_MAP_ARB:
2728                         settings->op[i].tex_type = tex_cube;
2729                         break;
2730                     case GL_TEXTURE_RECTANGLE_ARB:
2731                         settings->op[i].tex_type = tex_rect;
2732                         break;
2733                 }
2734             }
2735         } else {
2736             settings->op[i].color_fixup = COLOR_FIXUP_IDENTITY;
2737             settings->op[i].tex_type = tex_1d;
2738         }
2739
2740         cop = stateblock->textureState[i][WINED3DTSS_COLOROP];
2741         aop = stateblock->textureState[i][WINED3DTSS_ALPHAOP];
2742
2743         carg1 = (args[cop] & ARG1) ? stateblock->textureState[i][WINED3DTSS_COLORARG1] : ARG_UNUSED;
2744         carg2 = (args[cop] & ARG2) ? stateblock->textureState[i][WINED3DTSS_COLORARG2] : ARG_UNUSED;
2745         carg0 = (args[cop] & ARG0) ? stateblock->textureState[i][WINED3DTSS_COLORARG0] : ARG_UNUSED;
2746
2747         if(is_invalid_op(device, i, cop, carg1, carg2, carg0)) {
2748             carg0 = ARG_UNUSED;
2749             carg2 = ARG_UNUSED;
2750             carg1 = WINED3DTA_CURRENT;
2751             cop = WINED3DTOP_SELECTARG1;
2752         }
2753
2754         if(cop == WINED3DTOP_DOTPRODUCT3) {
2755             /* A dotproduct3 on the colorop overwrites the alphaop operation and replicates
2756              * the color result to the alpha component of the destination
2757              */
2758             aop = cop;
2759             aarg1 = carg1;
2760             aarg2 = carg2;
2761             aarg0 = carg0;
2762         } else {
2763             aarg1 = (args[aop] & ARG1) ? stateblock->textureState[i][WINED3DTSS_ALPHAARG1] : ARG_UNUSED;
2764             aarg2 = (args[aop] & ARG2) ? stateblock->textureState[i][WINED3DTSS_ALPHAARG2] : ARG_UNUSED;
2765             aarg0 = (args[aop] & ARG0) ? stateblock->textureState[i][WINED3DTSS_ALPHAARG0] : ARG_UNUSED;
2766         }
2767
2768         if (i == 0 && stateblock->textures[0] && stateblock->renderState[WINED3DRS_COLORKEYENABLE])
2769         {
2770             UINT texture_dimensions = IWineD3DBaseTexture_GetTextureDimensions(stateblock->textures[0]);
2771
2772             if (texture_dimensions == GL_TEXTURE_2D || texture_dimensions == GL_TEXTURE_RECTANGLE_ARB)
2773             {
2774                 IWineD3DSurfaceImpl *surf;
2775                 surf = (IWineD3DSurfaceImpl *) ((IWineD3DTextureImpl *) stateblock->textures[0])->surfaces[0];
2776
2777                 if (surf->CKeyFlags & WINEDDSD_CKSRCBLT && !surf->resource.format_desc->alpha_mask)
2778                 {
2779                     if (aop == WINED3DTOP_DISABLE)
2780                     {
2781                        aarg1 = WINED3DTA_TEXTURE;
2782                        aop = WINED3DTOP_SELECTARG1;
2783                     }
2784                     else if (aop == WINED3DTOP_SELECTARG1 && aarg1 != WINED3DTA_TEXTURE)
2785                     {
2786                         if (stateblock->renderState[WINED3DRS_ALPHABLENDENABLE])
2787                         {
2788                             aarg2 = WINED3DTA_TEXTURE;
2789                             aop = WINED3DTOP_MODULATE;
2790                         }
2791                         else aarg1 = WINED3DTA_TEXTURE;
2792                     }
2793                     else if (aop == WINED3DTOP_SELECTARG2 && aarg2 != WINED3DTA_TEXTURE)
2794                     {
2795                         if (stateblock->renderState[WINED3DRS_ALPHABLENDENABLE])
2796                         {
2797                             aarg1 = WINED3DTA_TEXTURE;
2798                             aop = WINED3DTOP_MODULATE;
2799                         }
2800                         else aarg2 = WINED3DTA_TEXTURE;
2801                     }
2802                 }
2803             }
2804         }
2805
2806         if(is_invalid_op(device, i, aop, aarg1, aarg2, aarg0)) {
2807                aarg0 = ARG_UNUSED;
2808                aarg2 = ARG_UNUSED;
2809                aarg1 = WINED3DTA_CURRENT;
2810                aop = WINED3DTOP_SELECTARG1;
2811         }
2812
2813         if(carg1 == WINED3DTA_TEXTURE || carg2 == WINED3DTA_TEXTURE || carg0 == WINED3DTA_TEXTURE ||
2814            aarg1 == WINED3DTA_TEXTURE || aarg2 == WINED3DTA_TEXTURE || aarg0 == WINED3DTA_TEXTURE) {
2815             ttff = stateblock->textureState[i][WINED3DTSS_TEXTURETRANSFORMFLAGS];
2816             if(ttff == (WINED3DTTFF_PROJECTED | WINED3DTTFF_COUNT3)) {
2817                 settings->op[i].projected = proj_count3;
2818             } else if(ttff == (WINED3DTTFF_PROJECTED | WINED3DTTFF_COUNT4)) {
2819                 settings->op[i].projected = proj_count4;
2820             } else {
2821                 settings->op[i].projected = proj_none;
2822             }
2823         } else {
2824             settings->op[i].projected = proj_none;
2825         }
2826
2827         settings->op[i].cop = cop;
2828         settings->op[i].aop = aop;
2829         settings->op[i].carg0 = carg0;
2830         settings->op[i].carg1 = carg1;
2831         settings->op[i].carg2 = carg2;
2832         settings->op[i].aarg0 = aarg0;
2833         settings->op[i].aarg1 = aarg1;
2834         settings->op[i].aarg2 = aarg2;
2835
2836         if(stateblock->textureState[i][WINED3DTSS_RESULTARG] == WINED3DTA_TEMP) {
2837             settings->op[i].dst = tempreg;
2838         } else {
2839             settings->op[i].dst = resultreg;
2840         }
2841     }
2842
2843     /* Clear unsupported stages */
2844     for(; i < MAX_TEXTURES; i++) {
2845         memset(&settings->op[i], 0xff, sizeof(settings->op[i]));
2846     }
2847
2848     if(stateblock->renderState[WINED3DRS_FOGENABLE] == FALSE) {
2849         settings->fog = FOG_OFF;
2850     } else if(stateblock->renderState[WINED3DRS_FOGTABLEMODE] == WINED3DFOG_NONE) {
2851         if(use_vs(stateblock) || ((IWineD3DVertexDeclarationImpl *) stateblock->vertexDecl)->position_transformed) {
2852             settings->fog = FOG_LINEAR;
2853         } else {
2854             switch(stateblock->renderState[WINED3DRS_FOGVERTEXMODE]) {
2855                 case WINED3DFOG_NONE:
2856                 case WINED3DFOG_LINEAR:
2857                     settings->fog = FOG_LINEAR;
2858                     break;
2859                 case WINED3DFOG_EXP:
2860                     settings->fog = FOG_EXP;
2861                     break;
2862                 case WINED3DFOG_EXP2:
2863                     settings->fog = FOG_EXP2;
2864                     break;
2865             }
2866         }
2867     } else {
2868         switch(stateblock->renderState[WINED3DRS_FOGTABLEMODE]) {
2869             case WINED3DFOG_LINEAR:
2870                 settings->fog = FOG_LINEAR;
2871                 break;
2872             case WINED3DFOG_EXP:
2873                 settings->fog = FOG_EXP;
2874                 break;
2875             case WINED3DFOG_EXP2:
2876                 settings->fog = FOG_EXP2;
2877                 break;
2878         }
2879     }
2880     if(stateblock->renderState[WINED3DRS_SRGBWRITEENABLE]) {
2881         settings->sRGB_write = 1;
2882     } else {
2883         settings->sRGB_write = 0;
2884     }
2885     if(device->vs_clipping || !use_vs(stateblock) || !stateblock->renderState[WINED3DRS_CLIPPING] ||
2886        !stateblock->renderState[WINED3DRS_CLIPPLANEENABLE]) {
2887         /* No need to emulate clipplanes if GL supports native vertex shader clipping or if
2888          * the fixed function vertex pipeline is used(which always supports clipplanes), or
2889          * if no clipplane is enabled
2890          */
2891         settings->emul_clipplanes = 0;
2892     } else {
2893         settings->emul_clipplanes = 1;
2894     }
2895 }
2896
2897 const struct ffp_frag_desc *find_ffp_frag_shader(const struct wine_rb_tree *fragment_shaders,
2898         const struct ffp_frag_settings *settings)
2899 {
2900     struct wine_rb_entry *entry = wine_rb_get(fragment_shaders, settings);
2901     return entry ? WINE_RB_ENTRY_VALUE(entry, struct ffp_frag_desc, entry) : NULL;
2902 }
2903
2904 void add_ffp_frag_shader(struct wine_rb_tree *shaders, struct ffp_frag_desc *desc)
2905 {
2906     /* Note that the key is the implementation independent part of the ffp_frag_desc structure,
2907      * whereas desc points to an extended structure with implementation specific parts. */
2908     if (wine_rb_put(shaders, &desc->settings, &desc->entry) == -1)
2909     {
2910         ERR("Failed to insert ffp frag shader.\n");
2911     }
2912 }
2913
2914 /* Activates the texture dimension according to the bound D3D texture.
2915  * Does not care for the colorop or correct gl texture unit(when using nvrc)
2916  * Requires the caller to activate the correct unit before
2917  */
2918 /* GL locking is done by the caller (state handler) */
2919 void texture_activate_dimensions(DWORD stage, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context)
2920 {
2921     const struct wined3d_gl_info *gl_info = context->gl_info;
2922
2923     if (stateblock->textures[stage])
2924     {
2925         switch (IWineD3DBaseTexture_GetTextureDimensions(stateblock->textures[stage])) {
2926             case GL_TEXTURE_2D:
2927                 glDisable(GL_TEXTURE_3D);
2928                 checkGLcall("glDisable(GL_TEXTURE_3D)");
2929                 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
2930                 {
2931                     glDisable(GL_TEXTURE_CUBE_MAP_ARB);
2932                     checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
2933                 }
2934                 if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
2935                 {
2936                     glDisable(GL_TEXTURE_RECTANGLE_ARB);
2937                     checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
2938                 }
2939                 glEnable(GL_TEXTURE_2D);
2940                 checkGLcall("glEnable(GL_TEXTURE_2D)");
2941                 break;
2942             case GL_TEXTURE_RECTANGLE_ARB:
2943                 glDisable(GL_TEXTURE_2D);
2944                 checkGLcall("glDisable(GL_TEXTURE_2D)");
2945                 glDisable(GL_TEXTURE_3D);
2946                 checkGLcall("glDisable(GL_TEXTURE_3D)");
2947                 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
2948                 {
2949                     glDisable(GL_TEXTURE_CUBE_MAP_ARB);
2950                     checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
2951                 }
2952                 glEnable(GL_TEXTURE_RECTANGLE_ARB);
2953                 checkGLcall("glEnable(GL_TEXTURE_RECTANGLE_ARB)");
2954                 break;
2955             case GL_TEXTURE_3D:
2956                 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
2957                 {
2958                     glDisable(GL_TEXTURE_CUBE_MAP_ARB);
2959                     checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
2960                 }
2961                 if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
2962                 {
2963                     glDisable(GL_TEXTURE_RECTANGLE_ARB);
2964                     checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
2965                 }
2966                 glDisable(GL_TEXTURE_2D);
2967                 checkGLcall("glDisable(GL_TEXTURE_2D)");
2968                 glEnable(GL_TEXTURE_3D);
2969                 checkGLcall("glEnable(GL_TEXTURE_3D)");
2970                 break;
2971             case GL_TEXTURE_CUBE_MAP_ARB:
2972                 glDisable(GL_TEXTURE_2D);
2973                 checkGLcall("glDisable(GL_TEXTURE_2D)");
2974                 glDisable(GL_TEXTURE_3D);
2975                 checkGLcall("glDisable(GL_TEXTURE_3D)");
2976                 if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
2977                 {
2978                     glDisable(GL_TEXTURE_RECTANGLE_ARB);
2979                     checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
2980                 }
2981                 glEnable(GL_TEXTURE_CUBE_MAP_ARB);
2982                 checkGLcall("glEnable(GL_TEXTURE_CUBE_MAP_ARB)");
2983               break;
2984         }
2985     } else {
2986         glEnable(GL_TEXTURE_2D);
2987         checkGLcall("glEnable(GL_TEXTURE_2D)");
2988         glDisable(GL_TEXTURE_3D);
2989         checkGLcall("glDisable(GL_TEXTURE_3D)");
2990         if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
2991         {
2992             glDisable(GL_TEXTURE_CUBE_MAP_ARB);
2993             checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
2994         }
2995         if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
2996         {
2997             glDisable(GL_TEXTURE_RECTANGLE_ARB);
2998             checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
2999         }
3000         /* Binding textures is done by samplers. A dummy texture will be bound */
3001     }
3002 }
3003
3004 /* GL locking is done by the caller (state handler) */
3005 void sampler_texdim(DWORD state, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context)
3006 {
3007     DWORD sampler = state - STATE_SAMPLER(0);
3008     DWORD mapped_stage = stateblock->device->texUnitMap[sampler];
3009
3010     /* No need to enable / disable anything here for unused samplers. The tex_colorop
3011     * handler takes care. Also no action is needed with pixel shaders, or if tex_colorop
3012     * will take care of this business
3013     */
3014     if (mapped_stage == WINED3D_UNMAPPED_STAGE || mapped_stage >= context->gl_info->limits.textures) return;
3015     if(sampler >= stateblock->lowest_disabled_stage) return;
3016     if(isStateDirty(context, STATE_TEXTURESTAGE(sampler, WINED3DTSS_COLOROP))) return;
3017
3018     texture_activate_dimensions(sampler, stateblock, context);
3019 }
3020
3021 void *wined3d_rb_alloc(size_t size)
3022 {
3023     return HeapAlloc(GetProcessHeap(), 0, size);
3024 }
3025
3026 void *wined3d_rb_realloc(void *ptr, size_t size)
3027 {
3028     return HeapReAlloc(GetProcessHeap(), 0, ptr, size);
3029 }
3030
3031 void wined3d_rb_free(void *ptr)
3032 {
3033     HeapFree(GetProcessHeap(), 0, ptr);
3034 }
3035
3036 static int ffp_frag_program_key_compare(const void *key, const struct wine_rb_entry *entry)
3037 {
3038     const struct ffp_frag_settings *ka = key;
3039     const struct ffp_frag_settings *kb = &WINE_RB_ENTRY_VALUE(entry, const struct ffp_frag_desc, entry)->settings;
3040
3041     return memcmp(ka, kb, sizeof(*ka));
3042 }
3043
3044 const struct wine_rb_functions wined3d_ffp_frag_program_rb_functions =
3045 {
3046     wined3d_rb_alloc,
3047     wined3d_rb_realloc,
3048     wined3d_rb_free,
3049     ffp_frag_program_key_compare,
3050 };
3051
3052 UINT wined3d_log2i(UINT32 x)
3053 {
3054     static const UINT l[] =
3055     {
3056         ~0U, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
3057           4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
3058           5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
3059           5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
3060           6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
3061           6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
3062           6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
3063           6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
3064           7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
3065           7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
3066           7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
3067           7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
3068           7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
3069           7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
3070           7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
3071           7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
3072     };
3073     UINT32 i;
3074
3075     return (i = x >> 16) ? (x = i >> 8) ? l[x] + 24 : l[i] + 16 : (i = x >> 8) ? l[i] + 8 : l[x];
3076 }
3077
3078 /* Set the shader type for this device, depending on the given capabilities
3079  * and the user preferences in wined3d_settings. */
3080 void select_shader_mode(const struct wined3d_gl_info *gl_info, int *ps_selected, int *vs_selected)
3081 {
3082     BOOL glsl = wined3d_settings.glslRequested && gl_info->glsl_version >= MAKEDWORD_VERSION(1, 20);
3083
3084     if (wined3d_settings.vs_mode == VS_NONE) *vs_selected = SHADER_NONE;
3085     else if (gl_info->supported[ARB_VERTEX_SHADER] && glsl)
3086     {
3087         /* Geforce4 cards support GLSL but for vertex shaders only. Further its reported GLSL caps are
3088          * wrong. This combined with the fact that glsl won't offer more features or performance, use ARB
3089          * shaders only on this card. */
3090         if (gl_info->supported[NV_VERTEX_PROGRAM] && !gl_info->supported[NV_VERTEX_PROGRAM2]) *vs_selected = SHADER_ARB;
3091         else *vs_selected = SHADER_GLSL;
3092     }
3093     else if (gl_info->supported[ARB_VERTEX_PROGRAM]) *vs_selected = SHADER_ARB;
3094     else *vs_selected = SHADER_NONE;
3095
3096     if (wined3d_settings.ps_mode == PS_NONE) *ps_selected = SHADER_NONE;
3097     else if (gl_info->supported[ARB_FRAGMENT_SHADER] && glsl) *ps_selected = SHADER_GLSL;
3098     else if (gl_info->supported[ARB_FRAGMENT_PROGRAM]) *ps_selected = SHADER_ARB;
3099     else if (gl_info->supported[ATI_FRAGMENT_SHADER]) *ps_selected = SHADER_ATI;
3100     else *ps_selected = SHADER_NONE;
3101 }