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  *
  11  * This library is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Lesser General Public
  13  * License as published by the Free Software Foundation; either
  14  * version 2.1 of the License, or (at your option) any later version.
  15  *
  16  * This library is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public
  22  * License along with this library; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  24  */
  25
  26 #include "config.h"
  27 #include "wined3d_private.h"
  28
  29 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
  30
  31 struct StaticPixelFormatDesc
  32 {
  33     WINED3DFORMAT format;
  34     DWORD alphaMask, redMask, greenMask, blueMask;
  35     UINT bpp;
  36     short depthSize, stencilSize;
  37     BOOL isFourcc;
  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   isFourcc */
  53     {WINED3DFMT_UNKNOWN,            0x0,        0x0,        0x0,        0x0,        0,      0,      0,      FALSE},
  54     /* FourCC formats, kept here to have WINED3DFMT_R8G8B8(=20) at position 20 */
  55     {WINED3DFMT_UYVY,               0x0,        0x0,        0x0,        0x0,        2,      0,      0,      TRUE },
  56     {WINED3DFMT_YUY2,               0x0,        0x0,        0x0,        0x0,        2,      0,      0,      TRUE },
  57     {WINED3DFMT_YV12,               0x0,        0x0,        0x0,        0x0,        1,      0,      0,      TRUE },
  58     {WINED3DFMT_DXT1,               0x0,        0x0,        0x0,        0x0,        1,      0,      0,      TRUE },
  59     {WINED3DFMT_DXT2,               0x0,        0x0,        0x0,        0x0,        1,      0,      0,      TRUE },
  60     {WINED3DFMT_DXT3,               0x0,        0x0,        0x0,        0x0,        1,      0,      0,      TRUE },
  61     {WINED3DFMT_DXT4,               0x0,        0x0,        0x0,        0x0,        1,      0,      0,      TRUE },
  62     {WINED3DFMT_DXT5,               0x0,        0x0,        0x0,        0x0,        1,      0,      0,      TRUE },
  63     {WINED3DFMT_MULTI2_ARGB8,       0x0,        0x0,        0x0,        0x0,        1/*?*/, 0,      0,      TRUE },
  64     {WINED3DFMT_G8R8_G8B8,          0x0,        0x0,        0x0,        0x0,        1/*?*/, 0,      0,      TRUE },
  65     {WINED3DFMT_R8G8_B8G8,          0x0,        0x0,        0x0,        0x0,        1/*?*/, 0,      0,      TRUE },
  66     /* IEEE formats */
  67     {WINED3DFMT_R32_FLOAT,          0x0,        0x0,        0x0,        0x0,        4,      0,      0,      FALSE},
  68     {WINED3DFMT_R32G32_FLOAT,       0x0,        0x0,        0x0,        0x0,        8,      0,      0,      FALSE},
  69     {WINED3DFMT_R32G32B32_FLOAT,    0x0,        0x0,        0x0,        0x0,        12,     0,      0,      FALSE},
  70     {WINED3DFMT_R32G32B32A32_FLOAT, 0x1,        0x0,        0x0,        0x0,        16,     0,      0,      FALSE},
  71     /* Hmm? */
  72     {WINED3DFMT_CxV8U8,             0x0,        0x0,        0x0,        0x0,        2,      0,      0,      FALSE},
  73     /* Float */
  74     {WINED3DFMT_R16_FLOAT,          0x0,        0x0,        0x0,        0x0,        2,      0,      0,      FALSE},
  75     {WINED3DFMT_R16G16_FLOAT,       0x0,        0x0,        0x0,        0x0,        4,      0,      0,      FALSE},
  76     {WINED3DFMT_R16G16_SINT,        0x0,        0x0,        0x0,        0x0,        4,      0,      0,      FALSE},
  77     {WINED3DFMT_R16G16B16A16_FLOAT, 0x1,        0x0,        0x0,        0x0,        8,      0,      0,      FALSE},
  78     {WINED3DFMT_R16G16B16A16_SINT,  0x1,        0x0,        0x0,        0x0,        8,      0,      0,      FALSE},
  79     /* Palettized formats */
  80     {WINED3DFMT_A8P8,               0x0000ff00, 0x0,        0x0,        0x0,        2,      0,      0,      FALSE},
  81     {WINED3DFMT_P8,                 0x0,        0x0,        0x0,        0x0,        1,      0,      0,      FALSE},
  82     /* Standard ARGB formats. */
  83     {WINED3DFMT_R8G8B8,             0x0,        0x00ff0000, 0x0000ff00, 0x000000ff, 3,      0,      0,      FALSE},
  84     {WINED3DFMT_A8R8G8B8,           0xff000000, 0x00ff0000, 0x0000ff00, 0x000000ff, 4,      0,      0,      FALSE},
  85     {WINED3DFMT_X8R8G8B8,           0x0,        0x00ff0000, 0x0000ff00, 0x000000ff, 4,      0,      0,      FALSE},
  86     {WINED3DFMT_R5G6B5,             0x0,        0x0000f800, 0x000007e0, 0x0000001f, 2,      0,      0,      FALSE},
  87     {WINED3DFMT_X1R5G5B5,           0x0,        0x00007c00, 0x000003e0, 0x0000001f, 2,      0,      0,      FALSE},
  88     {WINED3DFMT_A1R5G5B5,           0x00008000, 0x00007c00, 0x000003e0, 0x0000001f, 2,      0,      0,      FALSE},
  89     {WINED3DFMT_A4R4G4B4,           0x0000f000, 0x00000f00, 0x000000f0, 0x0000000f, 2,      0,      0,      FALSE},
  90     {WINED3DFMT_R3G3B2,             0x0,        0x000000e0, 0x0000001c, 0x00000003, 1,      0,      0,      FALSE},
  91     {WINED3DFMT_A8_UNORM,           0x000000ff, 0x0,        0x0,        0x0,        1,      0,      0,      FALSE},
  92     {WINED3DFMT_A8R3G3B2,           0x0000ff00, 0x000000e0, 0x0000001c, 0x00000003, 2,      0,      0,      FALSE},
  93     {WINED3DFMT_X4R4G4B4,           0x0,        0x00000f00, 0x000000f0, 0x0000000f, 2,      0,      0,      FALSE},
  94     {WINED3DFMT_R10G10B10A2_UNORM,  0xb0000000, 0x000003ff, 0x000ffc00, 0x3ff00000, 4,      0,      0,      FALSE},
  95     {WINED3DFMT_R10G10B10A2_UINT,   0xb0000000, 0x000003ff, 0x000ffc00, 0x3ff00000, 4,      0,      0,      FALSE},
  96     {WINED3DFMT_R10G10B10A2_SNORM,  0xb0000000, 0x000003ff, 0x000ffc00, 0x3ff00000, 4,      0,      0,      FALSE},
  97     {WINED3DFMT_R8G8B8A8_UNORM,     0xff000000, 0x000000ff, 0x0000ff00, 0x00ff0000, 4,      0,      0,      FALSE},
  98     {WINED3DFMT_R8G8B8A8_UINT,      0xff000000, 0x000000ff, 0x0000ff00, 0x00ff0000, 4,      0,      0,      FALSE},
  99     {WINED3DFMT_X8B8G8R8,           0x0,        0x000000ff, 0x0000ff00, 0x00ff0000, 4,      0,      0,      FALSE},
 100     {WINED3DFMT_R16G16_UNORM,       0x0,        0x0000ffff, 0xffff0000, 0x0,        4,      0,      0,      FALSE},
 101     {WINED3DFMT_A2R10G10B10,        0xb0000000, 0x3ff00000, 0x000ffc00, 0x000003ff, 4,      0,      0,      FALSE},
 102     {WINED3DFMT_R16G16B16A16_UNORM, 0x1,        0x0000ffff, 0xffff0000, 0x0,        8,      0,      0,      FALSE},
 103     /* Luminance */
 104     {WINED3DFMT_L8,                 0x0,        0x0,        0x0,        0x0,        1,      0,      0,      FALSE},
 105     {WINED3DFMT_A8L8,               0x0000ff00, 0x0,        0x0,        0x0,        2,      0,      0,      FALSE},
 106     {WINED3DFMT_A4L4,               0x000000f0, 0x0,        0x0,        0x0,        1,      0,      0,      FALSE},
 107     /* Bump mapping stuff */
 108     {WINED3DFMT_R8G8_SNORM,         0x0,        0x0,        0x0,        0x0,        2,      0,      0,      FALSE},
 109     {WINED3DFMT_L6V5U5,             0x0,        0x0,        0x0,        0x0,        2,      0,      0,      FALSE},
 110     {WINED3DFMT_X8L8V8U8,           0x0,        0x0,        0x0,        0x0,        4,      0,      0,      FALSE},
 111     {WINED3DFMT_R8G8B8A8_SNORM,     0x0,        0x0,        0x0,        0x0,        4,      0,      0,      FALSE},
 112     {WINED3DFMT_R16G16_SNORM,       0x0,        0x0,        0x0,        0x0,        4,      0,      0,      FALSE},
 113     {WINED3DFMT_W11V11U10,          0x0,        0x0,        0x0,        0x0,        4,      0,      0,      FALSE},
 114     {WINED3DFMT_A2W10V10U10,        0xb0000000, 0x0,        0x0,        0x0,        4,      0,      0,      FALSE},
 115     /* Depth stencil formats */
 116     {WINED3DFMT_D16_LOCKABLE,       0x0,        0x0,        0x0,        0x0,        2,      16,     0,      FALSE},
 117     {WINED3DFMT_D32,                0x0,        0x0,        0x0,        0x0,        4,      32,     0,      FALSE},
 118     {WINED3DFMT_D15S1,              0x0,        0x0,        0x0,        0x0,        2,      15,     1,      FALSE},
 119     {WINED3DFMT_D24S8,              0x0,        0x0,        0x0,        0x0,        4,      24,     8,      FALSE},
 120     {WINED3DFMT_D24X8,              0x0,        0x0,        0x0,        0x0,        4,      24,     0,      FALSE},
 121     {WINED3DFMT_D24X4S4,            0x0,        0x0,        0x0,        0x0,        4,      24,     4,      FALSE},
 122     {WINED3DFMT_D16_UNORM,          0x0,        0x0,        0x0,        0x0,        2,      16,     0,      FALSE},
 123     {WINED3DFMT_L16,                0x0,        0x0,        0x0,        0x0,        2,      16,     0,      FALSE},
 124     {WINED3DFMT_D32F_LOCKABLE,      0x0,        0x0,        0x0,        0x0,        4,      32,     0,      FALSE},
 125     {WINED3DFMT_D24FS8,             0x0,        0x0,        0x0,        0x0,        4,      24,     8,      FALSE},
 126     /* Is this a vertex buffer? */
 127     {WINED3DFMT_VERTEXDATA,         0x0,        0x0,        0x0,        0x0,        0,      0,      0,      FALSE},
 128     {WINED3DFMT_R16_UINT,           0x0,        0x0,        0x0,        0x0,        2,      0,      0,      FALSE},
 129     {WINED3DFMT_R32_UINT,           0x0,        0x0,        0x0,        0x0,        4,      0,      0,      FALSE},
 130     {WINED3DFMT_R16G16B16A16_SNORM, 0x0,        0x0,        0x0,        0x0,        8,      0,      0,      FALSE},
 131     /* Vendor-specific formats */
 132     {WINED3DFMT_ATI2N,              0x0,        0x0,        0x0,        0x0,        1,      0,      0,      TRUE },
 133     {WINED3DFMT_NVHU,               0x0,        0x0,        0x0,        0x0,        2,      0,      0,      TRUE },
 134     {WINED3DFMT_NVHS,               0x0,        0x0,        0x0,        0x0,        2,      0,      0,      TRUE },
 135 };
 136
 137 struct wined3d_format_vertex_info
 138 {
 139     WINED3DFORMAT format;
 140     enum wined3d_ffp_emit_idx emit_idx;
 141     GLint component_count;
 142     GLenum gl_vtx_type;
 143     GLint gl_vtx_format;
 144     GLboolean gl_normalized;
 145     unsigned int component_size;
 146 };
 147
 148 static const struct wined3d_format_vertex_info format_vertex_info[] =
 149 {
 150     {WINED3DFMT_R32_FLOAT,          WINED3D_FFP_EMIT_FLOAT1,    1, GL_FLOAT,          1, GL_FALSE, sizeof(float)},
 151     {WINED3DFMT_R32G32_FLOAT,       WINED3D_FFP_EMIT_FLOAT2,    2, GL_FLOAT,          2, GL_FALSE, sizeof(float)},
 152     {WINED3DFMT_R32G32B32_FLOAT,    WINED3D_FFP_EMIT_FLOAT3,    3, GL_FLOAT,          3, GL_FALSE, sizeof(float)},
 153     {WINED3DFMT_R32G32B32A32_FLOAT, WINED3D_FFP_EMIT_FLOAT4,    4, GL_FLOAT,          4, GL_FALSE, sizeof(float)},
 154     {WINED3DFMT_A8R8G8B8,           WINED3D_FFP_EMIT_D3DCOLOR,  4, GL_UNSIGNED_BYTE,  4, GL_TRUE,  sizeof(BYTE)},
 155     {WINED3DFMT_R8G8B8A8_UINT,      WINED3D_FFP_EMIT_UBYTE4,    4, GL_UNSIGNED_BYTE,  4, GL_FALSE, sizeof(BYTE)},
 156     {WINED3DFMT_R16G16_SINT,        WINED3D_FFP_EMIT_SHORT2,    2, GL_SHORT,          2, GL_FALSE, sizeof(short int)},
 157     {WINED3DFMT_R16G16B16A16_SINT,  WINED3D_FFP_EMIT_SHORT4,    4, GL_SHORT,          4, GL_FALSE, sizeof(short int)},
 158     {WINED3DFMT_R8G8B8A8_UNORM,     WINED3D_FFP_EMIT_UBYTE4N,   4, GL_UNSIGNED_BYTE,  4, GL_TRUE,  sizeof(BYTE)},
 159     {WINED3DFMT_R16G16_SNORM,       WINED3D_FFP_EMIT_SHORT2N,   2, GL_SHORT,          2, GL_TRUE,  sizeof(short int)},
 160     {WINED3DFMT_R16G16B16A16_SNORM, WINED3D_FFP_EMIT_SHORT4N,   4, GL_SHORT,          4, GL_TRUE,  sizeof(short int)},
 161     {WINED3DFMT_R16G16_UNORM,       WINED3D_FFP_EMIT_USHORT2N,  2, GL_UNSIGNED_SHORT, 2, GL_TRUE,  sizeof(short int)},
 162     {WINED3DFMT_R16G16B16A16_UNORM, WINED3D_FFP_EMIT_USHORT4N,  4, GL_UNSIGNED_SHORT, 4, GL_TRUE,  sizeof(short int)},
 163     {WINED3DFMT_R10G10B10A2_UINT,   WINED3D_FFP_EMIT_UDEC3,     3, GL_UNSIGNED_SHORT, 3, GL_FALSE, sizeof(short int)},
 164     {WINED3DFMT_R10G10B10A2_SNORM,  WINED3D_FFP_EMIT_DEC3N,     3, GL_SHORT,          3, GL_TRUE,  sizeof(short int)},
 165     {WINED3DFMT_R16G16_FLOAT,       WINED3D_FFP_EMIT_FLOAT16_2, 2, GL_FLOAT,          2, GL_FALSE, sizeof(GLhalfNV)},
 166     {WINED3DFMT_R16G16B16A16_FLOAT, WINED3D_FFP_EMIT_FLOAT16_4, 4, GL_FLOAT,          4, GL_FALSE, sizeof(GLhalfNV)}
 167 };
 168
 169 typedef struct {
 170     WINED3DFORMAT           fmt;
 171     GLint                   glInternal, glGammaInternal, rtInternal, glFormat, glType;
 172     unsigned int            Flags;
 173 } GlPixelFormatDescTemplate;
 174
 175 /*****************************************************************************
 176  * OpenGL format template. Contains unexciting formats which do not need
 177  * extension checks. The order in this table is independent of the order in
 178  * the table StaticPixelFormatDesc above. Not all formats have to be in this
 179  * table.
 180  */
 181 static const GlPixelFormatDescTemplate gl_formats_template[] = {
 182     /* WINED3DFORMAT                internal                          srgbInternal                            rtInternal
 183             format                  type
 184             flags */
 185     {WINED3DFMT_UNKNOWN,            0,                                0,                                      0,
 186             0,                      0,
 187             0},
 188     /* FourCC formats */
 189     /* GL_APPLE_ycbcr_422 claims that its '2YUV' format, which is supported via the UNSIGNED_SHORT_8_8_REV_APPLE type
 190      * is equivalent to 'UYVY' format on Windows, and the 'YUVS' via UNSIGNED_SHORT_8_8_APPLE equates to 'YUY2'. The
 191      * d3d9 test however shows that the opposite is true. Since the extension is from 2002, it predates the x86 based
 192      * Macs, so probably the endianess differs. This could be tested as soon as we have a Windows and MacOS on a big
 193      * endian machine
 194      */
 195     {WINED3DFMT_UYVY,               GL_RGB,                           GL_RGB,                                 0,
 196             GL_YCBCR_422_APPLE,     UNSIGNED_SHORT_8_8_APPLE,
 197             WINED3DFMT_FLAG_FILTERING},
 198     {WINED3DFMT_YUY2,               GL_RGB,                           GL_RGB,                                 0,
 199             GL_YCBCR_422_APPLE, UNSIGNED_SHORT_8_8_REV_APPLE,
 200             WINED3DFMT_FLAG_FILTERING},
 201     {WINED3DFMT_YV12,               GL_ALPHA,                         GL_ALPHA,                               0,
 202             GL_ALPHA,               GL_UNSIGNED_BYTE,
 203             WINED3DFMT_FLAG_FILTERING},
 204     {WINED3DFMT_DXT1,               GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, 0,
 205             GL_RGBA,                GL_UNSIGNED_BYTE,
 206             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING},
 207     {WINED3DFMT_DXT2,               GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, 0,
 208             GL_RGBA,                GL_UNSIGNED_BYTE,
 209             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING},
 210     {WINED3DFMT_DXT3,               GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, 0,
 211             GL_RGBA,                GL_UNSIGNED_BYTE,
 212             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING},
 213     {WINED3DFMT_DXT4,               GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, 0,
 214             GL_RGBA,                GL_UNSIGNED_BYTE,
 215             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING},
 216     {WINED3DFMT_DXT5,               GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, 0,
 217             GL_RGBA,                GL_UNSIGNED_BYTE,
 218             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING},
 219     {WINED3DFMT_MULTI2_ARGB8,       0,                                0,                                      0,
 220             0,                      0,
 221             0},
 222     {WINED3DFMT_G8R8_G8B8,          0,                                0,                                      0,
 223             0,                      0,
 224             0},
 225     {WINED3DFMT_R8G8_B8G8,          0,                                0,                                      0,
 226             0,                      0,
 227             0},
 228     /* IEEE formats */
 229     {WINED3DFMT_R32_FLOAT,          GL_RGB32F_ARB,                    GL_RGB32F_ARB,                          0,
 230             GL_RED,                 GL_FLOAT,
 231             WINED3DFMT_FLAG_RENDERTARGET},
 232     {WINED3DFMT_R32G32_FLOAT,       GL_RG32F,                         GL_RG32F,                               0,
 233             GL_RG,                  GL_FLOAT,
 234             WINED3DFMT_FLAG_RENDERTARGET},
 235     {WINED3DFMT_R32G32B32A32_FLOAT, GL_RGBA32F_ARB,                   GL_RGBA32F_ARB,                         0,
 236             GL_RGBA,                GL_FLOAT,
 237             WINED3DFMT_FLAG_RENDERTARGET},
 238     /* Hmm? */
 239     {WINED3DFMT_CxV8U8,             0,                                0,                                      0,
 240             0,                      0,
 241             0},
 242     /* Float */
 243     {WINED3DFMT_R16_FLOAT,          GL_RGB16F_ARB,                    GL_RGB16F_ARB,                          0,
 244             GL_RED,             GL_HALF_FLOAT_ARB,
 245             WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET},
 246     {WINED3DFMT_R16G16_FLOAT,       GL_RG16F,                         GL_RG16F,                               0,
 247             GL_RG,              GL_HALF_FLOAT_ARB,
 248             WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET},
 249     {WINED3DFMT_R16G16B16A16_FLOAT, GL_RGBA16F_ARB,                   GL_RGBA16F_ARB,                         0,
 250             GL_RGBA,            GL_HALF_FLOAT_ARB,
 251             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET},
 252     /* Palettized formats */
 253     {WINED3DFMT_A8P8,               0,                                0,                                      0,
 254             0,                      0,
 255             0},
 256     {WINED3DFMT_P8,                 GL_COLOR_INDEX8_EXT,              GL_COLOR_INDEX8_EXT,                    0,
 257             GL_COLOR_INDEX,         GL_UNSIGNED_BYTE,
 258             0},
 259     /* Standard ARGB formats */
 260     {WINED3DFMT_R8G8B8,             GL_RGB8,                          GL_RGB8,                                0,
 261             GL_BGR,                 GL_UNSIGNED_BYTE,
 262             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET},
 263     {WINED3DFMT_A8R8G8B8,           GL_RGBA8,                         GL_SRGB8_ALPHA8_EXT,                    0,
 264             GL_BGRA,                GL_UNSIGNED_INT_8_8_8_8_REV,
 265             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET},
 266     {WINED3DFMT_X8R8G8B8,           GL_RGB8,                          GL_SRGB8_EXT,                           0,
 267             GL_BGRA,                GL_UNSIGNED_INT_8_8_8_8_REV,
 268             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET},
 269     {WINED3DFMT_R5G6B5,             GL_RGB5,                          GL_RGB5,                                GL_RGB8,
 270             GL_RGB,                 GL_UNSIGNED_SHORT_5_6_5,
 271             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET},
 272     {WINED3DFMT_X1R5G5B5,           GL_RGB5,                          GL_RGB5_A1,                             0,
 273             GL_BGRA,                GL_UNSIGNED_SHORT_1_5_5_5_REV,
 274             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING},
 275     {WINED3DFMT_A1R5G5B5,           GL_RGB5_A1,                       GL_RGB5_A1,                             0,
 276             GL_BGRA,                GL_UNSIGNED_SHORT_1_5_5_5_REV,
 277             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING},
 278     {WINED3DFMT_A4R4G4B4,           GL_RGBA4,                         GL_SRGB8_ALPHA8_EXT,                    0,
 279             GL_BGRA,                GL_UNSIGNED_SHORT_4_4_4_4_REV,
 280             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING},
 281     {WINED3DFMT_R3G3B2,             GL_R3_G3_B2,                      GL_R3_G3_B2,                            0,
 282             GL_RGB,                 GL_UNSIGNED_BYTE_3_3_2,
 283             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING},
 284     {WINED3DFMT_A8_UNORM,           GL_ALPHA8,                        GL_ALPHA8,                              0,
 285             GL_ALPHA,               GL_UNSIGNED_BYTE,
 286             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING},
 287     {WINED3DFMT_A8R3G3B2,           0,                                0,                                      0,
 288             0,                      0,
 289             0},
 290     {WINED3DFMT_X4R4G4B4,           GL_RGB4,                          GL_RGB4,                                0,
 291             GL_BGRA,                GL_UNSIGNED_SHORT_4_4_4_4_REV,
 292             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING},
 293     {WINED3DFMT_R10G10B10A2_UNORM,  GL_RGB10_A2,                      GL_RGB10_A2,                            0,
 294             GL_RGBA,                GL_UNSIGNED_INT_2_10_10_10_REV,
 295             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING},
 296     {WINED3DFMT_R8G8B8A8_UNORM,     GL_RGBA8,                         GL_RGBA8,                               0,
 297             GL_RGBA,                GL_UNSIGNED_INT_8_8_8_8_REV,
 298             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING},
 299     {WINED3DFMT_X8B8G8R8,           GL_RGB8,                          GL_RGB8,                                0,
 300             GL_RGBA,                GL_UNSIGNED_INT_8_8_8_8_REV,
 301             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING},
 302     {WINED3DFMT_R16G16_UNORM,       GL_RGB16_EXT,                     GL_RGB16_EXT,                           0,
 303             GL_RGB,                 GL_UNSIGNED_SHORT,
 304             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING},
 305     {WINED3DFMT_A2R10G10B10,        GL_RGB10_A2,                      GL_RGB10_A2,                            0,
 306             GL_BGRA,                GL_UNSIGNED_INT_2_10_10_10_REV,
 307             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING},
 308     {WINED3DFMT_R16G16B16A16_UNORM, GL_RGBA16_EXT,                    GL_RGBA16_EXT,                          0,
 309             GL_RGBA,                GL_UNSIGNED_SHORT,
 310             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET},
 311     /* Luminance */
 312     {WINED3DFMT_L8,                 GL_LUMINANCE8,                    GL_SLUMINANCE8_EXT,                     0,
 313             GL_LUMINANCE,           GL_UNSIGNED_BYTE,
 314             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING},
 315     {WINED3DFMT_A8L8,               GL_LUMINANCE8_ALPHA8,             GL_SLUMINANCE8_ALPHA8_EXT,              0,
 316             GL_LUMINANCE_ALPHA,     GL_UNSIGNED_BYTE,
 317             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING},
 318     {WINED3DFMT_A4L4,               GL_LUMINANCE4_ALPHA4,             GL_LUMINANCE4_ALPHA4,                   0,
 319             GL_LUMINANCE_ALPHA,     GL_UNSIGNED_BYTE,
 320             0},
 321     /* Bump mapping stuff */
 322     {WINED3DFMT_R8G8_SNORM,         GL_DSDT8_NV,                      GL_DSDT8_NV,                            0,
 323             GL_DSDT_NV,             GL_BYTE,
 324             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING},
 325     {WINED3DFMT_L6V5U5,             GL_DSDT8_MAG8_NV,                 GL_DSDT8_MAG8_NV,                       0,
 326             GL_DSDT_MAG_NV,         GL_BYTE,
 327             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING},
 328     {WINED3DFMT_X8L8V8U8,           GL_DSDT8_MAG8_INTENSITY8_NV,      GL_DSDT8_MAG8_INTENSITY8_NV,            0,
 329             GL_DSDT_MAG_VIB_NV,     GL_UNSIGNED_INT_8_8_S8_S8_REV_NV,
 330             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING},
 331     {WINED3DFMT_R8G8B8A8_SNORM,     GL_SIGNED_RGBA8_NV,               GL_SIGNED_RGBA8_NV,                     0,
 332             GL_RGBA,                GL_BYTE,
 333             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING},
 334     {WINED3DFMT_R16G16_SNORM,       GL_SIGNED_HILO16_NV,              GL_SIGNED_HILO16_NV,                    0,
 335             GL_HILO_NV,             GL_SHORT,
 336             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING},
 337     {WINED3DFMT_W11V11U10,          0,                                0,                                      0,
 338             0,                      0,
 339             0},
 340     {WINED3DFMT_A2W10V10U10,        0,                                0,                                      0,
 341             0,                      0,
 342             0},
 343     /* Depth stencil formats */
 344     {WINED3DFMT_D16_LOCKABLE,       GL_DEPTH_COMPONENT24_ARB,         GL_DEPTH_COMPONENT24_ARB,               0,
 345             GL_DEPTH_COMPONENT,     GL_UNSIGNED_SHORT,
 346             WINED3DFMT_FLAG_DEPTH},
 347     {WINED3DFMT_D32,                GL_DEPTH_COMPONENT32_ARB,         GL_DEPTH_COMPONENT32_ARB,               0,
 348             GL_DEPTH_COMPONENT,     GL_UNSIGNED_INT,
 349             WINED3DFMT_FLAG_DEPTH},
 350     {WINED3DFMT_D15S1,              GL_DEPTH_COMPONENT24_ARB,         GL_DEPTH_COMPONENT24_ARB,               0,
 351             GL_DEPTH_COMPONENT,     GL_UNSIGNED_SHORT,
 352             WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL},
 353     {WINED3DFMT_D24S8,              GL_DEPTH_COMPONENT24_ARB,         GL_DEPTH_COMPONENT24_ARB,               0,
 354             GL_DEPTH_COMPONENT,     GL_UNSIGNED_INT,
 355             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL},
 356     {WINED3DFMT_D24X8,              GL_DEPTH_COMPONENT24_ARB,         GL_DEPTH_COMPONENT24_ARB,               0,
 357             GL_DEPTH_COMPONENT,     GL_UNSIGNED_INT,
 358             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_DEPTH},
 359     {WINED3DFMT_D24X4S4,            GL_DEPTH_COMPONENT24_ARB,         GL_DEPTH_COMPONENT24_ARB,               0,
 360             GL_DEPTH_COMPONENT,     GL_UNSIGNED_INT,
 361             WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL},
 362     {WINED3DFMT_D16_UNORM,          GL_DEPTH_COMPONENT24_ARB,         GL_DEPTH_COMPONENT24_ARB,               0,
 363             GL_DEPTH_COMPONENT,     GL_UNSIGNED_SHORT,
 364             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_DEPTH},
 365     {WINED3DFMT_L16,                GL_LUMINANCE16_EXT,               GL_LUMINANCE16_EXT,                     0,
 366             GL_LUMINANCE,           GL_UNSIGNED_SHORT,
 367             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING},
 368     {WINED3DFMT_D32F_LOCKABLE,      GL_DEPTH_COMPONENT32_ARB,         GL_DEPTH_COMPONENT32_ARB,               0,
 369             GL_DEPTH_COMPONENT,     GL_FLOAT,
 370             WINED3DFMT_FLAG_DEPTH},
 371     {WINED3DFMT_D24FS8,             GL_DEPTH_COMPONENT24_ARB,         GL_DEPTH_COMPONENT24_ARB,               0,
 372             GL_DEPTH_COMPONENT,     GL_FLOAT,
 373             WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL},
 374     /* Is this a vertex buffer? */
 375     {WINED3DFMT_VERTEXDATA,         0,                                0,                                      0,
 376             0,                      0,
 377             0},
 378     {WINED3DFMT_R16_UINT,           0,                                0,                                      0,
 379             0,                      0,
 380             0},
 381     {WINED3DFMT_R32_UINT,           0,                                0,                                      0,
 382             0,                      0,
 383             0},
 384     {WINED3DFMT_R16G16B16A16_SNORM, GL_COLOR_INDEX,                   GL_COLOR_INDEX,                         0,
 385             GL_COLOR_INDEX,         GL_UNSIGNED_SHORT,
 386             0},
 387     /* Vendor-specific formats */
 388     {WINED3DFMT_ATI2N,              0,                                0,                                      0,
 389             GL_LUMINANCE_ALPHA,     GL_UNSIGNED_BYTE,
 390             0},
 391     {WINED3DFMT_NVHU,               0,                                0,                                      0,
 392             GL_LUMINANCE_ALPHA,     GL_UNSIGNED_BYTE,
 393             0},
 394     {WINED3DFMT_NVHS,               0,                                0,                                      0,
 395             GL_LUMINANCE_ALPHA,     GL_UNSIGNED_BYTE,
 396             0}
 397 };
 398
 399 static inline int getFmtIdx(WINED3DFORMAT fmt) {
 400     /* First check if the format is at the position of its value.
 401      * This will catch the argb formats before the loop is entered
 402      */
 403     if(fmt < (sizeof(formats) / sizeof(formats[0])) && formats[fmt].format == fmt) {
 404         return fmt;
 405     } else {
 406         unsigned int i;
 407         for(i = 0; i < (sizeof(formats) / sizeof(formats[0])); i++) {
 408             if(formats[i].format == fmt) {
 409                 return i;
 410             }
 411         }
 412     }
 413     return -1;
 414 }
 415
 416 static BOOL init_format_base_info(WineD3D_GL_Info *gl_info)
 417 {
 418     UINT format_count = sizeof(formats) / sizeof(*formats);
 419     UINT i;
 420
 421     gl_info->gl_formats = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, format_count * sizeof(*gl_info->gl_formats));
 422     if (!gl_info->gl_formats)
 423     {
 424         ERR("Failed to allocate memory.\n");
 425         return FALSE;
 426     }
 427
 428     for (i = 0; i < format_count; ++i)
 429     {
 430         struct GlPixelFormatDesc *desc = &gl_info->gl_formats[i];
 431         desc->format = formats[i].format;
 432         desc->red_mask = formats[i].redMask;
 433         desc->green_mask = formats[i].greenMask;
 434         desc->blue_mask = formats[i].blueMask;
 435         desc->alpha_mask = formats[i].alphaMask;
 436         desc->byte_count = formats[i].bpp;
 437         desc->depth_size = formats[i].depthSize;
 438         desc->stencil_size = formats[i].stencilSize;
 439         if (formats[i].isFourcc) desc->Flags |= WINED3DFMT_FLAG_FOURCC;
 440     }
 441
 442     return TRUE;
 443 }
 444
 445 #define GLINFO_LOCATION (*gl_info)
 446
 447 static BOOL check_fbo_compat(const WineD3D_GL_Info *gl_info, GLint internal_format)
 448 {
 449     GLuint tex, fb;
 450     GLenum status;
 451
 452     while(glGetError());
 453     glGenTextures(1, &tex);
 454     glBindTexture(GL_TEXTURE_2D, tex);
 455     glTexImage2D(GL_TEXTURE_2D, 0, internal_format, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
 456
 457     GL_EXTCALL(glGenFramebuffersEXT(1, &fb));
 458     GL_EXTCALL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb));
 459     GL_EXTCALL(glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, tex, 0));
 460
 461     status = GL_EXTCALL(glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT));
 462     GL_EXTCALL(glDeleteFramebuffersEXT(1, &fb));
 463     glDeleteTextures(1, &tex);
 464
 465     checkGLcall("Framebuffer format check");
 466
 467     return status == GL_FRAMEBUFFER_COMPLETE_EXT;
 468 }
 469
 470 static BOOL init_format_texture_info(WineD3D_GL_Info *gl_info)
 471 {
 472     unsigned int i;
 473
 474     for (i = 0; i < sizeof(gl_formats_template) / sizeof(gl_formats_template[0]); ++i)
 475     {
 476         int fmt_idx = getFmtIdx(gl_formats_template[i].fmt);
 477         struct GlPixelFormatDesc *desc;
 478
 479         if (fmt_idx == -1)
 480         {
 481             ERR("Format %s (%#x) not found.\n",
 482                     debug_d3dformat(gl_formats_template[i].fmt), gl_formats_template[i].fmt);
 483             return FALSE;
 484         }
 485
 486         desc = &gl_info->gl_formats[fmt_idx];
 487         desc->glInternal = gl_formats_template[i].glInternal;
 488         desc->glGammaInternal = gl_formats_template[i].glGammaInternal;
 489         desc->glFormat = gl_formats_template[i].glFormat;
 490         desc->glType = gl_formats_template[i].glType;
 491         desc->color_fixup = COLOR_FIXUP_IDENTITY;
 492         desc->Flags |= gl_formats_template[i].Flags;
 493         desc->heightscale = 1.0;
 494
 495         if (wined3d_settings.offscreen_rendering_mode == ORM_FBO && gl_formats_template[i].rtInternal)
 496         {
 497             /* Check if the default internal format is supported as a frame buffer target, otherwise
 498              * fall back to the render target internal.
 499              *
 500              * Try to stick to the standard format if possible, this limits precision differences */
 501             if (!check_fbo_compat(gl_info, gl_formats_template[i].glInternal))
 502             {
 503                 TRACE("Internal format of %s not supported as FBO target, using render target internal instead\n",
 504                         debug_d3dformat(gl_formats_template[i].fmt));
 505                 desc->rtInternal = gl_formats_template[i].rtInternal;
 506             }
 507             else
 508             {
 509                 TRACE("Format %s is supported as fbo target\n", debug_d3dformat(gl_formats_template[i].fmt));
 510                 desc->rtInternal = gl_formats_template[i].glInternal;
 511             }
 512         }
 513         else
 514         {
 515             desc->rtInternal = gl_formats_template[i].glInternal;
 516         }
 517     }
 518
 519     return TRUE;
 520 }
 521
 522 static void apply_format_fixups(WineD3D_GL_Info *gl_info)
 523 {
 524     int idx;
 525
 526     idx = getFmtIdx(WINED3DFMT_R16_FLOAT);
 527     gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
 528             0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
 529     /* When ARB_texture_rg is supported we only require 16-bit for R16F instead of 64-bit RGBA16F */
 530     if (GL_SUPPORT(ARB_TEXTURE_RG))
 531     {
 532         gl_info->gl_formats[idx].glInternal = GL_R16F;
 533         gl_info->gl_formats[idx].glGammaInternal = GL_R16F;
 534     }
 535
 536     idx = getFmtIdx(WINED3DFMT_R32_FLOAT);
 537     gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
 538             0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
 539     /* When ARB_texture_rg is supported we only require 32-bit for R32F instead of 128-bit RGBA32F */
 540     if (GL_SUPPORT(ARB_TEXTURE_RG))
 541     {
 542         gl_info->gl_formats[idx].glInternal = GL_R32F;
 543         gl_info->gl_formats[idx].glGammaInternal = GL_R32F;
 544     }
 545
 546     idx = getFmtIdx(WINED3DFMT_R16G16_UNORM);
 547     gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
 548             0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
 549
 550     idx = getFmtIdx(WINED3DFMT_R16G16_FLOAT);
 551     gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
 552             0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
 553
 554     idx = getFmtIdx(WINED3DFMT_R32G32_FLOAT);
 555     gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
 556             0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
 557
 558     /* V8U8 is supported natively by GL_ATI_envmap_bumpmap and GL_NV_texture_shader.
 559      * V16U16 is only supported by GL_NV_texture_shader. The formats need fixup if
 560      * their extensions are not available. GL_ATI_envmap_bumpmap is not used because
 561      * the only driver that implements it(fglrx) has a buggy implementation.
 562      *
 563      * V8U8 and V16U16 need a fixup of the undefined blue channel. OpenGL
 564      * returns 0.0 when sampling from it, DirectX 1.0. So we always have in-shader
 565      * conversion for this format.
 566      */
 567     if (!GL_SUPPORT(NV_TEXTURE_SHADER))
 568     {
 569         idx = getFmtIdx(WINED3DFMT_R8G8_SNORM);
 570         gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
 571                 1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
 572         idx = getFmtIdx(WINED3DFMT_R16G16_SNORM);
 573         gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
 574                 1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
 575     }
 576     else
 577     {
 578         idx = getFmtIdx(WINED3DFMT_R8G8_SNORM);
 579         gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
 580                 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
 581         idx = getFmtIdx(WINED3DFMT_R16G16_SNORM);
 582         gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
 583                 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
 584     }
 585
 586     if (!GL_SUPPORT(NV_TEXTURE_SHADER))
 587     {
 588         /* If GL_NV_texture_shader is not supported, those formats are converted, incompatibly
 589          * with each other
 590          */
 591         idx = getFmtIdx(WINED3DFMT_L6V5U5);
 592         gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
 593                 1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Z, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE);
 594         idx = getFmtIdx(WINED3DFMT_X8L8V8U8);
 595         gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
 596                 1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_Z, 0, CHANNEL_SOURCE_W);
 597         idx = getFmtIdx(WINED3DFMT_R8G8B8A8_SNORM);
 598         gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
 599                 1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Y, 1, CHANNEL_SOURCE_Z, 1, CHANNEL_SOURCE_W);
 600     }
 601     else
 602     {
 603         /* If GL_NV_texture_shader is supported, WINED3DFMT_L6V5U5 and WINED3DFMT_X8L8V8U8
 604          * are converted at surface loading time, but they do not need any modification in
 605          * the shader, thus they are compatible with all WINED3DFMT_UNKNOWN group formats.
 606          * WINED3DFMT_Q8W8V8U8 doesn't even need load-time conversion
 607          */
 608     }
 609
 610     if (GL_SUPPORT(EXT_TEXTURE_COMPRESSION_RGTC))
 611     {
 612         idx = getFmtIdx(WINED3DFMT_ATI2N);
 613         gl_info->gl_formats[idx].glInternal = GL_COMPRESSED_RED_GREEN_RGTC2_EXT;
 614         gl_info->gl_formats[idx].glGammaInternal = GL_COMPRESSED_RED_GREEN_RGTC2_EXT;
 615         gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
 616                 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
 617     }
 618     else if (GL_SUPPORT(ATI_TEXTURE_COMPRESSION_3DC))
 619     {
 620         idx = getFmtIdx(WINED3DFMT_ATI2N);
 621         gl_info->gl_formats[idx].glInternal = GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI;
 622         gl_info->gl_formats[idx].glGammaInternal = GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI;
 623         gl_info->gl_formats[idx].color_fixup= create_color_fixup_desc(
 624                 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_W, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
 625     }
 626
 627     if (!GL_SUPPORT(APPLE_YCBCR_422))
 628     {
 629         idx = getFmtIdx(WINED3DFMT_YUY2);
 630         gl_info->gl_formats[idx].glInternal = GL_LUMINANCE_ALPHA;
 631         gl_info->gl_formats[idx].glGammaInternal = GL_LUMINANCE_ALPHA; /* not srgb */
 632         gl_info->gl_formats[idx].glFormat = GL_LUMINANCE_ALPHA;
 633         gl_info->gl_formats[idx].glType = GL_UNSIGNED_BYTE;
 634         gl_info->gl_formats[idx].color_fixup = create_yuv_fixup_desc(YUV_FIXUP_YUY2);
 635
 636         idx = getFmtIdx(WINED3DFMT_UYVY);
 637         gl_info->gl_formats[idx].glInternal = GL_LUMINANCE_ALPHA;
 638         gl_info->gl_formats[idx].glGammaInternal = GL_LUMINANCE_ALPHA; /* not srgb */
 639         gl_info->gl_formats[idx].glFormat = GL_LUMINANCE_ALPHA;
 640         gl_info->gl_formats[idx].glType = GL_UNSIGNED_BYTE;
 641         gl_info->gl_formats[idx].color_fixup = create_yuv_fixup_desc(YUV_FIXUP_UYVY);
 642     }
 643
 644     idx = getFmtIdx(WINED3DFMT_YV12);
 645     gl_info->gl_formats[idx].heightscale = 1.5;
 646     gl_info->gl_formats[idx].color_fixup = create_yuv_fixup_desc(YUV_FIXUP_YV12);
 647
 648     if (GL_SUPPORT(EXT_VERTEX_ARRAY_BGRA))
 649     {
 650         idx = getFmtIdx(WINED3DFMT_A8R8G8B8);
 651         gl_info->gl_formats[idx].gl_vtx_format = GL_BGRA;
 652     }
 653
 654     if (GL_SUPPORT(NV_HALF_FLOAT))
 655     {
 656         /* Do not change the size of the type, it is CPU side. We have to change the GPU-side information though.
 657          * It is the job of the vertex buffer code to make sure that the vbos have the right format */
 658         idx = getFmtIdx(WINED3DFMT_R16G16_FLOAT);
 659         gl_info->gl_formats[idx].gl_vtx_type = GL_HALF_FLOAT_NV;
 660
 661         idx = getFmtIdx(WINED3DFMT_R16G16B16A16_FLOAT);
 662         gl_info->gl_formats[idx].gl_vtx_type = GL_HALF_FLOAT_NV;
 663     }
 664 }
 665
 666 static BOOL init_format_vertex_info(WineD3D_GL_Info *gl_info)
 667 {
 668     unsigned int i;
 669
 670     for (i = 0; i < (sizeof(format_vertex_info) / sizeof(*format_vertex_info)); ++i)
 671     {
 672         struct GlPixelFormatDesc *format_desc;
 673         int fmt_idx = getFmtIdx(format_vertex_info[i].format);
 674
 675         if (fmt_idx == -1)
 676         {
 677             ERR("Format %s (%#x) not found.\n",
 678                     debug_d3dformat(format_vertex_info[i].format), format_vertex_info[i].format);
 679             return FALSE;
 680         }
 681
 682         format_desc = &gl_info->gl_formats[fmt_idx];
 683         format_desc->emit_idx = format_vertex_info[i].emit_idx;
 684         format_desc->component_count = format_vertex_info[i].component_count;
 685         format_desc->gl_vtx_type = format_vertex_info[i].gl_vtx_type;
 686         format_desc->gl_vtx_format = format_vertex_info[i].gl_vtx_format;
 687         format_desc->gl_normalized = format_vertex_info[i].gl_normalized;
 688         format_desc->component_size = format_vertex_info[i].component_size;
 689     }
 690
 691     return TRUE;
 692 }
 693
 694 BOOL initPixelFormatsNoGL(WineD3D_GL_Info *gl_info)
 695 {
 696     return init_format_base_info(gl_info);
 697 }
 698
 699 BOOL initPixelFormats(WineD3D_GL_Info *gl_info)
 700 {
 701     if (!init_format_base_info(gl_info)) return FALSE;
 702
 703     if (!init_format_texture_info(gl_info))
 704     {
 705         HeapFree(GetProcessHeap(), 0, gl_info->gl_formats);
 706         return FALSE;
 707     }
 708
 709     if (!init_format_vertex_info(gl_info))
 710     {
 711         HeapFree(GetProcessHeap(), 0, gl_info->gl_formats);
 712         return FALSE;
 713     }
 714
 715     apply_format_fixups(gl_info);
 716
 717     return TRUE;
 718 }
 719
 720 #undef GLINFO_LOCATION
 721
 722 #define GLINFO_LOCATION This->adapter->gl_info
 723
 724 const struct GlPixelFormatDesc *getFormatDescEntry(WINED3DFORMAT fmt, const WineD3D_GL_Info *gl_info)
 725 {
 726     int idx = getFmtIdx(fmt);
 727
 728     if(idx == -1) {
 729         FIXME("Can't find format %s(%d) in the format lookup table\n", debug_d3dformat(fmt), fmt);
 730         /* Get the caller a valid pointer */
 731         idx = getFmtIdx(WINED3DFMT_UNKNOWN);
 732     }
 733
 734     return &gl_info->gl_formats[idx];
 735 }
 736
 737 /*****************************************************************************
 738  * Trace formatting of useful values
 739  */
 740 const char* debug_d3dformat(WINED3DFORMAT fmt) {
 741   switch (fmt) {
 742 #define FMT_TO_STR(fmt) case fmt: return #fmt
 743     FMT_TO_STR(WINED3DFMT_UNKNOWN);
 744     FMT_TO_STR(WINED3DFMT_R8G8B8);
 745     FMT_TO_STR(WINED3DFMT_A8R8G8B8);
 746     FMT_TO_STR(WINED3DFMT_X8R8G8B8);
 747     FMT_TO_STR(WINED3DFMT_R5G6B5);
 748     FMT_TO_STR(WINED3DFMT_X1R5G5B5);
 749     FMT_TO_STR(WINED3DFMT_A1R5G5B5);
 750     FMT_TO_STR(WINED3DFMT_A4R4G4B4);
 751     FMT_TO_STR(WINED3DFMT_R3G3B2);
 752     FMT_TO_STR(WINED3DFMT_A8R3G3B2);
 753     FMT_TO_STR(WINED3DFMT_X4R4G4B4);
 754     FMT_TO_STR(WINED3DFMT_X8B8G8R8);
 755     FMT_TO_STR(WINED3DFMT_A2R10G10B10);
 756     FMT_TO_STR(WINED3DFMT_A8P8);
 757     FMT_TO_STR(WINED3DFMT_P8);
 758     FMT_TO_STR(WINED3DFMT_L8);
 759     FMT_TO_STR(WINED3DFMT_A8L8);
 760     FMT_TO_STR(WINED3DFMT_A4L4);
 761     FMT_TO_STR(WINED3DFMT_L6V5U5);
 762     FMT_TO_STR(WINED3DFMT_X8L8V8U8);
 763     FMT_TO_STR(WINED3DFMT_W11V11U10);
 764     FMT_TO_STR(WINED3DFMT_A2W10V10U10);
 765     FMT_TO_STR(WINED3DFMT_UYVY);
 766     FMT_TO_STR(WINED3DFMT_YUY2);
 767     FMT_TO_STR(WINED3DFMT_YV12);
 768     FMT_TO_STR(WINED3DFMT_DXT1);
 769     FMT_TO_STR(WINED3DFMT_DXT2);
 770     FMT_TO_STR(WINED3DFMT_DXT3);
 771     FMT_TO_STR(WINED3DFMT_DXT4);
 772     FMT_TO_STR(WINED3DFMT_DXT5);
 773     FMT_TO_STR(WINED3DFMT_MULTI2_ARGB8);
 774     FMT_TO_STR(WINED3DFMT_G8R8_G8B8);
 775     FMT_TO_STR(WINED3DFMT_R8G8_B8G8);
 776     FMT_TO_STR(WINED3DFMT_D16_LOCKABLE);
 777     FMT_TO_STR(WINED3DFMT_D32);
 778     FMT_TO_STR(WINED3DFMT_D15S1);
 779     FMT_TO_STR(WINED3DFMT_D24S8);
 780     FMT_TO_STR(WINED3DFMT_D24X8);
 781     FMT_TO_STR(WINED3DFMT_D24X4S4);
 782     FMT_TO_STR(WINED3DFMT_L16);
 783     FMT_TO_STR(WINED3DFMT_D32F_LOCKABLE);
 784     FMT_TO_STR(WINED3DFMT_D24FS8);
 785     FMT_TO_STR(WINED3DFMT_VERTEXDATA);
 786     FMT_TO_STR(WINED3DFMT_CxV8U8);
 787     FMT_TO_STR(WINED3DFMT_ATI2N);
 788     FMT_TO_STR(WINED3DFMT_NVHU);
 789     FMT_TO_STR(WINED3DFMT_NVHS);
 790     FMT_TO_STR(WINED3DFMT_R32G32B32A32_TYPELESS);
 791     FMT_TO_STR(WINED3DFMT_R32G32B32A32_FLOAT);
 792     FMT_TO_STR(WINED3DFMT_R32G32B32A32_UINT);
 793     FMT_TO_STR(WINED3DFMT_R32G32B32A32_SINT);
 794     FMT_TO_STR(WINED3DFMT_R32G32B32_TYPELESS);
 795     FMT_TO_STR(WINED3DFMT_R32G32B32_FLOAT);
 796     FMT_TO_STR(WINED3DFMT_R32G32B32_UINT);
 797     FMT_TO_STR(WINED3DFMT_R32G32B32_SINT);
 798     FMT_TO_STR(WINED3DFMT_R16G16B16A16_TYPELESS);
 799     FMT_TO_STR(WINED3DFMT_R16G16B16A16_FLOAT);
 800     FMT_TO_STR(WINED3DFMT_R16G16B16A16_UNORM);
 801     FMT_TO_STR(WINED3DFMT_R16G16B16A16_UINT);
 802     FMT_TO_STR(WINED3DFMT_R16G16B16A16_SNORM);
 803     FMT_TO_STR(WINED3DFMT_R16G16B16A16_SINT);
 804     FMT_TO_STR(WINED3DFMT_R32G32_TYPELESS);
 805     FMT_TO_STR(WINED3DFMT_R32G32_FLOAT);
 806     FMT_TO_STR(WINED3DFMT_R32G32_UINT);
 807     FMT_TO_STR(WINED3DFMT_R32G32_SINT);
 808     FMT_TO_STR(WINED3DFMT_R32G8X24_TYPELESS);
 809     FMT_TO_STR(WINED3DFMT_D32_FLOAT_S8X24_UINT);
 810     FMT_TO_STR(WINED3DFMT_R32_FLOAT_X8X24_TYPELESS);
 811     FMT_TO_STR(WINED3DFMT_X32_TYPELESS_G8X24_UINT);
 812     FMT_TO_STR(WINED3DFMT_R10G10B10A2_TYPELESS);
 813     FMT_TO_STR(WINED3DFMT_R10G10B10A2_UNORM);
 814     FMT_TO_STR(WINED3DFMT_R10G10B10A2_UINT);
 815     FMT_TO_STR(WINED3DFMT_R10G10B10A2_SNORM);
 816     FMT_TO_STR(WINED3DFMT_R11G11B10_FLOAT);
 817     FMT_TO_STR(WINED3DFMT_R8G8B8A8_TYPELESS);
 818     FMT_TO_STR(WINED3DFMT_R8G8B8A8_UNORM);
 819     FMT_TO_STR(WINED3DFMT_R8G8B8A8_UNORM_SRGB);
 820     FMT_TO_STR(WINED3DFMT_R8G8B8A8_UINT);
 821     FMT_TO_STR(WINED3DFMT_R8G8B8A8_SNORM);
 822     FMT_TO_STR(WINED3DFMT_R8G8B8A8_SINT);
 823     FMT_TO_STR(WINED3DFMT_R16G16_TYPELESS);
 824     FMT_TO_STR(WINED3DFMT_R16G16_FLOAT);
 825     FMT_TO_STR(WINED3DFMT_R16G16_UNORM);
 826     FMT_TO_STR(WINED3DFMT_R16G16_UINT);
 827     FMT_TO_STR(WINED3DFMT_R16G16_SNORM);
 828     FMT_TO_STR(WINED3DFMT_R16G16_SINT);
 829     FMT_TO_STR(WINED3DFMT_R32_TYPELESS);
 830     FMT_TO_STR(WINED3DFMT_D32_FLOAT);
 831     FMT_TO_STR(WINED3DFMT_R32_FLOAT);
 832     FMT_TO_STR(WINED3DFMT_R32_UINT);
 833     FMT_TO_STR(WINED3DFMT_R32_SINT);
 834     FMT_TO_STR(WINED3DFMT_R24G8_TYPELESS);
 835     FMT_TO_STR(WINED3DFMT_D24_UNORM_S8_UINT);
 836     FMT_TO_STR(WINED3DFMT_R24_UNORM_X8_TYPELESS);
 837     FMT_TO_STR(WINED3DFMT_X24_TYPELESS_G8_UINT);
 838     FMT_TO_STR(WINED3DFMT_R8G8_TYPELESS);
 839     FMT_TO_STR(WINED3DFMT_R8G8_UNORM);
 840     FMT_TO_STR(WINED3DFMT_R8G8_UINT);
 841     FMT_TO_STR(WINED3DFMT_R8G8_SNORM);
 842     FMT_TO_STR(WINED3DFMT_R8G8_SINT);
 843     FMT_TO_STR(WINED3DFMT_R16_TYPELESS);
 844     FMT_TO_STR(WINED3DFMT_R16_FLOAT);
 845     FMT_TO_STR(WINED3DFMT_D16_UNORM);
 846     FMT_TO_STR(WINED3DFMT_R16_UNORM);
 847     FMT_TO_STR(WINED3DFMT_R16_UINT);
 848     FMT_TO_STR(WINED3DFMT_R16_SNORM);
 849     FMT_TO_STR(WINED3DFMT_R16_SINT);
 850     FMT_TO_STR(WINED3DFMT_R8_TYPELESS);
 851     FMT_TO_STR(WINED3DFMT_R8_UNORM);
 852     FMT_TO_STR(WINED3DFMT_R8_UINT);
 853     FMT_TO_STR(WINED3DFMT_R8_SNORM);
 854     FMT_TO_STR(WINED3DFMT_R8_SINT);
 855     FMT_TO_STR(WINED3DFMT_A8_UNORM);
 856     FMT_TO_STR(WINED3DFMT_R1_UNORM);
 857     FMT_TO_STR(WINED3DFMT_R9G9B9E5_SHAREDEXP);
 858     FMT_TO_STR(WINED3DFMT_R8G8_B8G8_UNORM);
 859     FMT_TO_STR(WINED3DFMT_G8R8_G8B8_UNORM);
 860     FMT_TO_STR(WINED3DFMT_BC1_TYPELESS);
 861     FMT_TO_STR(WINED3DFMT_BC1_UNORM);
 862     FMT_TO_STR(WINED3DFMT_BC1_UNORM_SRGB);
 863     FMT_TO_STR(WINED3DFMT_BC2_TYPELESS);
 864     FMT_TO_STR(WINED3DFMT_BC2_UNORM);
 865     FMT_TO_STR(WINED3DFMT_BC2_UNORM_SRGB);
 866     FMT_TO_STR(WINED3DFMT_BC3_TYPELESS);
 867     FMT_TO_STR(WINED3DFMT_BC3_UNORM);
 868     FMT_TO_STR(WINED3DFMT_BC3_UNORM_SRGB);
 869     FMT_TO_STR(WINED3DFMT_BC4_TYPELESS);
 870     FMT_TO_STR(WINED3DFMT_BC4_UNORM);
 871     FMT_TO_STR(WINED3DFMT_BC4_SNORM);
 872     FMT_TO_STR(WINED3DFMT_BC5_TYPELESS);
 873     FMT_TO_STR(WINED3DFMT_BC5_UNORM);
 874     FMT_TO_STR(WINED3DFMT_BC5_SNORM);
 875     FMT_TO_STR(WINED3DFMT_B5G6R5_UNORM);
 876     FMT_TO_STR(WINED3DFMT_B5G5R5A1_UNORM);
 877     FMT_TO_STR(WINED3DFMT_B8G8R8A8_UNORM);
 878     FMT_TO_STR(WINED3DFMT_B8G8R8X8_UNORM);
 879 #undef FMT_TO_STR
 880   default:
 881     {
 882       char fourcc[5];
 883       fourcc[0] = (char)(fmt);
 884       fourcc[1] = (char)(fmt >> 8);
 885       fourcc[2] = (char)(fmt >> 16);
 886       fourcc[3] = (char)(fmt >> 24);
 887       fourcc[4] = 0;
 888       if( isprint(fourcc[0]) && isprint(fourcc[1]) && isprint(fourcc[2]) && isprint(fourcc[3]) )
 889         FIXME("Unrecognized %u (as fourcc: %s) WINED3DFORMAT!\n", fmt, fourcc);
 890       else
 891         FIXME("Unrecognized %u WINED3DFORMAT!\n", fmt);
 892     }
 893     return "unrecognized";
 894   }
 895 }
 896
 897 const char* debug_d3ddevicetype(WINED3DDEVTYPE devtype) {
 898   switch (devtype) {
 899 #define DEVTYPE_TO_STR(dev) case dev: return #dev
 900     DEVTYPE_TO_STR(WINED3DDEVTYPE_HAL);
 901     DEVTYPE_TO_STR(WINED3DDEVTYPE_REF);
 902     DEVTYPE_TO_STR(WINED3DDEVTYPE_SW);
 903 #undef DEVTYPE_TO_STR
 904   default:
 905     FIXME("Unrecognized %u WINED3DDEVTYPE!\n", devtype);
 906     return "unrecognized";
 907   }
 908 }
 909
 910 const char* debug_d3dusage(DWORD usage) {
 911   switch (usage & WINED3DUSAGE_MASK) {
 912 #define WINED3DUSAGE_TO_STR(u) case u: return #u
 913     WINED3DUSAGE_TO_STR(WINED3DUSAGE_RENDERTARGET);
 914     WINED3DUSAGE_TO_STR(WINED3DUSAGE_DEPTHSTENCIL);
 915     WINED3DUSAGE_TO_STR(WINED3DUSAGE_WRITEONLY);
 916     WINED3DUSAGE_TO_STR(WINED3DUSAGE_SOFTWAREPROCESSING);
 917     WINED3DUSAGE_TO_STR(WINED3DUSAGE_DONOTCLIP);
 918     WINED3DUSAGE_TO_STR(WINED3DUSAGE_POINTS);
 919     WINED3DUSAGE_TO_STR(WINED3DUSAGE_RTPATCHES);
 920     WINED3DUSAGE_TO_STR(WINED3DUSAGE_NPATCHES);
 921     WINED3DUSAGE_TO_STR(WINED3DUSAGE_DYNAMIC);
 922     WINED3DUSAGE_TO_STR(WINED3DUSAGE_AUTOGENMIPMAP);
 923     WINED3DUSAGE_TO_STR(WINED3DUSAGE_DMAP);
 924 #undef WINED3DUSAGE_TO_STR
 925   case 0: return "none";
 926   default:
 927     FIXME("Unrecognized %u Usage!\n", usage);
 928     return "unrecognized";
 929   }
 930 }
 931
 932 const char* debug_d3dusagequery(DWORD usagequery) {
 933   switch (usagequery & WINED3DUSAGE_QUERY_MASK) {
 934 #define WINED3DUSAGEQUERY_TO_STR(u) case u: return #u
 935     WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_FILTER);
 936     WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_LEGACYBUMPMAP);
 937     WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING);
 938     WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_SRGBREAD);
 939     WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_SRGBWRITE);
 940     WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_VERTEXTEXTURE);
 941     WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_WRAPANDMIP);
 942 #undef WINED3DUSAGEQUERY_TO_STR
 943   case 0: return "none";
 944   default:
 945     FIXME("Unrecognized %u Usage Query!\n", usagequery);
 946     return "unrecognized";
 947   }
 948 }
 949
 950 const char* debug_d3ddeclmethod(WINED3DDECLMETHOD method) {
 951     switch (method) {
 952 #define WINED3DDECLMETHOD_TO_STR(u) case u: return #u
 953         WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_DEFAULT);
 954         WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_PARTIALU);
 955         WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_PARTIALV);
 956         WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_CROSSUV);
 957         WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_UV);
 958         WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_LOOKUP);
 959         WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_LOOKUPPRESAMPLED);
 960 #undef WINED3DDECLMETHOD_TO_STR
 961         default:
 962             FIXME("Unrecognized %u declaration method!\n", method);
 963             return "unrecognized";
 964     }
 965 }
 966
 967 const char* debug_d3ddeclusage(BYTE usage) {
 968     switch (usage) {
 969 #define WINED3DDECLUSAGE_TO_STR(u) case u: return #u
 970         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_POSITION);
 971         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BLENDWEIGHT);
 972         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BLENDINDICES);
 973         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_NORMAL);
 974         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_PSIZE);
 975         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TEXCOORD);
 976         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TANGENT);
 977         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BINORMAL);
 978         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TESSFACTOR);
 979         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_POSITIONT);
 980         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_COLOR);
 981         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_FOG);
 982         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_DEPTH);
 983         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_SAMPLE);
 984 #undef WINED3DDECLUSAGE_TO_STR
 985         default:
 986             FIXME("Unrecognized %u declaration usage!\n", usage);
 987             return "unrecognized";
 988     }
 989 }
 990
 991 const char* debug_d3dresourcetype(WINED3DRESOURCETYPE res) {
 992   switch (res) {
 993 #define RES_TO_STR(res) case res: return #res
 994     RES_TO_STR(WINED3DRTYPE_SURFACE);
 995     RES_TO_STR(WINED3DRTYPE_VOLUME);
 996     RES_TO_STR(WINED3DRTYPE_TEXTURE);
 997     RES_TO_STR(WINED3DRTYPE_VOLUMETEXTURE);
 998     RES_TO_STR(WINED3DRTYPE_CUBETEXTURE);
 999     RES_TO_STR(WINED3DRTYPE_VERTEXBUFFER);
1000     RES_TO_STR(WINED3DRTYPE_INDEXBUFFER);
1001     RES_TO_STR(WINED3DRTYPE_BUFFER);
1002 #undef  RES_TO_STR
1003   default:
1004     FIXME("Unrecognized %u WINED3DRESOURCETYPE!\n", res);
1005     return "unrecognized";
1006   }
1007 }
1008
1009 const char* debug_d3dprimitivetype(WINED3DPRIMITIVETYPE PrimitiveType) {
1010   switch (PrimitiveType) {
1011 #define PRIM_TO_STR(prim) case prim: return #prim
1012     PRIM_TO_STR(WINED3DPT_UNDEFINED);
1013     PRIM_TO_STR(WINED3DPT_POINTLIST);
1014     PRIM_TO_STR(WINED3DPT_LINELIST);
1015     PRIM_TO_STR(WINED3DPT_LINESTRIP);
1016     PRIM_TO_STR(WINED3DPT_TRIANGLELIST);
1017     PRIM_TO_STR(WINED3DPT_TRIANGLESTRIP);
1018     PRIM_TO_STR(WINED3DPT_TRIANGLEFAN);
1019     PRIM_TO_STR(WINED3DPT_LINELIST_ADJ);
1020     PRIM_TO_STR(WINED3DPT_LINESTRIP_ADJ);
1021     PRIM_TO_STR(WINED3DPT_TRIANGLELIST_ADJ);
1022     PRIM_TO_STR(WINED3DPT_TRIANGLESTRIP_ADJ);
1023 #undef  PRIM_TO_STR
1024   default:
1025     FIXME("Unrecognized %u WINED3DPRIMITIVETYPE!\n", PrimitiveType);
1026     return "unrecognized";
1027   }
1028 }
1029
1030 const char* debug_d3drenderstate(DWORD state) {
1031   switch (state) {
1032 #define D3DSTATE_TO_STR(u) case u: return #u
1033     D3DSTATE_TO_STR(WINED3DRS_TEXTUREHANDLE             );
1034     D3DSTATE_TO_STR(WINED3DRS_ANTIALIAS                 );
1035     D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESS            );
1036     D3DSTATE_TO_STR(WINED3DRS_TEXTUREPERSPECTIVE        );
1037     D3DSTATE_TO_STR(WINED3DRS_WRAPU                     );
1038     D3DSTATE_TO_STR(WINED3DRS_WRAPV                     );
1039     D3DSTATE_TO_STR(WINED3DRS_ZENABLE                   );
1040     D3DSTATE_TO_STR(WINED3DRS_FILLMODE                  );
1041     D3DSTATE_TO_STR(WINED3DRS_SHADEMODE                 );
1042     D3DSTATE_TO_STR(WINED3DRS_LINEPATTERN               );
1043     D3DSTATE_TO_STR(WINED3DRS_MONOENABLE                );
1044     D3DSTATE_TO_STR(WINED3DRS_ROP2                      );
1045     D3DSTATE_TO_STR(WINED3DRS_PLANEMASK                 );
1046     D3DSTATE_TO_STR(WINED3DRS_ZWRITEENABLE              );
1047     D3DSTATE_TO_STR(WINED3DRS_ALPHATESTENABLE           );
1048     D3DSTATE_TO_STR(WINED3DRS_LASTPIXEL                 );
1049     D3DSTATE_TO_STR(WINED3DRS_TEXTUREMAG                );
1050     D3DSTATE_TO_STR(WINED3DRS_TEXTUREMIN                );
1051     D3DSTATE_TO_STR(WINED3DRS_SRCBLEND                  );
1052     D3DSTATE_TO_STR(WINED3DRS_DESTBLEND                 );
1053     D3DSTATE_TO_STR(WINED3DRS_TEXTUREMAPBLEND           );
1054     D3DSTATE_TO_STR(WINED3DRS_CULLMODE                  );
1055     D3DSTATE_TO_STR(WINED3DRS_ZFUNC                     );
1056     D3DSTATE_TO_STR(WINED3DRS_ALPHAREF                  );
1057     D3DSTATE_TO_STR(WINED3DRS_ALPHAFUNC                 );
1058     D3DSTATE_TO_STR(WINED3DRS_DITHERENABLE              );
1059     D3DSTATE_TO_STR(WINED3DRS_ALPHABLENDENABLE          );
1060     D3DSTATE_TO_STR(WINED3DRS_FOGENABLE                 );
1061     D3DSTATE_TO_STR(WINED3DRS_SPECULARENABLE            );
1062     D3DSTATE_TO_STR(WINED3DRS_ZVISIBLE                  );
1063     D3DSTATE_TO_STR(WINED3DRS_SUBPIXEL                  );
1064     D3DSTATE_TO_STR(WINED3DRS_SUBPIXELX                 );
1065     D3DSTATE_TO_STR(WINED3DRS_STIPPLEDALPHA             );
1066     D3DSTATE_TO_STR(WINED3DRS_FOGCOLOR                  );
1067     D3DSTATE_TO_STR(WINED3DRS_FOGTABLEMODE              );
1068     D3DSTATE_TO_STR(WINED3DRS_FOGSTART                  );
1069     D3DSTATE_TO_STR(WINED3DRS_FOGEND                    );
1070     D3DSTATE_TO_STR(WINED3DRS_FOGDENSITY                );
1071     D3DSTATE_TO_STR(WINED3DRS_STIPPLEENABLE             );
1072     D3DSTATE_TO_STR(WINED3DRS_EDGEANTIALIAS             );
1073     D3DSTATE_TO_STR(WINED3DRS_COLORKEYENABLE            );
1074     D3DSTATE_TO_STR(WINED3DRS_BORDERCOLOR               );
1075     D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESSU           );
1076     D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESSV           );
1077     D3DSTATE_TO_STR(WINED3DRS_MIPMAPLODBIAS             );
1078     D3DSTATE_TO_STR(WINED3DRS_ZBIAS                     );
1079     D3DSTATE_TO_STR(WINED3DRS_RANGEFOGENABLE            );
1080     D3DSTATE_TO_STR(WINED3DRS_ANISOTROPY                );
1081     D3DSTATE_TO_STR(WINED3DRS_FLUSHBATCH                );
1082     D3DSTATE_TO_STR(WINED3DRS_TRANSLUCENTSORTINDEPENDENT);
1083     D3DSTATE_TO_STR(WINED3DRS_STENCILENABLE             );
1084     D3DSTATE_TO_STR(WINED3DRS_STENCILFAIL               );
1085     D3DSTATE_TO_STR(WINED3DRS_STENCILZFAIL              );
1086     D3DSTATE_TO_STR(WINED3DRS_STENCILPASS               );
1087     D3DSTATE_TO_STR(WINED3DRS_STENCILFUNC               );
1088     D3DSTATE_TO_STR(WINED3DRS_STENCILREF                );
1089     D3DSTATE_TO_STR(WINED3DRS_STENCILMASK               );
1090     D3DSTATE_TO_STR(WINED3DRS_STENCILWRITEMASK          );
1091     D3DSTATE_TO_STR(WINED3DRS_TEXTUREFACTOR             );
1092     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN00          );
1093     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN01          );
1094     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN02          );
1095     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN03          );
1096     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN04          );
1097     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN05          );
1098     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN06          );
1099     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN07          );
1100     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN08          );
1101     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN09          );
1102     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN10          );
1103     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN11          );
1104     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN12          );
1105     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN13          );
1106     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN14          );
1107     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN15          );
1108     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN16          );
1109     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN17          );
1110     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN18          );
1111     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN19          );
1112     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN20          );
1113     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN21          );
1114     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN22          );
1115     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN23          );
1116     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN24          );
1117     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN25          );
1118     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN26          );
1119     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN27          );
1120     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN28          );
1121     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN29          );
1122     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN30          );
1123     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN31          );
1124     D3DSTATE_TO_STR(WINED3DRS_WRAP0                     );
1125     D3DSTATE_TO_STR(WINED3DRS_WRAP1                     );
1126     D3DSTATE_TO_STR(WINED3DRS_WRAP2                     );
1127     D3DSTATE_TO_STR(WINED3DRS_WRAP3                     );
1128     D3DSTATE_TO_STR(WINED3DRS_WRAP4                     );
1129     D3DSTATE_TO_STR(WINED3DRS_WRAP5                     );
1130     D3DSTATE_TO_STR(WINED3DRS_WRAP6                     );
1131     D3DSTATE_TO_STR(WINED3DRS_WRAP7                     );
1132     D3DSTATE_TO_STR(WINED3DRS_CLIPPING                  );
1133     D3DSTATE_TO_STR(WINED3DRS_LIGHTING                  );
1134     D3DSTATE_TO_STR(WINED3DRS_EXTENTS                   );
1135     D3DSTATE_TO_STR(WINED3DRS_AMBIENT                   );
1136     D3DSTATE_TO_STR(WINED3DRS_FOGVERTEXMODE             );
1137     D3DSTATE_TO_STR(WINED3DRS_COLORVERTEX               );
1138     D3DSTATE_TO_STR(WINED3DRS_LOCALVIEWER               );
1139     D3DSTATE_TO_STR(WINED3DRS_NORMALIZENORMALS          );
1140     D3DSTATE_TO_STR(WINED3DRS_COLORKEYBLENDENABLE       );
1141     D3DSTATE_TO_STR(WINED3DRS_DIFFUSEMATERIALSOURCE     );
1142     D3DSTATE_TO_STR(WINED3DRS_SPECULARMATERIALSOURCE    );
1143     D3DSTATE_TO_STR(WINED3DRS_AMBIENTMATERIALSOURCE     );
1144     D3DSTATE_TO_STR(WINED3DRS_EMISSIVEMATERIALSOURCE    );
1145     D3DSTATE_TO_STR(WINED3DRS_VERTEXBLEND               );
1146     D3DSTATE_TO_STR(WINED3DRS_CLIPPLANEENABLE           );
1147     D3DSTATE_TO_STR(WINED3DRS_SOFTWAREVERTEXPROCESSING  );
1148     D3DSTATE_TO_STR(WINED3DRS_POINTSIZE                 );
1149     D3DSTATE_TO_STR(WINED3DRS_POINTSIZE_MIN             );
1150     D3DSTATE_TO_STR(WINED3DRS_POINTSPRITEENABLE         );
1151     D3DSTATE_TO_STR(WINED3DRS_POINTSCALEENABLE          );
1152     D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_A              );
1153     D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_B              );
1154     D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_C              );
1155     D3DSTATE_TO_STR(WINED3DRS_MULTISAMPLEANTIALIAS      );
1156     D3DSTATE_TO_STR(WINED3DRS_MULTISAMPLEMASK           );
1157     D3DSTATE_TO_STR(WINED3DRS_PATCHEDGESTYLE            );
1158     D3DSTATE_TO_STR(WINED3DRS_PATCHSEGMENTS             );
1159     D3DSTATE_TO_STR(WINED3DRS_DEBUGMONITORTOKEN         );
1160     D3DSTATE_TO_STR(WINED3DRS_POINTSIZE_MAX             );
1161     D3DSTATE_TO_STR(WINED3DRS_INDEXEDVERTEXBLENDENABLE  );
1162     D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE          );
1163     D3DSTATE_TO_STR(WINED3DRS_TWEENFACTOR               );
1164     D3DSTATE_TO_STR(WINED3DRS_BLENDOP                   );
1165     D3DSTATE_TO_STR(WINED3DRS_POSITIONDEGREE            );
1166     D3DSTATE_TO_STR(WINED3DRS_NORMALDEGREE              );
1167     D3DSTATE_TO_STR(WINED3DRS_SCISSORTESTENABLE         );
1168     D3DSTATE_TO_STR(WINED3DRS_SLOPESCALEDEPTHBIAS       );
1169     D3DSTATE_TO_STR(WINED3DRS_ANTIALIASEDLINEENABLE     );
1170     D3DSTATE_TO_STR(WINED3DRS_MINTESSELLATIONLEVEL      );
1171     D3DSTATE_TO_STR(WINED3DRS_MAXTESSELLATIONLEVEL      );
1172     D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_X            );
1173     D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_Y            );
1174     D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_Z            );
1175     D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_W            );
1176     D3DSTATE_TO_STR(WINED3DRS_ENABLEADAPTIVETESSELLATION);
1177     D3DSTATE_TO_STR(WINED3DRS_TWOSIDEDSTENCILMODE       );
1178     D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILFAIL           );
1179     D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILZFAIL          );
1180     D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILPASS           );
1181     D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILFUNC           );
1182     D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE1         );
1183     D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE2         );
1184     D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE3         );
1185     D3DSTATE_TO_STR(WINED3DRS_BLENDFACTOR               );
1186     D3DSTATE_TO_STR(WINED3DRS_SRGBWRITEENABLE           );
1187     D3DSTATE_TO_STR(WINED3DRS_DEPTHBIAS                 );
1188     D3DSTATE_TO_STR(WINED3DRS_WRAP8                     );
1189     D3DSTATE_TO_STR(WINED3DRS_WRAP9                     );
1190     D3DSTATE_TO_STR(WINED3DRS_WRAP10                    );
1191     D3DSTATE_TO_STR(WINED3DRS_WRAP11                    );
1192     D3DSTATE_TO_STR(WINED3DRS_WRAP12                    );
1193     D3DSTATE_TO_STR(WINED3DRS_WRAP13                    );
1194     D3DSTATE_TO_STR(WINED3DRS_WRAP14                    );
1195     D3DSTATE_TO_STR(WINED3DRS_WRAP15                    );
1196     D3DSTATE_TO_STR(WINED3DRS_SEPARATEALPHABLENDENABLE  );
1197     D3DSTATE_TO_STR(WINED3DRS_SRCBLENDALPHA             );
1198     D3DSTATE_TO_STR(WINED3DRS_DESTBLENDALPHA            );
1199     D3DSTATE_TO_STR(WINED3DRS_BLENDOPALPHA              );
1200 #undef D3DSTATE_TO_STR
1201   default:
1202     FIXME("Unrecognized %u render state!\n", state);
1203     return "unrecognized";
1204   }
1205 }
1206
1207 const char* debug_d3dsamplerstate(DWORD state) {
1208   switch (state) {
1209 #define D3DSTATE_TO_STR(u) case u: return #u
1210     D3DSTATE_TO_STR(WINED3DSAMP_BORDERCOLOR  );
1211     D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSU     );
1212     D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSV     );
1213     D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSW     );
1214     D3DSTATE_TO_STR(WINED3DSAMP_MAGFILTER    );
1215     D3DSTATE_TO_STR(WINED3DSAMP_MINFILTER    );
1216     D3DSTATE_TO_STR(WINED3DSAMP_MIPFILTER    );
1217     D3DSTATE_TO_STR(WINED3DSAMP_MIPMAPLODBIAS);
1218     D3DSTATE_TO_STR(WINED3DSAMP_MAXMIPLEVEL  );
1219     D3DSTATE_TO_STR(WINED3DSAMP_MAXANISOTROPY);
1220     D3DSTATE_TO_STR(WINED3DSAMP_SRGBTEXTURE  );
1221     D3DSTATE_TO_STR(WINED3DSAMP_ELEMENTINDEX );
1222     D3DSTATE_TO_STR(WINED3DSAMP_DMAPOFFSET   );
1223 #undef D3DSTATE_TO_STR
1224   default:
1225     FIXME("Unrecognized %u sampler state!\n", state);
1226     return "unrecognized";
1227   }
1228 }
1229
1230 const char *debug_d3dtexturefiltertype(WINED3DTEXTUREFILTERTYPE filter_type) {
1231     switch (filter_type) {
1232 #define D3DTEXTUREFILTERTYPE_TO_STR(u) case u: return #u
1233         D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_NONE);
1234         D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_POINT);
1235         D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_LINEAR);
1236         D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_ANISOTROPIC);
1237         D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_FLATCUBIC);
1238         D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_GAUSSIANCUBIC);
1239         D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_PYRAMIDALQUAD);
1240         D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_GAUSSIANQUAD);
1241 #undef D3DTEXTUREFILTERTYPE_TO_STR
1242         default:
1243             FIXME("Unrecognied texture filter type 0x%08x\n", filter_type);
1244             return "unrecognized";
1245     }
1246 }
1247
1248 const char* debug_d3dtexturestate(DWORD state) {
1249   switch (state) {
1250 #define D3DSTATE_TO_STR(u) case u: return #u
1251     D3DSTATE_TO_STR(WINED3DTSS_COLOROP               );
1252     D3DSTATE_TO_STR(WINED3DTSS_COLORARG1             );
1253     D3DSTATE_TO_STR(WINED3DTSS_COLORARG2             );
1254     D3DSTATE_TO_STR(WINED3DTSS_ALPHAOP               );
1255     D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG1             );
1256     D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG2             );
1257     D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT00          );
1258     D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT01          );
1259     D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT10          );
1260     D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT11          );
1261     D3DSTATE_TO_STR(WINED3DTSS_TEXCOORDINDEX         );
1262     D3DSTATE_TO_STR(WINED3DTSS_BUMPENVLSCALE         );
1263     D3DSTATE_TO_STR(WINED3DTSS_BUMPENVLOFFSET        );
1264     D3DSTATE_TO_STR(WINED3DTSS_TEXTURETRANSFORMFLAGS );
1265     D3DSTATE_TO_STR(WINED3DTSS_COLORARG0             );
1266     D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG0             );
1267     D3DSTATE_TO_STR(WINED3DTSS_RESULTARG             );
1268     D3DSTATE_TO_STR(WINED3DTSS_CONSTANT              );
1269 #undef D3DSTATE_TO_STR
1270   default:
1271     FIXME("Unrecognized %u texture state!\n", state);
1272     return "unrecognized";
1273   }
1274 }
1275
1276 const char* debug_d3dtop(WINED3DTEXTUREOP d3dtop) {
1277     switch (d3dtop) {
1278 #define D3DTOP_TO_STR(u) case u: return #u
1279         D3DTOP_TO_STR(WINED3DTOP_DISABLE);
1280         D3DTOP_TO_STR(WINED3DTOP_SELECTARG1);
1281         D3DTOP_TO_STR(WINED3DTOP_SELECTARG2);
1282         D3DTOP_TO_STR(WINED3DTOP_MODULATE);
1283         D3DTOP_TO_STR(WINED3DTOP_MODULATE2X);
1284         D3DTOP_TO_STR(WINED3DTOP_MODULATE4X);
1285         D3DTOP_TO_STR(WINED3DTOP_ADD);
1286         D3DTOP_TO_STR(WINED3DTOP_ADDSIGNED);
1287         D3DTOP_TO_STR(WINED3DTOP_ADDSIGNED2X);
1288         D3DTOP_TO_STR(WINED3DTOP_SUBTRACT);
1289         D3DTOP_TO_STR(WINED3DTOP_ADDSMOOTH);
1290         D3DTOP_TO_STR(WINED3DTOP_BLENDDIFFUSEALPHA);
1291         D3DTOP_TO_STR(WINED3DTOP_BLENDTEXTUREALPHA);
1292         D3DTOP_TO_STR(WINED3DTOP_BLENDFACTORALPHA);
1293         D3DTOP_TO_STR(WINED3DTOP_BLENDTEXTUREALPHAPM);
1294         D3DTOP_TO_STR(WINED3DTOP_BLENDCURRENTALPHA);
1295         D3DTOP_TO_STR(WINED3DTOP_PREMODULATE);
1296         D3DTOP_TO_STR(WINED3DTOP_MODULATEALPHA_ADDCOLOR);
1297         D3DTOP_TO_STR(WINED3DTOP_MODULATECOLOR_ADDALPHA);
1298         D3DTOP_TO_STR(WINED3DTOP_MODULATEINVALPHA_ADDCOLOR);
1299         D3DTOP_TO_STR(WINED3DTOP_MODULATEINVCOLOR_ADDALPHA);
1300         D3DTOP_TO_STR(WINED3DTOP_BUMPENVMAP);
1301         D3DTOP_TO_STR(WINED3DTOP_BUMPENVMAPLUMINANCE);
1302         D3DTOP_TO_STR(WINED3DTOP_DOTPRODUCT3);
1303         D3DTOP_TO_STR(WINED3DTOP_MULTIPLYADD);
1304         D3DTOP_TO_STR(WINED3DTOP_LERP);
1305 #undef D3DTOP_TO_STR
1306         default:
1307             FIXME("Unrecognized %u WINED3DTOP\n", d3dtop);
1308             return "unrecognized";
1309     }
1310 }
1311
1312 const char* debug_d3dtstype(WINED3DTRANSFORMSTATETYPE tstype) {
1313     switch (tstype) {
1314 #define TSTYPE_TO_STR(tstype) case tstype: return #tstype
1315     TSTYPE_TO_STR(WINED3DTS_VIEW);
1316     TSTYPE_TO_STR(WINED3DTS_PROJECTION);
1317     TSTYPE_TO_STR(WINED3DTS_TEXTURE0);
1318     TSTYPE_TO_STR(WINED3DTS_TEXTURE1);
1319     TSTYPE_TO_STR(WINED3DTS_TEXTURE2);
1320     TSTYPE_TO_STR(WINED3DTS_TEXTURE3);
1321     TSTYPE_TO_STR(WINED3DTS_TEXTURE4);
1322     TSTYPE_TO_STR(WINED3DTS_TEXTURE5);
1323     TSTYPE_TO_STR(WINED3DTS_TEXTURE6);
1324     TSTYPE_TO_STR(WINED3DTS_TEXTURE7);
1325     TSTYPE_TO_STR(WINED3DTS_WORLDMATRIX(0));
1326 #undef TSTYPE_TO_STR
1327     default:
1328         if (tstype > 256 && tstype < 512) {
1329             FIXME("WINED3DTS_WORLDMATRIX(%u). 1..255 not currently supported\n", tstype);
1330             return ("WINED3DTS_WORLDMATRIX > 0");
1331         }
1332         FIXME("Unrecognized %u WINED3DTS\n", tstype);
1333         return "unrecognized";
1334     }
1335 }
1336
1337 const char* debug_d3dpool(WINED3DPOOL Pool) {
1338   switch (Pool) {
1339 #define POOL_TO_STR(p) case p: return #p
1340     POOL_TO_STR(WINED3DPOOL_DEFAULT);
1341     POOL_TO_STR(WINED3DPOOL_MANAGED);
1342     POOL_TO_STR(WINED3DPOOL_SYSTEMMEM);
1343     POOL_TO_STR(WINED3DPOOL_SCRATCH);
1344 #undef  POOL_TO_STR
1345   default:
1346     FIXME("Unrecognized %u WINED3DPOOL!\n", Pool);
1347     return "unrecognized";
1348   }
1349 }
1350
1351 const char *debug_fbostatus(GLenum status) {
1352     switch(status) {
1353 #define FBOSTATUS_TO_STR(u) case u: return #u
1354         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_COMPLETE_EXT);
1355         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT);
1356         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT);
1357         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT);
1358         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT);
1359         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT);
1360         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT);
1361         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT);
1362         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_UNSUPPORTED_EXT);
1363 #undef FBOSTATUS_TO_STR
1364         default:
1365             FIXME("Unrecognied FBO status 0x%08x\n", status);
1366             return "unrecognized";
1367     }
1368 }
1369
1370 const char *debug_glerror(GLenum error) {
1371     switch(error) {
1372 #define GLERROR_TO_STR(u) case u: return #u
1373         GLERROR_TO_STR(GL_NO_ERROR);
1374         GLERROR_TO_STR(GL_INVALID_ENUM);
1375         GLERROR_TO_STR(GL_INVALID_VALUE);
1376         GLERROR_TO_STR(GL_INVALID_OPERATION);
1377         GLERROR_TO_STR(GL_STACK_OVERFLOW);
1378         GLERROR_TO_STR(GL_STACK_UNDERFLOW);
1379         GLERROR_TO_STR(GL_OUT_OF_MEMORY);
1380         GLERROR_TO_STR(GL_INVALID_FRAMEBUFFER_OPERATION_EXT);
1381 #undef GLERROR_TO_STR
1382         default:
1383             FIXME("Unrecognied GL error 0x%08x\n", error);
1384             return "unrecognized";
1385     }
1386 }
1387
1388 const char *debug_d3dbasis(WINED3DBASISTYPE basis) {
1389     switch(basis) {
1390         case WINED3DBASIS_BEZIER:       return "WINED3DBASIS_BEZIER";
1391         case WINED3DBASIS_BSPLINE:      return "WINED3DBASIS_BSPLINE";
1392         case WINED3DBASIS_INTERPOLATE:  return "WINED3DBASIS_INTERPOLATE";
1393         default:                        return "unrecognized";
1394     }
1395 }
1396
1397 const char *debug_d3ddegree(WINED3DDEGREETYPE degree) {
1398     switch(degree) {
1399         case WINED3DDEGREE_LINEAR:      return "WINED3DDEGREE_LINEAR";
1400         case WINED3DDEGREE_QUADRATIC:   return "WINED3DDEGREE_QUADRATIC";
1401         case WINED3DDEGREE_CUBIC:       return "WINED3DDEGREE_CUBIC";
1402         case WINED3DDEGREE_QUINTIC:     return "WINED3DDEGREE_QUINTIC";
1403         default:                        return "unrecognized";
1404     }
1405 }
1406
1407 static const char *debug_fixup_channel_source(enum fixup_channel_source source)
1408 {
1409     switch(source)
1410     {
1411 #define WINED3D_TO_STR(x) case x: return #x
1412         WINED3D_TO_STR(CHANNEL_SOURCE_ZERO);
1413         WINED3D_TO_STR(CHANNEL_SOURCE_ONE);
1414         WINED3D_TO_STR(CHANNEL_SOURCE_X);
1415         WINED3D_TO_STR(CHANNEL_SOURCE_Y);
1416         WINED3D_TO_STR(CHANNEL_SOURCE_Z);
1417         WINED3D_TO_STR(CHANNEL_SOURCE_W);
1418         WINED3D_TO_STR(CHANNEL_SOURCE_YUV0);
1419         WINED3D_TO_STR(CHANNEL_SOURCE_YUV1);
1420 #undef WINED3D_TO_STR
1421         default:
1422             FIXME("Unrecognized fixup_channel_source %#x\n", source);
1423             return "unrecognized";
1424     }
1425 }
1426
1427 static const char *debug_yuv_fixup(enum yuv_fixup yuv_fixup)
1428 {
1429     switch(yuv_fixup)
1430     {
1431 #define WINED3D_TO_STR(x) case x: return #x
1432         WINED3D_TO_STR(YUV_FIXUP_YUY2);
1433         WINED3D_TO_STR(YUV_FIXUP_UYVY);
1434         WINED3D_TO_STR(YUV_FIXUP_YV12);
1435 #undef WINED3D_TO_STR
1436         default:
1437             FIXME("Unrecognized YUV fixup %#x\n", yuv_fixup);
1438             return "unrecognized";
1439     }
1440 }
1441
1442 void dump_color_fixup_desc(struct color_fixup_desc fixup)
1443 {
1444     if (is_yuv_fixup(fixup))
1445     {
1446         TRACE("\tYUV: %s\n", debug_yuv_fixup(get_yuv_fixup(fixup)));
1447         return;
1448     }
1449
1450     TRACE("\tX: %s%s\n", debug_fixup_channel_source(fixup.x_source), fixup.x_sign_fixup ? ", SIGN_FIXUP" : "");
1451     TRACE("\tY: %s%s\n", debug_fixup_channel_source(fixup.y_source), fixup.y_sign_fixup ? ", SIGN_FIXUP" : "");
1452     TRACE("\tZ: %s%s\n", debug_fixup_channel_source(fixup.z_source), fixup.z_sign_fixup ? ", SIGN_FIXUP" : "");
1453     TRACE("\tW: %s%s\n", debug_fixup_channel_source(fixup.w_source), fixup.w_sign_fixup ? ", SIGN_FIXUP" : "");
1454 }
1455
1456 const char *debug_surflocation(DWORD flag) {
1457     char buf[128];
1458
1459     buf[0] = 0;
1460     if(flag & SFLAG_INSYSMEM) strcat(buf, " | SFLAG_INSYSMEM");
1461     if(flag & SFLAG_INDRAWABLE) strcat(buf, " | SFLAG_INDRAWABLE");
1462     if(flag & SFLAG_INTEXTURE) strcat(buf, " | SFLAG_INTEXTURE");
1463     if(flag & SFLAG_INSRGBTEX) strcat(buf, " | SFLAG_INSRGBTEX");
1464     return wine_dbg_sprintf("%s", buf[0] ? buf + 3 : "0");
1465 }
1466
1467 /*****************************************************************************
1468  * Useful functions mapping GL <-> D3D values
1469  */
1470 GLenum StencilOp(DWORD op) {
1471     switch(op) {
1472     case WINED3DSTENCILOP_KEEP    : return GL_KEEP;
1473     case WINED3DSTENCILOP_ZERO    : return GL_ZERO;
1474     case WINED3DSTENCILOP_REPLACE : return GL_REPLACE;
1475     case WINED3DSTENCILOP_INCRSAT : return GL_INCR;
1476     case WINED3DSTENCILOP_DECRSAT : return GL_DECR;
1477     case WINED3DSTENCILOP_INVERT  : return GL_INVERT;
1478     case WINED3DSTENCILOP_INCR    : return GL_INCR_WRAP_EXT;
1479     case WINED3DSTENCILOP_DECR    : return GL_DECR_WRAP_EXT;
1480     default:
1481         FIXME("Unrecognized stencil op %d\n", op);
1482         return GL_KEEP;
1483     }
1484 }
1485
1486 GLenum CompareFunc(DWORD func) {
1487     switch ((WINED3DCMPFUNC)func) {
1488     case WINED3DCMP_NEVER        : return GL_NEVER;
1489     case WINED3DCMP_LESS         : return GL_LESS;
1490     case WINED3DCMP_EQUAL        : return GL_EQUAL;
1491     case WINED3DCMP_LESSEQUAL    : return GL_LEQUAL;
1492     case WINED3DCMP_GREATER      : return GL_GREATER;
1493     case WINED3DCMP_NOTEQUAL     : return GL_NOTEQUAL;
1494     case WINED3DCMP_GREATEREQUAL : return GL_GEQUAL;
1495     case WINED3DCMP_ALWAYS       : return GL_ALWAYS;
1496     default:
1497         FIXME("Unrecognized WINED3DCMPFUNC value %d\n", func);
1498         return 0;
1499     }
1500 }
1501
1502 BOOL is_invalid_op(IWineD3DDeviceImpl *This, int stage, WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3) {
1503     if (op == WINED3DTOP_DISABLE) return FALSE;
1504     if (This->stateBlock->textures[stage]) return FALSE;
1505
1506     if ((arg1 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
1507             && op != WINED3DTOP_SELECTARG2) return TRUE;
1508     if ((arg2 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
1509             && op != WINED3DTOP_SELECTARG1) return TRUE;
1510     if ((arg3 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
1511             && (op == WINED3DTOP_MULTIPLYADD || op == WINED3DTOP_LERP)) return TRUE;
1512
1513     return FALSE;
1514 }
1515
1516 /* Setup this textures matrix according to the texture flags*/
1517 void set_texture_matrix(const float *smat, DWORD flags, BOOL calculatedCoords, BOOL transformed,
1518         WINED3DFORMAT vtx_fmt, BOOL ffp_proj_control)
1519 {
1520     float mat[16];
1521
1522     glMatrixMode(GL_TEXTURE);
1523     checkGLcall("glMatrixMode(GL_TEXTURE)");
1524
1525     if (flags == WINED3DTTFF_DISABLE || flags == WINED3DTTFF_COUNT1 || transformed) {
1526         glLoadIdentity();
1527         checkGLcall("glLoadIdentity()");
1528         return;
1529     }
1530
1531     if (flags == (WINED3DTTFF_COUNT1|WINED3DTTFF_PROJECTED)) {
1532         ERR("Invalid texture transform flags: WINED3DTTFF_COUNT1|WINED3DTTFF_PROJECTED\n");
1533         return;
1534     }
1535
1536     memcpy(mat, smat, 16 * sizeof(float));
1537
1538     if (flags & WINED3DTTFF_PROJECTED) {
1539         if(!ffp_proj_control) {
1540             switch (flags & ~WINED3DTTFF_PROJECTED) {
1541             case WINED3DTTFF_COUNT2:
1542                 mat[3] = mat[1], mat[7] = mat[5], mat[11] = mat[9], mat[15] = mat[13];
1543                 mat[1] = mat[5] = mat[9] = mat[13] = 0;
1544                 break;
1545             case WINED3DTTFF_COUNT3:
1546                 mat[3] = mat[2], mat[7] = mat[6], mat[11] = mat[10], mat[15] = mat[14];
1547                 mat[2] = mat[6] = mat[10] = mat[14] = 0;
1548                 break;
1549             }
1550         }
1551     } else { /* under directx the R/Z coord can be used for translation, under opengl we use the Q coord instead */
1552         if(!calculatedCoords) {
1553             switch(vtx_fmt)
1554             {
1555                 case WINED3DFMT_R32_FLOAT:
1556                     /* Direct3D passes the default 1.0 in the 2nd coord, while gl passes it in the 4th.
1557                      * swap 2nd and 4th coord. No need to store the value of mat[12] in mat[4] because
1558                      * the input value to the transformation will be 0, so the matrix value is irrelevant
1559                      */
1560                     mat[12] = mat[4];
1561                     mat[13] = mat[5];
1562                     mat[14] = mat[6];
1563                     mat[15] = mat[7];
1564                     break;
1565                 case WINED3DFMT_R32G32_FLOAT:
1566                     /* See above, just 3rd and 4th coord
1567                     */
1568                     mat[12] = mat[8];
1569                     mat[13] = mat[9];
1570                     mat[14] = mat[10];
1571                     mat[15] = mat[11];
1572                     break;
1573                 case WINED3DFMT_R32G32B32_FLOAT: /* Opengl defaults match dx defaults */
1574                 case WINED3DFMT_R32G32B32A32_FLOAT: /* No defaults apply, all app defined */
1575
1576                 /* This is to prevent swapping the matrix lines and put the default 4th coord = 1.0
1577                  * into a bad place. The division elimination below will apply to make sure the
1578                  * 1.0 doesn't do anything bad. The caller will set this value if the stride is 0
1579                  */
1580                 case WINED3DFMT_UNKNOWN: /* No texture coords, 0/0/0/1 defaults are passed */
1581                     break;
1582                 default:
1583                     FIXME("Unexpected fixed function texture coord input\n");
1584             }
1585         }
1586         if(!ffp_proj_control) {
1587             switch (flags & ~WINED3DTTFF_PROJECTED) {
1588                 /* case WINED3DTTFF_COUNT1: Won't ever get here */
1589                 case WINED3DTTFF_COUNT2: mat[2] = mat[6] = mat[10] = mat[14] = 0;
1590                 /* OpenGL divides the first 3 vertex coord by the 4th by default,
1591                 * which is essentially the same as D3DTTFF_PROJECTED. Make sure that
1592                 * the 4th coord evaluates to 1.0 to eliminate that.
1593                 *
1594                 * If the fixed function pipeline is used, the 4th value remains unused,
1595                 * so there is no danger in doing this. With vertex shaders we have a
1596                 * problem. Should an app hit that problem, the code here would have to
1597                 * check for pixel shaders, and the shader has to undo the default gl divide.
1598                 *
1599                 * A more serious problem occurs if the app passes 4 coordinates in, and the
1600                 * 4th is != 1.0(opengl default). This would have to be fixed in drawStridedSlow
1601                 * or a replacement shader
1602                 */
1603                 default: mat[3] = mat[7] = mat[11] = 0; mat[15] = 1;
1604             }
1605         }
1606     }
1607
1608     glLoadMatrixf(mat);
1609     checkGLcall("glLoadMatrixf(mat)");
1610 }
1611 #undef GLINFO_LOCATION
1612
1613 /* This small helper function is used to convert a bitmask into the number of masked bits */
1614 unsigned int count_bits(unsigned int mask)
1615 {
1616     unsigned int count;
1617     for (count = 0; mask; ++count)
1618     {
1619         mask &= mask - 1;
1620     }
1621     return count;
1622 }
1623
1624 /* Helper function for retrieving color info for ChoosePixelFormat and wglChoosePixelFormatARB.
1625  * The later function requires individual color components. */
1626 BOOL getColorBits(const struct GlPixelFormatDesc *format_desc,
1627         short *redSize, short *greenSize, short *blueSize, short *alphaSize, short *totalSize)
1628 {
1629     TRACE("fmt: %s\n", debug_d3dformat(format_desc->format));
1630     switch(format_desc->format)
1631     {
1632         case WINED3DFMT_X8R8G8B8:
1633         case WINED3DFMT_R8G8B8:
1634         case WINED3DFMT_A8R8G8B8:
1635         case WINED3DFMT_R8G8B8A8_UNORM:
1636         case WINED3DFMT_A2R10G10B10:
1637         case WINED3DFMT_X1R5G5B5:
1638         case WINED3DFMT_A1R5G5B5:
1639         case WINED3DFMT_R5G6B5:
1640         case WINED3DFMT_X4R4G4B4:
1641         case WINED3DFMT_A4R4G4B4:
1642         case WINED3DFMT_R3G3B2:
1643         case WINED3DFMT_A8P8:
1644         case WINED3DFMT_P8:
1645             break;
1646         default:
1647             ERR("Unsupported format: %s\n", debug_d3dformat(format_desc->format));
1648             return FALSE;
1649     }
1650
1651     *redSize = count_bits(format_desc->red_mask);
1652     *greenSize = count_bits(format_desc->green_mask);
1653     *blueSize = count_bits(format_desc->blue_mask);
1654     *alphaSize = count_bits(format_desc->alpha_mask);
1655     *totalSize = *redSize + *greenSize + *blueSize + *alphaSize;
1656
1657     TRACE("Returning red:  %d, green: %d, blue: %d, alpha: %d, total: %d for fmt=%s\n",
1658             *redSize, *greenSize, *blueSize, *alphaSize, *totalSize, debug_d3dformat(format_desc->format));
1659     return TRUE;
1660 }
1661
1662 /* Helper function for retrieving depth/stencil info for ChoosePixelFormat and wglChoosePixelFormatARB */
1663 BOOL getDepthStencilBits(const struct GlPixelFormatDesc *format_desc, short *depthSize, short *stencilSize)
1664 {
1665     TRACE("fmt: %s\n", debug_d3dformat(format_desc->format));
1666     switch(format_desc->format)
1667     {
1668         case WINED3DFMT_D16_LOCKABLE:
1669         case WINED3DFMT_D16_UNORM:
1670         case WINED3DFMT_D15S1:
1671         case WINED3DFMT_D24X8:
1672         case WINED3DFMT_D24X4S4:
1673         case WINED3DFMT_D24S8:
1674         case WINED3DFMT_D24FS8:
1675         case WINED3DFMT_D32:
1676         case WINED3DFMT_D32F_LOCKABLE:
1677             break;
1678         default:
1679             FIXME("Unsupported stencil format: %s\n", debug_d3dformat(format_desc->format));
1680             return FALSE;
1681     }
1682
1683     *depthSize = format_desc->depth_size;
1684     *stencilSize = format_desc->stencil_size;
1685
1686     TRACE("Returning depthSize: %d and stencilSize: %d for fmt=%s\n",
1687             *depthSize, *stencilSize, debug_d3dformat(format_desc->format));
1688     return TRUE;
1689 }
1690
1691 /* DirectDraw stuff */
1692 WINED3DFORMAT pixelformat_for_depth(DWORD depth) {
1693     switch(depth) {
1694         case 8:  return WINED3DFMT_P8;
1695         case 15: return WINED3DFMT_X1R5G5B5;
1696         case 16: return WINED3DFMT_R5G6B5;
1697         case 24: return WINED3DFMT_X8R8G8B8; /* Robots needs 24bit to be X8R8G8B8 */
1698         case 32: return WINED3DFMT_X8R8G8B8; /* EVE online and the Fur demo need 32bit AdapterDisplayMode to return X8R8G8B8 */
1699         default: return WINED3DFMT_UNKNOWN;
1700     }
1701 }
1702
1703 void multiply_matrix(WINED3DMATRIX *dest, const WINED3DMATRIX *src1, const WINED3DMATRIX *src2) {
1704     WINED3DMATRIX temp;
1705
1706     /* Now do the multiplication 'by hand'.
1707        I know that all this could be optimised, but this will be done later :-) */
1708     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);
1709     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);
1710     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);
1711     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);
1712
1713     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);
1714     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);
1715     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);
1716     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);
1717
1718     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);
1719     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);
1720     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);
1721     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);
1722
1723     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);
1724     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);
1725     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);
1726     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);
1727
1728     /* And copy the new matrix in the good storage.. */
1729     memcpy(dest, &temp, 16 * sizeof(float));
1730 }
1731
1732 DWORD get_flexible_vertex_size(DWORD d3dvtVertexType) {
1733     DWORD size = 0;
1734     int i;
1735     int numTextures = (d3dvtVertexType & WINED3DFVF_TEXCOUNT_MASK) >> WINED3DFVF_TEXCOUNT_SHIFT;
1736
1737     if (d3dvtVertexType & WINED3DFVF_NORMAL) size += 3 * sizeof(float);
1738     if (d3dvtVertexType & WINED3DFVF_DIFFUSE) size += sizeof(DWORD);
1739     if (d3dvtVertexType & WINED3DFVF_SPECULAR) size += sizeof(DWORD);
1740     if (d3dvtVertexType & WINED3DFVF_PSIZE) size += sizeof(DWORD);
1741     switch (d3dvtVertexType & WINED3DFVF_POSITION_MASK) {
1742         case WINED3DFVF_XYZ:    size += 3 * sizeof(float); break;
1743         case WINED3DFVF_XYZRHW: size += 4 * sizeof(float); break;
1744         case WINED3DFVF_XYZB1:  size += 4 * sizeof(float); break;
1745         case WINED3DFVF_XYZB2:  size += 5 * sizeof(float); break;
1746         case WINED3DFVF_XYZB3:  size += 6 * sizeof(float); break;
1747         case WINED3DFVF_XYZB4:  size += 7 * sizeof(float); break;
1748         case WINED3DFVF_XYZB5:  size += 8 * sizeof(float); break;
1749         case WINED3DFVF_XYZW:   size += 4 * sizeof(float); break;
1750         default: ERR("Unexpected position mask\n");
1751     }
1752     for (i = 0; i < numTextures; i++) {
1753         size += GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType, i) * sizeof(float);
1754     }
1755
1756     return size;
1757 }
1758
1759 /***********************************************************************
1760  * CalculateTexRect
1761  *
1762  * Calculates the dimensions of the opengl texture used for blits.
1763  * Handled oversized opengl textures and updates the source rectangle
1764  * accordingly
1765  *
1766  * Params:
1767  *  This: Surface to operate on
1768  *  Rect: Requested rectangle
1769  *
1770  * Returns:
1771  *  TRUE if the texture part can be loaded,
1772  *  FALSE otherwise
1773  *
1774  *********************************************************************/
1775 #define GLINFO_LOCATION This->resource.wineD3DDevice->adapter->gl_info
1776
1777 BOOL CalculateTexRect(IWineD3DSurfaceImpl *This, RECT *Rect, float glTexCoord[4]) {
1778     int x1 = Rect->left, x2 = Rect->right;
1779     int y1 = Rect->top, y2 = Rect->bottom;
1780     GLint maxSize = GL_LIMITS(texture_size);
1781
1782     TRACE("(%p)->(%d,%d)-(%d,%d)\n", This,
1783           Rect->left, Rect->top, Rect->right, Rect->bottom);
1784
1785     /* The sizes might be reversed */
1786     if(Rect->left > Rect->right) {
1787         x1 = Rect->right;
1788         x2 = Rect->left;
1789     }
1790     if(Rect->top > Rect->bottom) {
1791         y1 = Rect->bottom;
1792         y2 = Rect->top;
1793     }
1794
1795     /* No oversized texture? This is easy */
1796     if(!(This->Flags & SFLAG_OVERSIZE)) {
1797         /* Which rect from the texture do I need? */
1798         if(This->glDescription.target == GL_TEXTURE_RECTANGLE_ARB) {
1799             glTexCoord[0] = (float) Rect->left;
1800             glTexCoord[2] = (float) Rect->top;
1801             glTexCoord[1] = (float) Rect->right;
1802             glTexCoord[3] = (float) Rect->bottom;
1803         } else {
1804             glTexCoord[0] = (float) Rect->left / (float) This->pow2Width;
1805             glTexCoord[2] = (float) Rect->top / (float) This->pow2Height;
1806             glTexCoord[1] = (float) Rect->right / (float) This->pow2Width;
1807             glTexCoord[3] = (float) Rect->bottom / (float) This->pow2Height;
1808         }
1809
1810         return TRUE;
1811     } else {
1812         /* Check if we can succeed at all */
1813         if( (x2 - x1) > maxSize ||
1814             (y2 - y1) > maxSize ) {
1815             TRACE("Requested rectangle is too large for gl\n");
1816             return FALSE;
1817         }
1818
1819         /* A part of the texture has to be picked. First, check if
1820          * some texture part is loaded already, if yes try to re-use it.
1821          * If the texture is dirty, or the part can't be used,
1822          * re-position the part to load
1823          */
1824         if(This->Flags & SFLAG_INTEXTURE) {
1825             if(This->glRect.left <= x1 && This->glRect.right >= x2 &&
1826                This->glRect.top <= y1 && This->glRect.bottom >= x2 ) {
1827                 /* Ok, the rectangle is ok, re-use it */
1828                 TRACE("Using existing gl Texture\n");
1829             } else {
1830                 /* Rectangle is not ok, dirtify the texture to reload it */
1831                 TRACE("Dirtifying texture to force reload\n");
1832                 This->Flags &= ~SFLAG_INTEXTURE;
1833             }
1834         }
1835
1836         /* Now if we are dirty(no else if!) */
1837         if(!(This->Flags & SFLAG_INTEXTURE)) {
1838             /* Set the new rectangle. Use the following strategy:
1839              * 1) Use as big textures as possible.
1840              * 2) Place the texture part in the way that the requested
1841              *    part is in the middle of the texture(well, almost)
1842              * 3) If the texture is moved over the edges of the
1843              *    surface, replace it nicely
1844              * 4) If the coord is not limiting the texture size,
1845              *    use the whole size
1846              */
1847             if((This->pow2Width) > maxSize) {
1848                 This->glRect.left = x1 - maxSize / 2;
1849                 if(This->glRect.left < 0) {
1850                     This->glRect.left = 0;
1851                 }
1852                 This->glRect.right = This->glRect.left + maxSize;
1853                 if(This->glRect.right > This->currentDesc.Width) {
1854                     This->glRect.right = This->currentDesc.Width;
1855                     This->glRect.left = This->glRect.right - maxSize;
1856                 }
1857             } else {
1858                 This->glRect.left = 0;
1859                 This->glRect.right = This->pow2Width;
1860             }
1861
1862             if(This->pow2Height > maxSize) {
1863                 This->glRect.top = x1 - GL_LIMITS(texture_size) / 2;
1864                 if(This->glRect.top < 0) This->glRect.top = 0;
1865                 This->glRect.bottom = This->glRect.left + maxSize;
1866                 if(This->glRect.bottom > This->currentDesc.Height) {
1867                     This->glRect.bottom = This->currentDesc.Height;
1868                     This->glRect.top = This->glRect.bottom - maxSize;
1869                 }
1870             } else {
1871                 This->glRect.top = 0;
1872                 This->glRect.bottom = This->pow2Height;
1873             }
1874             TRACE("(%p): Using rect (%d,%d)-(%d,%d)\n", This,
1875                    This->glRect.left, This->glRect.top, This->glRect.right, This->glRect.bottom);
1876         }
1877
1878         /* Re-calculate the rect to draw */
1879         Rect->left -= This->glRect.left;
1880         Rect->right -= This->glRect.left;
1881         Rect->top -= This->glRect.top;
1882         Rect->bottom -= This->glRect.top;
1883
1884         /* Get the gl coordinates. The gl rectangle is a power of 2, eigher the max size,
1885          * or the pow2Width / pow2Height of the surface.
1886          *
1887          * Can never be GL_TEXTURE_RECTANGLE_ARB because oversized surfaces are always set up
1888          * as regular GL_TEXTURE_2D.
1889          */
1890         glTexCoord[0] = (float) Rect->left / (float) (This->glRect.right - This->glRect.left);
1891         glTexCoord[2] = (float) Rect->top / (float) (This->glRect.bottom - This->glRect.top);
1892         glTexCoord[1] = (float) Rect->right / (float) (This->glRect.right - This->glRect.left);
1893         glTexCoord[3] = (float) Rect->bottom / (float) (This->glRect.bottom - This->glRect.top);
1894     }
1895     return TRUE;
1896 }
1897 #undef GLINFO_LOCATION
1898
1899 /* Hash table functions */
1900
1901 struct hash_table_t *hash_table_create(hash_function_t *hash_function, compare_function_t *compare_function)
1902 {
1903     struct hash_table_t *table;
1904     unsigned int initial_size = 8;
1905
1906     table = HeapAlloc(GetProcessHeap(), 0, sizeof(struct hash_table_t) + (initial_size * sizeof(struct list)));
1907     if (!table)
1908     {
1909         ERR("Failed to allocate table, returning NULL.\n");
1910         return NULL;
1911     }
1912
1913     table->hash_function = hash_function;
1914     table->compare_function = compare_function;
1915
1916     table->grow_size = initial_size - (initial_size >> 2);
1917     table->shrink_size = 0;
1918
1919     table->buckets = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, initial_size * sizeof(struct list));
1920     if (!table->buckets)
1921     {
1922         ERR("Failed to allocate table buckets, returning NULL.\n");
1923         HeapFree(GetProcessHeap(), 0, table);
1924         return NULL;
1925     }
1926     table->bucket_count = initial_size;
1927
1928     table->entries = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, table->grow_size * sizeof(struct hash_table_entry_t));
1929     if (!table->entries)
1930     {
1931         ERR("Failed to allocate table entries, returning NULL.\n");
1932         HeapFree(GetProcessHeap(), 0, table->buckets);
1933         HeapFree(GetProcessHeap(), 0, table);
1934         return NULL;
1935     }
1936     table->entry_count = 0;
1937
1938     list_init(&table->free_entries);
1939     table->count = 0;
1940
1941     return table;
1942 }
1943
1944 void hash_table_destroy(struct hash_table_t *table, void (*free_value)(void *value, void *cb), void *cb)
1945 {
1946     unsigned int i = 0;
1947
1948     for (i = 0; i < table->entry_count; ++i)
1949     {
1950         if(free_value) {
1951             free_value(table->entries[i].value, cb);
1952         }
1953         HeapFree(GetProcessHeap(), 0, table->entries[i].key);
1954     }
1955
1956     HeapFree(GetProcessHeap(), 0, table->entries);
1957     HeapFree(GetProcessHeap(), 0, table->buckets);
1958     HeapFree(GetProcessHeap(), 0, table);
1959 }
1960
1961 void hash_table_for_each_entry(struct hash_table_t *table, void (*callback)(void *value, void *context), void *context)
1962 {
1963     unsigned int i = 0;
1964
1965     for (i = 0; i < table->entry_count; ++i)
1966     {
1967         callback(table->entries[i].value, context);
1968     }
1969 }
1970
1971 static inline struct hash_table_entry_t *hash_table_get_by_idx(const struct hash_table_t *table, const void *key,
1972         unsigned int idx)
1973 {
1974     struct hash_table_entry_t *entry;
1975
1976     if (table->buckets[idx].next)
1977         LIST_FOR_EACH_ENTRY(entry, &(table->buckets[idx]), struct hash_table_entry_t, entry)
1978             if (table->compare_function(entry->key, key)) return entry;
1979
1980     return NULL;
1981 }
1982
1983 static BOOL hash_table_resize(struct hash_table_t *table, unsigned int new_bucket_count)
1984 {
1985     unsigned int new_entry_count = 0;
1986     struct hash_table_entry_t *new_entries;
1987     struct list *new_buckets;
1988     unsigned int grow_size = new_bucket_count - (new_bucket_count >> 2);
1989     unsigned int i;
1990
1991     new_buckets = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, new_bucket_count * sizeof(struct list));
1992     if (!new_buckets)
1993     {
1994         ERR("Failed to allocate new buckets, returning FALSE.\n");
1995         return FALSE;
1996     }
1997
1998     new_entries = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, grow_size * sizeof(struct hash_table_entry_t));
1999     if (!new_entries)
2000     {
2001         ERR("Failed to allocate new entries, returning FALSE.\n");
2002         HeapFree(GetProcessHeap(), 0, new_buckets);
2003         return FALSE;
2004     }
2005
2006     for (i = 0; i < table->bucket_count; ++i)
2007     {
2008         if (table->buckets[i].next)
2009         {
2010             struct hash_table_entry_t *entry, *entry2;
2011
2012             LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &table->buckets[i], struct hash_table_entry_t, entry)
2013             {
2014                 int j;
2015                 struct hash_table_entry_t *new_entry = new_entries + (new_entry_count++);
2016                 *new_entry = *entry;
2017
2018                 j = new_entry->hash & (new_bucket_count - 1);
2019
2020                 if (!new_buckets[j].next) list_init(&new_buckets[j]);
2021                 list_add_head(&new_buckets[j], &new_entry->entry);
2022             }
2023         }
2024     }
2025
2026     HeapFree(GetProcessHeap(), 0, table->buckets);
2027     table->buckets = new_buckets;
2028
2029     HeapFree(GetProcessHeap(), 0, table->entries);
2030     table->entries = new_entries;
2031
2032     table->entry_count = new_entry_count;
2033     list_init(&table->free_entries);
2034
2035     table->bucket_count = new_bucket_count;
2036     table->grow_size = grow_size;
2037     table->shrink_size = new_bucket_count > 8 ? new_bucket_count >> 2 : 0;
2038
2039     return TRUE;
2040 }
2041
2042 void hash_table_put(struct hash_table_t *table, void *key, void *value)
2043 {
2044     unsigned int idx;
2045     unsigned int hash;
2046     struct hash_table_entry_t *entry;
2047
2048     hash = table->hash_function(key);
2049     idx = hash & (table->bucket_count - 1);
2050     entry = hash_table_get_by_idx(table, key, idx);
2051
2052     if (entry)
2053     {
2054         HeapFree(GetProcessHeap(), 0, key);
2055         entry->value = value;
2056
2057         if (!value)
2058         {
2059             HeapFree(GetProcessHeap(), 0, entry->key);
2060             entry->key = NULL;
2061
2062             /* Remove the entry */
2063             list_remove(&entry->entry);
2064             list_add_head(&table->free_entries, &entry->entry);
2065
2066             --table->count;
2067
2068             /* Shrink if necessary */
2069             if (table->count < table->shrink_size) {
2070                 if (!hash_table_resize(table, table->bucket_count >> 1))
2071                 {
2072                     ERR("Failed to shrink the table...\n");
2073                 }
2074             }
2075         }
2076
2077         return;
2078     }
2079
2080     if (!value) return;
2081
2082     /* Grow if necessary */
2083     if (table->count >= table->grow_size)
2084     {
2085         if (!hash_table_resize(table, table->bucket_count << 1))
2086         {
2087             ERR("Failed to grow the table, returning.\n");
2088             return;
2089         }
2090
2091         idx = hash & (table->bucket_count - 1);
2092     }
2093
2094     /* Find an entry to insert */
2095     if (!list_empty(&table->free_entries))
2096     {
2097         struct list *elem = list_head(&table->free_entries);
2098
2099         list_remove(elem);
2100         entry = LIST_ENTRY(elem, struct hash_table_entry_t, entry);
2101     } else {
2102         entry = table->entries + (table->entry_count++);
2103     }
2104
2105     /* Insert the entry */
2106     entry->key = key;
2107     entry->value = value;
2108     entry->hash = hash;
2109     if (!table->buckets[idx].next) list_init(&table->buckets[idx]);
2110     list_add_head(&table->buckets[idx], &entry->entry);
2111
2112     ++table->count;
2113 }
2114
2115 void hash_table_remove(struct hash_table_t *table, void *key)
2116 {
2117     hash_table_put(table, key, NULL);
2118 }
2119
2120 void *hash_table_get(const struct hash_table_t *table, const void *key)
2121 {
2122     unsigned int idx;
2123     struct hash_table_entry_t *entry;
2124
2125     idx = table->hash_function(key) & (table->bucket_count - 1);
2126     entry = hash_table_get_by_idx(table, key, idx);
2127
2128     return entry ? entry->value : NULL;
2129 }
2130
2131 #define GLINFO_LOCATION stateblock->wineD3DDevice->adapter->gl_info
2132 void gen_ffp_frag_op(IWineD3DStateBlockImpl *stateblock, struct ffp_frag_settings *settings, BOOL ignore_textype) {
2133 #define ARG1 0x01
2134 #define ARG2 0x02
2135 #define ARG0 0x04
2136     static const unsigned char args[WINED3DTOP_LERP + 1] = {
2137         /* undefined                        */  0,
2138         /* D3DTOP_DISABLE                   */  0,
2139         /* D3DTOP_SELECTARG1                */  ARG1,
2140         /* D3DTOP_SELECTARG2                */  ARG2,
2141         /* D3DTOP_MODULATE                  */  ARG1 | ARG2,
2142         /* D3DTOP_MODULATE2X                */  ARG1 | ARG2,
2143         /* D3DTOP_MODULATE4X                */  ARG1 | ARG2,
2144         /* D3DTOP_ADD                       */  ARG1 | ARG2,
2145         /* D3DTOP_ADDSIGNED                 */  ARG1 | ARG2,
2146         /* D3DTOP_ADDSIGNED2X               */  ARG1 | ARG2,
2147         /* D3DTOP_SUBTRACT                  */  ARG1 | ARG2,
2148         /* D3DTOP_ADDSMOOTH                 */  ARG1 | ARG2,
2149         /* D3DTOP_BLENDDIFFUSEALPHA         */  ARG1 | ARG2,
2150         /* D3DTOP_BLENDTEXTUREALPHA         */  ARG1 | ARG2,
2151         /* D3DTOP_BLENDFACTORALPHA          */  ARG1 | ARG2,
2152         /* D3DTOP_BLENDTEXTUREALPHAPM       */  ARG1 | ARG2,
2153         /* D3DTOP_BLENDCURRENTALPHA         */  ARG1 | ARG2,
2154         /* D3DTOP_PREMODULATE               */  ARG1 | ARG2,
2155         /* D3DTOP_MODULATEALPHA_ADDCOLOR    */  ARG1 | ARG2,
2156         /* D3DTOP_MODULATECOLOR_ADDALPHA    */  ARG1 | ARG2,
2157         /* D3DTOP_MODULATEINVALPHA_ADDCOLOR */  ARG1 | ARG2,
2158         /* D3DTOP_MODULATEINVCOLOR_ADDALPHA */  ARG1 | ARG2,
2159         /* D3DTOP_BUMPENVMAP                */  ARG1 | ARG2,
2160         /* D3DTOP_BUMPENVMAPLUMINANCE       */  ARG1 | ARG2,
2161         /* D3DTOP_DOTPRODUCT3               */  ARG1 | ARG2,
2162         /* D3DTOP_MULTIPLYADD               */  ARG1 | ARG2 | ARG0,
2163         /* D3DTOP_LERP                      */  ARG1 | ARG2 | ARG0
2164     };
2165     unsigned int i;
2166     DWORD ttff;
2167     DWORD cop, aop, carg0, carg1, carg2, aarg0, aarg1, aarg2;
2168
2169     for(i = 0; i < GL_LIMITS(texture_stages); i++) {
2170         IWineD3DBaseTextureImpl *texture;
2171         settings->op[i].padding = 0;
2172         if(stateblock->textureState[i][WINED3DTSS_COLOROP] == WINED3DTOP_DISABLE) {
2173             settings->op[i].cop = WINED3DTOP_DISABLE;
2174             settings->op[i].aop = WINED3DTOP_DISABLE;
2175             settings->op[i].carg0 = settings->op[i].carg1 = settings->op[i].carg2 = ARG_UNUSED;
2176             settings->op[i].aarg0 = settings->op[i].aarg1 = settings->op[i].aarg2 = ARG_UNUSED;
2177             settings->op[i].color_fixup = COLOR_FIXUP_IDENTITY;
2178             settings->op[i].dst = resultreg;
2179             settings->op[i].tex_type = tex_1d;
2180             settings->op[i].projected = proj_none;
2181             i++;
2182             break;
2183         }
2184
2185         texture = (IWineD3DBaseTextureImpl *) stateblock->textures[i];
2186         if(texture) {
2187             settings->op[i].color_fixup = texture->resource.format_desc->color_fixup;
2188             if(ignore_textype) {
2189                 settings->op[i].tex_type = tex_1d;
2190             } else {
2191                 switch (IWineD3DBaseTexture_GetTextureDimensions((IWineD3DBaseTexture *)texture)) {
2192                     case GL_TEXTURE_1D:
2193                         settings->op[i].tex_type = tex_1d;
2194                         break;
2195                     case GL_TEXTURE_2D:
2196                         settings->op[i].tex_type = tex_2d;
2197                         break;
2198                     case GL_TEXTURE_3D:
2199                         settings->op[i].tex_type = tex_3d;
2200                         break;
2201                     case GL_TEXTURE_CUBE_MAP_ARB:
2202                         settings->op[i].tex_type = tex_cube;
2203                         break;
2204                     case GL_TEXTURE_RECTANGLE_ARB:
2205                         settings->op[i].tex_type = tex_rect;
2206                         break;
2207                 }
2208             }
2209         } else {
2210             settings->op[i].color_fixup = COLOR_FIXUP_IDENTITY;
2211             settings->op[i].tex_type = tex_1d;
2212         }
2213
2214         cop = stateblock->textureState[i][WINED3DTSS_COLOROP];
2215         aop = stateblock->textureState[i][WINED3DTSS_ALPHAOP];
2216
2217         carg1 = (args[cop] & ARG1) ? stateblock->textureState[i][WINED3DTSS_COLORARG1] : ARG_UNUSED;
2218         carg2 = (args[cop] & ARG2) ? stateblock->textureState[i][WINED3DTSS_COLORARG2] : ARG_UNUSED;
2219         carg0 = (args[cop] & ARG0) ? stateblock->textureState[i][WINED3DTSS_COLORARG0] : ARG_UNUSED;
2220
2221         if(is_invalid_op(stateblock->wineD3DDevice, i, cop,
2222                          carg1, carg2, carg0)) {
2223             carg0 = ARG_UNUSED;
2224             carg2 = ARG_UNUSED;
2225             carg1 = WINED3DTA_CURRENT;
2226             cop = WINED3DTOP_SELECTARG1;
2227         }
2228
2229         if(cop == WINED3DTOP_DOTPRODUCT3) {
2230             /* A dotproduct3 on the colorop overwrites the alphaop operation and replicates
2231              * the color result to the alpha component of the destination
2232              */
2233             aop = cop;
2234             aarg1 = carg1;
2235             aarg2 = carg2;
2236             aarg0 = carg0;
2237         } else {
2238             aarg1 = (args[aop] & ARG1) ? stateblock->textureState[i][WINED3DTSS_ALPHAARG1] : ARG_UNUSED;
2239             aarg2 = (args[aop] & ARG2) ? stateblock->textureState[i][WINED3DTSS_ALPHAARG2] : ARG_UNUSED;
2240             aarg0 = (args[aop] & ARG0) ? stateblock->textureState[i][WINED3DTSS_ALPHAARG0] : ARG_UNUSED;
2241         }
2242
2243         if (i == 0 && stateblock->textures[0] && stateblock->renderState[WINED3DRS_COLORKEYENABLE])
2244         {
2245             UINT texture_dimensions = IWineD3DBaseTexture_GetTextureDimensions(stateblock->textures[0]);
2246
2247             if (texture_dimensions == GL_TEXTURE_2D || texture_dimensions == GL_TEXTURE_RECTANGLE_ARB)
2248             {
2249                 IWineD3DSurfaceImpl *surf;
2250                 surf = (IWineD3DSurfaceImpl *) ((IWineD3DTextureImpl *) stateblock->textures[0])->surfaces[0];
2251
2252                 if (surf->CKeyFlags & WINEDDSD_CKSRCBLT && !surf->resource.format_desc->alpha_mask)
2253                 {
2254                     if (aop == WINED3DTOP_DISABLE)
2255                     {
2256                        aarg1 = WINED3DTA_TEXTURE;
2257                        aop = WINED3DTOP_SELECTARG1;
2258                     }
2259                     else if (aop == WINED3DTOP_SELECTARG1 && aarg1 != WINED3DTA_TEXTURE)
2260                     {
2261                         if (stateblock->renderState[WINED3DRS_ALPHABLENDENABLE])
2262                         {
2263                             aarg2 = WINED3DTA_TEXTURE;
2264                             aop = WINED3DTOP_MODULATE;
2265                         }
2266                         else aarg1 = WINED3DTA_TEXTURE;
2267                     }
2268                     else if (aop == WINED3DTOP_SELECTARG2 && aarg2 != WINED3DTA_TEXTURE)
2269                     {
2270                         if (stateblock->renderState[WINED3DRS_ALPHABLENDENABLE])
2271                         {
2272                             aarg1 = WINED3DTA_TEXTURE;
2273                             aop = WINED3DTOP_MODULATE;
2274                         }
2275                         else aarg2 = WINED3DTA_TEXTURE;
2276                     }
2277                 }
2278             }
2279         }
2280
2281         if(is_invalid_op(stateblock->wineD3DDevice, i, aop,
2282            aarg1, aarg2, aarg0)) {
2283                aarg0 = ARG_UNUSED;
2284                aarg2 = ARG_UNUSED;
2285                aarg1 = WINED3DTA_CURRENT;
2286                aop = WINED3DTOP_SELECTARG1;
2287         }
2288
2289         if(carg1 == WINED3DTA_TEXTURE || carg2 == WINED3DTA_TEXTURE || carg0 == WINED3DTA_TEXTURE ||
2290            aarg1 == WINED3DTA_TEXTURE || aarg2 == WINED3DTA_TEXTURE || aarg0 == WINED3DTA_TEXTURE) {
2291             ttff = stateblock->textureState[i][WINED3DTSS_TEXTURETRANSFORMFLAGS];
2292             if(ttff == (WINED3DTTFF_PROJECTED | WINED3DTTFF_COUNT3)) {
2293                 settings->op[i].projected = proj_count3;
2294             } else if(ttff == (WINED3DTTFF_PROJECTED | WINED3DTTFF_COUNT4)) {
2295                 settings->op[i].projected = proj_count4;
2296             } else {
2297                 settings->op[i].projected = proj_none;
2298             }
2299         } else {
2300             settings->op[i].projected = proj_none;
2301         }
2302
2303         settings->op[i].cop = cop;
2304         settings->op[i].aop = aop;
2305         settings->op[i].carg0 = carg0;
2306         settings->op[i].carg1 = carg1;
2307         settings->op[i].carg2 = carg2;
2308         settings->op[i].aarg0 = aarg0;
2309         settings->op[i].aarg1 = aarg1;
2310         settings->op[i].aarg2 = aarg2;
2311
2312         if(stateblock->textureState[i][WINED3DTSS_RESULTARG] == WINED3DTA_TEMP) {
2313             settings->op[i].dst = tempreg;
2314         } else {
2315             settings->op[i].dst = resultreg;
2316         }
2317     }
2318
2319     /* Clear unsupported stages */
2320     for(; i < MAX_TEXTURES; i++) {
2321         memset(&settings->op[i], 0xff, sizeof(settings->op[i]));
2322     }
2323
2324     if(stateblock->renderState[WINED3DRS_FOGENABLE] == FALSE) {
2325         settings->fog = FOG_OFF;
2326     } else if(stateblock->renderState[WINED3DRS_FOGTABLEMODE] == WINED3DFOG_NONE) {
2327         if(use_vs(stateblock) || ((IWineD3DVertexDeclarationImpl *) stateblock->vertexDecl)->position_transformed) {
2328             settings->fog = FOG_LINEAR;
2329         } else {
2330             switch(stateblock->renderState[WINED3DRS_FOGVERTEXMODE]) {
2331                 case WINED3DFOG_NONE:
2332                 case WINED3DFOG_LINEAR:
2333                     settings->fog = FOG_LINEAR;
2334                     break;
2335                 case WINED3DFOG_EXP:
2336                     settings->fog = FOG_EXP;
2337                     break;
2338                 case WINED3DFOG_EXP2:
2339                     settings->fog = FOG_EXP2;
2340                     break;
2341             }
2342         }
2343     } else {
2344         switch(stateblock->renderState[WINED3DRS_FOGTABLEMODE]) {
2345             case WINED3DFOG_LINEAR:
2346                 settings->fog = FOG_LINEAR;
2347                 break;
2348             case WINED3DFOG_EXP:
2349                 settings->fog = FOG_EXP;
2350                 break;
2351             case WINED3DFOG_EXP2:
2352                 settings->fog = FOG_EXP2;
2353                 break;
2354         }
2355     }
2356     if(stateblock->renderState[WINED3DRS_SRGBWRITEENABLE]) {
2357         settings->sRGB_write = 1;
2358     } else {
2359         settings->sRGB_write = 0;
2360     }
2361 }
2362 #undef GLINFO_LOCATION
2363
2364 const struct ffp_frag_desc *find_ffp_frag_shader(const struct hash_table_t *fragment_shaders,
2365         const struct ffp_frag_settings *settings)
2366 {
2367     return hash_table_get(fragment_shaders, settings);
2368 }
2369
2370 void add_ffp_frag_shader(struct hash_table_t *shaders, struct ffp_frag_desc *desc) {
2371     struct ffp_frag_settings *key = HeapAlloc(GetProcessHeap(), 0, sizeof(*key));
2372     /* Note that the key is the implementation independent part of the ffp_frag_desc structure,
2373      * whereas desc points to an extended structure with implementation specific parts.
2374      * Make a copy of the key because hash_table_put takes ownership of it
2375      */
2376     *key = desc->settings;
2377     hash_table_put(shaders, key, desc);
2378 }
2379
2380 /* Activates the texture dimension according to the bound D3D texture.
2381  * Does not care for the colorop or correct gl texture unit(when using nvrc)
2382  * Requires the caller to activate the correct unit before
2383  */
2384 #define GLINFO_LOCATION stateblock->wineD3DDevice->adapter->gl_info
2385 void texture_activate_dimensions(DWORD stage, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2386     if(stateblock->textures[stage]) {
2387         switch (IWineD3DBaseTexture_GetTextureDimensions(stateblock->textures[stage])) {
2388             case GL_TEXTURE_2D:
2389                 glDisable(GL_TEXTURE_3D);
2390                 checkGLcall("glDisable(GL_TEXTURE_3D)");
2391                 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
2392                     glDisable(GL_TEXTURE_CUBE_MAP_ARB);
2393                     checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
2394                 }
2395                 if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE)) {
2396                     glDisable(GL_TEXTURE_RECTANGLE_ARB);
2397                     checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
2398                 }
2399                 glEnable(GL_TEXTURE_2D);
2400                 checkGLcall("glEnable(GL_TEXTURE_2D)");
2401                 break;
2402             case GL_TEXTURE_RECTANGLE_ARB:
2403                 glDisable(GL_TEXTURE_2D);
2404                 checkGLcall("glDisable(GL_TEXTURE_2D)");
2405                 glDisable(GL_TEXTURE_3D);
2406                 checkGLcall("glDisable(GL_TEXTURE_3D)");
2407                 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
2408                     glDisable(GL_TEXTURE_CUBE_MAP_ARB);
2409                     checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
2410                 }
2411                 glEnable(GL_TEXTURE_RECTANGLE_ARB);
2412                 checkGLcall("glEnable(GL_TEXTURE_RECTANGLE_ARB)");
2413                 break;
2414             case GL_TEXTURE_3D:
2415                 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
2416                     glDisable(GL_TEXTURE_CUBE_MAP_ARB);
2417                     checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
2418                 }
2419                 if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE)) {
2420                     glDisable(GL_TEXTURE_RECTANGLE_ARB);
2421                     checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
2422                 }
2423                 glDisable(GL_TEXTURE_2D);
2424                 checkGLcall("glDisable(GL_TEXTURE_2D)");
2425                 glEnable(GL_TEXTURE_3D);
2426                 checkGLcall("glEnable(GL_TEXTURE_3D)");
2427                 break;
2428             case GL_TEXTURE_CUBE_MAP_ARB:
2429                 glDisable(GL_TEXTURE_2D);
2430                 checkGLcall("glDisable(GL_TEXTURE_2D)");
2431                 glDisable(GL_TEXTURE_3D);
2432                 checkGLcall("glDisable(GL_TEXTURE_3D)");
2433                 if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE)) {
2434                     glDisable(GL_TEXTURE_RECTANGLE_ARB);
2435                     checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
2436                 }
2437                 glEnable(GL_TEXTURE_CUBE_MAP_ARB);
2438                 checkGLcall("glEnable(GL_TEXTURE_CUBE_MAP_ARB)");
2439               break;
2440         }
2441     } else {
2442         glEnable(GL_TEXTURE_2D);
2443         checkGLcall("glEnable(GL_TEXTURE_2D)");
2444         glDisable(GL_TEXTURE_3D);
2445         checkGLcall("glDisable(GL_TEXTURE_3D)");
2446         if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
2447             glDisable(GL_TEXTURE_CUBE_MAP_ARB);
2448             checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
2449         }
2450         if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE)) {
2451             glDisable(GL_TEXTURE_RECTANGLE_ARB);
2452             checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
2453         }
2454         /* Binding textures is done by samplers. A dummy texture will be bound */
2455     }
2456 }
2457
2458 void sampler_texdim(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2459     DWORD sampler = state - STATE_SAMPLER(0);
2460     DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[sampler];
2461
2462     /* No need to enable / disable anything here for unused samplers. The tex_colorop
2463     * handler takes care. Also no action is needed with pixel shaders, or if tex_colorop
2464     * will take care of this business
2465     */
2466     if(mapped_stage == WINED3D_UNMAPPED_STAGE || mapped_stage >= GL_LIMITS(textures)) return;
2467     if(sampler >= stateblock->lowest_disabled_stage) return;
2468     if(isStateDirty(context, STATE_TEXTURESTAGE(sampler, WINED3DTSS_COLOROP))) return;
2469
2470     texture_activate_dimensions(sampler, stateblock, context);
2471 }
2472 #undef GLINFO_LOCATION
2473
2474 unsigned int ffp_frag_program_key_hash(const void *key)
2475 {
2476     const struct ffp_frag_settings *k = key;
2477     unsigned int hash = 0, i;
2478     const DWORD *blob;
2479
2480     /* This takes the texture op settings of stage 0 and 1 into account.
2481      * how exactly depends on the memory laybout of the compiler, but it
2482      * should not matter too much. Stages > 1 are used rarely, so there's
2483      * no need to process them. Even if they're used it is likely that
2484      * the ffp setup has distinct stage 0 and 1 settings.
2485      */
2486     for(i = 0; i < 2; i++) {
2487         blob = (const DWORD *)&k->op[i];
2488         hash ^= blob[0] ^ blob[1];
2489     }
2490
2491     hash += ~(hash << 15);
2492     hash ^=  (hash >> 10);
2493     hash +=  (hash << 3);
2494     hash ^=  (hash >> 6);
2495     hash += ~(hash << 11);
2496     hash ^=  (hash >> 16);
2497
2498     return hash;
2499 }
2500
2501 BOOL ffp_frag_program_key_compare(const void *keya, const void *keyb)
2502 {
2503     const struct ffp_frag_settings *ka = keya;
2504     const struct ffp_frag_settings *kb = keyb;
2505
2506     return memcmp(ka, kb, sizeof(*ka)) == 0;
2507 }
2508
2509 UINT wined3d_log2i(UINT32 x)
2510 {
2511     static const BYTE l[] =
2512     {
2513         0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
2514         4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
2515         5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
2516         5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
2517         6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
2518         6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
2519         6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
2520         6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
2521         7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2522         7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2523         7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2524         7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2525         7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2526         7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2527         7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2528         7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2529     };
2530     UINT32 i;
2531
2532     return (i = x >> 16) ? (x = i >> 8) ? l[x] + 24 : l[i] + 16 : (i = x >> 8) ? l[i] + 8 : l[x];
2533 }