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

   1 /*
   2  * Utility functions for the WineD3D Library
   3  *
   4  * Copyright 2002-2004 Jason Edmeades
   5  * Copyright 2003-2004 Raphael Junqueira
   6  * Copyright 2004 Christian Costa
   7  * Copyright 2005 Oliver Stieber
   8  * Copyright 2006-2008 Henri Verbeet
   9  * Copyright 2007-2008 Stefan Dösinger for CodeWeavers
  10  * Copyright 2009-2010 Henri Verbeet for CodeWeavers
  11  *
  12  * This library is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU Lesser General Public
  14  * License as published by the Free Software Foundation; either
  15  * version 2.1 of the License, or (at your option) any later version.
  16  *
  17  * This library is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  * Lesser General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Lesser General Public
  23  * License along with this library; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  25  */
  26
  27 #include "config.h"
  28 #include "wine/port.h"
  29
  30 #include "wined3d_private.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
  33
  34 struct wined3d_format_channels
  35 {
  36     enum wined3d_format_id id;
  37     DWORD red_size, green_size, blue_size, alpha_size;
  38     DWORD red_offset, green_offset, blue_offset, alpha_offset;
  39     UINT bpp;
  40     BYTE depth_size, stencil_size;
  41 };
  42
  43 static const struct wined3d_format_channels formats[] =
  44 {
  45     /*                                          size            offset
  46      *  format id                           r   g   b   a    r   g   b   a    bpp depth stencil */
  47     {WINED3DFMT_UNKNOWN,                    0,  0,  0,  0,   0,  0,  0,  0,    0,   0,     0},
  48     /* FourCC formats */
  49     {WINED3DFMT_UYVY,                       0,  0,  0,  0,   0,  0,  0,  0,    2,   0,     0},
  50     {WINED3DFMT_YUY2,                       0,  0,  0,  0,   0,  0,  0,  0,    2,   0,     0},
  51     {WINED3DFMT_YV12,                       0,  0,  0,  0,   0,  0,  0,  0,    1,   0,     0},
  52     {WINED3DFMT_DXT1,                       0,  0,  0,  0,   0,  0,  0,  0,    1,   0,     0},
  53     {WINED3DFMT_DXT2,                       0,  0,  0,  0,   0,  0,  0,  0,    1,   0,     0},
  54     {WINED3DFMT_DXT3,                       0,  0,  0,  0,   0,  0,  0,  0,    1,   0,     0},
  55     {WINED3DFMT_DXT4,                       0,  0,  0,  0,   0,  0,  0,  0,    1,   0,     0},
  56     {WINED3DFMT_DXT5,                       0,  0,  0,  0,   0,  0,  0,  0,    1,   0,     0},
  57     {WINED3DFMT_MULTI2_ARGB8,               0,  0,  0,  0,   0,  0,  0,  0,    1,   0,     0},
  58     {WINED3DFMT_G8R8_G8B8,                  0,  0,  0,  0,   0,  0,  0,  0,    1,   0,     0},
  59     {WINED3DFMT_R8G8_B8G8,                  0,  0,  0,  0,   0,  0,  0,  0,    1,   0,     0},
  60     /* IEEE formats */
  61     {WINED3DFMT_R32_FLOAT,                 32,  0,  0,  0,   0,  0,  0,  0,    4,   0,     0},
  62     {WINED3DFMT_R32G32_FLOAT,              32, 32,  0,  0,   0, 32,  0,  0,    8,   0,     0},
  63     {WINED3DFMT_R32G32B32_FLOAT,           32, 32, 32,  0,   0, 32, 64,  0,   12,   0,     0},
  64     {WINED3DFMT_R32G32B32A32_FLOAT,        32, 32, 32, 32,   0, 32, 64, 96,   16,   0,     0},
  65     /* Hmm? */
  66     {WINED3DFMT_R8G8_SNORM_Cx,              0,  0,  0,  0,   0,  0,  0,  0,    2,   0,     0},
  67     /* Float */
  68     {WINED3DFMT_R16_FLOAT,                 16,  0,  0,  0,   0,  0,  0,  0,    2,   0,     0},
  69     {WINED3DFMT_R16G16_FLOAT,              16, 16,  0,  0,   0, 16,  0,  0,    4,   0,     0},
  70     {WINED3DFMT_R16G16_SINT,               16, 16,  0,  0,   0, 16,  0,  0,    4,   0,     0},
  71     {WINED3DFMT_R16G16B16A16_FLOAT,        16, 16, 16, 16,   0, 16, 32, 48,    8,   0,     0},
  72     {WINED3DFMT_R16G16B16A16_SINT,         16, 16, 16, 16,   0, 16, 32, 48,    8,   0,     0},
  73     /* Palettized formats */
  74     {WINED3DFMT_P8_UINT_A8_UNORM,           0,  0,  0,  8,   0,  0,  0,  8,    2,   0,     0},
  75     {WINED3DFMT_P8_UINT,                    0,  0,  0,  0,   0,  0,  0,  0,    1,   0,     0},
  76     /* Standard ARGB formats. */
  77     {WINED3DFMT_B8G8R8_UNORM,               8,  8,  8,  0,  16,  8,  0,  0,    3,   0,     0},
  78     {WINED3DFMT_B8G8R8A8_UNORM,             8,  8,  8,  8,  16,  8,  0, 24,    4,   0,     0},
  79     {WINED3DFMT_B8G8R8X8_UNORM,             8,  8,  8,  0,  16,  8,  0,  0,    4,   0,     0},
  80     {WINED3DFMT_B5G6R5_UNORM,               5,  6,  5,  0,  11,  5,  0,  0,    2,   0,     0},
  81     {WINED3DFMT_B5G5R5X1_UNORM,             5,  5,  5,  0,  10,  5,  0,  0,    2,   0,     0},
  82     {WINED3DFMT_B5G5R5A1_UNORM,             5,  5,  5,  1,  10,  5,  0, 15,    2,   0,     0},
  83     {WINED3DFMT_B4G4R4A4_UNORM,             4,  4,  4,  4,   8,  4,  0, 12,    2,   0,     0},
  84     {WINED3DFMT_B2G3R3_UNORM,               3,  3,  2,  0,   5,  2,  0,  0,    1,   0,     0},
  85     {WINED3DFMT_A8_UNORM,                   0,  0,  0,  8,   0,  0,  0,  0,    1,   0,     0},
  86     {WINED3DFMT_B2G3R3A8_UNORM,             3,  3,  2,  8,   5,  2,  0,  8,    2,   0,     0},
  87     {WINED3DFMT_B4G4R4X4_UNORM,             4,  4,  4,  0,   8,  4,  0,  0,    2,   0,     0},
  88     {WINED3DFMT_R10G10B10A2_UNORM,         10, 10, 10,  2,   0, 10, 20, 30,    4,   0,     0},
  89     {WINED3DFMT_R10G10B10A2_UINT,          10, 10, 10,  2,   0, 10, 20, 30,    4,   0,     0},
  90     {WINED3DFMT_R10G10B10A2_SNORM,         10, 10, 10,  2,   0, 10, 20, 30,    4,   0,     0},
  91     {WINED3DFMT_R8G8B8A8_UNORM,             8,  8,  8,  8,   0,  8, 16, 24,    4,   0,     0},
  92     {WINED3DFMT_R8G8B8A8_UINT,              8,  8,  8,  8,   0,  8, 16, 24,    4,   0,     0},
  93     {WINED3DFMT_R8G8B8X8_UNORM,             8,  8,  8,  0,   0,  8, 16,  0,    4,   0,     0},
  94     {WINED3DFMT_R16G16_UNORM,              16, 16,  0,  0,   0, 16,  0,  0,    4,   0,     0},
  95     {WINED3DFMT_B10G10R10A2_UNORM,         10, 10, 10,  2,  20, 10,  0, 30,    4,   0,     0},
  96     {WINED3DFMT_R16G16B16A16_UNORM,        16, 16, 16, 16,   0, 16, 32, 48,    8,   0,     0},
  97     /* Luminance */
  98     {WINED3DFMT_L8_UNORM,                   0,  0,  0,  0,   0,  0,  0,  0,    1,   0,     0},
  99     {WINED3DFMT_L8A8_UNORM,                 0,  0,  0,  8,   0,  0,  0,  8,    2,   0,     0},
 100     {WINED3DFMT_L4A4_UNORM,                 0,  0,  0,  4,   0,  0,  0,  4,    1,   0,     0},
 101     {WINED3DFMT_L16_UNORM,                  0,  0,  0,  0,   0,  0,  0,  0,    2,   0,     0},
 102     /* Bump mapping stuff */
 103     {WINED3DFMT_R8G8_SNORM,                 8,  8,  0,  0,   0,  8,  0,  0,    2,   0,     0},
 104     {WINED3DFMT_R5G5_SNORM_L6_UNORM,        5,  5,  0,  0,   0,  5,  0,  0,    2,   0,     0},
 105     {WINED3DFMT_R8G8_SNORM_L8X8_UNORM,      8,  8,  0,  0,   0,  8,  0,  0,    4,   0,     0},
 106     {WINED3DFMT_R8G8B8A8_SNORM,             8,  8,  8,  8,   0,  8, 16, 24,    4,   0,     0},
 107     {WINED3DFMT_R16G16_SNORM,              16, 16,  0,  0,   0, 16,  0,  0,    4,   0,     0},
 108     {WINED3DFMT_R10G11B11_SNORM,           10, 11, 11,  0,   0, 10, 21,  0,    4,   0,     0},
 109     {WINED3DFMT_R10G10B10_SNORM_A2_UNORM,  10, 10, 10,  2,   0, 10, 20, 30,    4,   0,     0},
 110     /* Depth stencil formats */
 111     {WINED3DFMT_D16_LOCKABLE,               0,  0,  0,  0,   0,  0,  0,  0,    2,  16,     0},
 112     {WINED3DFMT_D32_UNORM,                  0,  0,  0,  0,   0,  0,  0,  0,    4,  32,     0},
 113     {WINED3DFMT_S1_UINT_D15_UNORM,          0,  0,  0,  0,   0,  0,  0,  0,    2,  15,     1},
 114     {WINED3DFMT_D24_UNORM_S8_UINT,          0,  0,  0,  0,   0,  0,  0,  0,    4,  24,     8},
 115     {WINED3DFMT_X8D24_UNORM,                0,  0,  0,  0,   0,  0,  0,  0,    4,  24,     0},
 116     {WINED3DFMT_S4X4_UINT_D24_UNORM,        0,  0,  0,  0,   0,  0,  0,  0,    4,  24,     4},
 117     {WINED3DFMT_D16_UNORM,                  0,  0,  0,  0,   0,  0,  0,  0,    2,  16,     0},
 118     {WINED3DFMT_D32_FLOAT,                  0,  0,  0,  0,   0,  0,  0,  0,    4,  32,     0},
 119     {WINED3DFMT_S8_UINT_D24_FLOAT,          0,  0,  0,  0,   0,  0,  0,  0,    4,  24,     8},
 120     {WINED3DFMT_VERTEXDATA,                 0,  0,  0,  0,   0,  0,  0,  0,    0,   0,     0},
 121     {WINED3DFMT_R16_UINT,                  16,  0,  0,  0,   0,  0,  0,  0,    2,   0,     0},
 122     {WINED3DFMT_R32_UINT,                  32,  0,  0,  0,   0,  0,  0,  0,    4,   0,     0},
 123     {WINED3DFMT_R16G16B16A16_SNORM,        16, 16, 16, 16,   0, 16, 32, 48,    8,   0,     0},
 124     /* Vendor-specific formats */
 125     {WINED3DFMT_ATI2N,                      0,  0,  0,  0,   0,  0,  0,  0,    1,   0,     0},
 126     {WINED3DFMT_NVDB,                       0,  0,  0,  0,   0,  0,  0,  0,    0,   0,     0},
 127     {WINED3DFMT_INST,                       0,  0,  0,  0,   0,  0,  0,  0,    0,   0,     0},
 128     {WINED3DFMT_INTZ,                       0,  0,  0,  0,   0,  0,  0,  0,    4,  24,     8},
 129     {WINED3DFMT_RESZ,                       0,  0,  0,  0,   0,  0,  0,  0,    0,   0,     0},
 130     {WINED3DFMT_NVHU,                       0,  0,  0,  0,   0,  0,  0,  0,    2,   0,     0},
 131     {WINED3DFMT_NVHS,                       0,  0,  0,  0,   0,  0,  0,  0,    2,   0,     0},
 132     {WINED3DFMT_NULL,                       8,  8,  8,  8,   0,  8, 16, 24,    4,   0,     0},
 133     /* Unsure about them, could not find a Windows driver that supports them */
 134     {WINED3DFMT_R16,                       16,  0,  0,  0,   0,  0,  0,  0,    2,   0,     0},
 135     {WINED3DFMT_AL16,                       0,  0,  0, 16,   0,  0,  0, 16,    4,   0,     0},
 136 };
 137
 138 struct wined3d_format_base_flags
 139 {
 140     enum wined3d_format_id id;
 141     DWORD flags;
 142 };
 143
 144 /* The ATI2N format behaves like an uncompressed format in LockRect(), but
 145  * still needs to use the correct block based calculation for e.g. the
 146  * resource size. */
 147 static const struct wined3d_format_base_flags format_base_flags[] =
 148 {
 149     {WINED3DFMT_P8_UINT,            WINED3DFMT_FLAG_GETDC},
 150     {WINED3DFMT_B8G8R8_UNORM,       WINED3DFMT_FLAG_GETDC},
 151     {WINED3DFMT_B8G8R8A8_UNORM,     WINED3DFMT_FLAG_GETDC},
 152     {WINED3DFMT_B8G8R8X8_UNORM,     WINED3DFMT_FLAG_GETDC},
 153     {WINED3DFMT_B5G6R5_UNORM,       WINED3DFMT_FLAG_GETDC},
 154     {WINED3DFMT_B5G5R5X1_UNORM,     WINED3DFMT_FLAG_GETDC},
 155     {WINED3DFMT_B5G5R5A1_UNORM,     WINED3DFMT_FLAG_GETDC},
 156     {WINED3DFMT_B4G4R4A4_UNORM,     WINED3DFMT_FLAG_GETDC},
 157     {WINED3DFMT_B4G4R4X4_UNORM,     WINED3DFMT_FLAG_GETDC},
 158     {WINED3DFMT_R8G8B8A8_UNORM,     WINED3DFMT_FLAG_GETDC},
 159     {WINED3DFMT_R8G8B8X8_UNORM,     WINED3DFMT_FLAG_GETDC},
 160     {WINED3DFMT_ATI2N,              WINED3DFMT_FLAG_BROKEN_PITCH},
 161     {WINED3DFMT_R32_FLOAT,          WINED3DFMT_FLAG_FLOAT},
 162     {WINED3DFMT_R32G32_FLOAT,       WINED3DFMT_FLAG_FLOAT},
 163     {WINED3DFMT_R32G32B32_FLOAT,    WINED3DFMT_FLAG_FLOAT},
 164     {WINED3DFMT_R32G32B32A32_FLOAT, WINED3DFMT_FLAG_FLOAT},
 165     {WINED3DFMT_R16_FLOAT,          WINED3DFMT_FLAG_FLOAT},
 166     {WINED3DFMT_R16G16_FLOAT,       WINED3DFMT_FLAG_FLOAT},
 167     {WINED3DFMT_R16G16B16A16_FLOAT, WINED3DFMT_FLAG_FLOAT},
 168     {WINED3DFMT_D32_FLOAT,          WINED3DFMT_FLAG_FLOAT},
 169     {WINED3DFMT_S8_UINT_D24_FLOAT,  WINED3DFMT_FLAG_FLOAT},
 170 };
 171
 172 struct wined3d_format_block_info
 173 {
 174     enum wined3d_format_id id;
 175     UINT block_width;
 176     UINT block_height;
 177     UINT block_byte_count;
 178 };
 179
 180 static const struct wined3d_format_block_info format_block_info[] =
 181 {
 182     {WINED3DFMT_DXT1,   4,  4,  8},
 183     {WINED3DFMT_DXT2,   4,  4,  16},
 184     {WINED3DFMT_DXT3,   4,  4,  16},
 185     {WINED3DFMT_DXT4,   4,  4,  16},
 186     {WINED3DFMT_DXT5,   4,  4,  16},
 187     {WINED3DFMT_ATI2N,  4,  4,  16},
 188     {WINED3DFMT_YUY2,   2,  1,  4},
 189     {WINED3DFMT_UYVY,   2,  1,  4},
 190 };
 191
 192 struct wined3d_format_vertex_info
 193 {
 194     enum wined3d_format_id id;
 195     enum wined3d_ffp_emit_idx emit_idx;
 196     GLint component_count;
 197     GLenum gl_vtx_type;
 198     GLint gl_vtx_format;
 199     GLboolean gl_normalized;
 200     unsigned int component_size;
 201 };
 202
 203 static const struct wined3d_format_vertex_info format_vertex_info[] =
 204 {
 205     {WINED3DFMT_R32_FLOAT,          WINED3D_FFP_EMIT_FLOAT1,    1, GL_FLOAT,          1, GL_FALSE, sizeof(float)},
 206     {WINED3DFMT_R32G32_FLOAT,       WINED3D_FFP_EMIT_FLOAT2,    2, GL_FLOAT,          2, GL_FALSE, sizeof(float)},
 207     {WINED3DFMT_R32G32B32_FLOAT,    WINED3D_FFP_EMIT_FLOAT3,    3, GL_FLOAT,          3, GL_FALSE, sizeof(float)},
 208     {WINED3DFMT_R32G32B32A32_FLOAT, WINED3D_FFP_EMIT_FLOAT4,    4, GL_FLOAT,          4, GL_FALSE, sizeof(float)},
 209     {WINED3DFMT_B8G8R8A8_UNORM,     WINED3D_FFP_EMIT_D3DCOLOR,  4, GL_UNSIGNED_BYTE,  4, GL_TRUE,  sizeof(BYTE)},
 210     {WINED3DFMT_R8G8B8A8_UINT,      WINED3D_FFP_EMIT_UBYTE4,    4, GL_UNSIGNED_BYTE,  4, GL_FALSE, sizeof(BYTE)},
 211     {WINED3DFMT_R16G16_SINT,        WINED3D_FFP_EMIT_SHORT2,    2, GL_SHORT,          2, GL_FALSE, sizeof(short int)},
 212     {WINED3DFMT_R16G16B16A16_SINT,  WINED3D_FFP_EMIT_SHORT4,    4, GL_SHORT,          4, GL_FALSE, sizeof(short int)},
 213     {WINED3DFMT_R8G8B8A8_UNORM,     WINED3D_FFP_EMIT_UBYTE4N,   4, GL_UNSIGNED_BYTE,  4, GL_TRUE,  sizeof(BYTE)},
 214     {WINED3DFMT_R16G16_SNORM,       WINED3D_FFP_EMIT_SHORT2N,   2, GL_SHORT,          2, GL_TRUE,  sizeof(short int)},
 215     {WINED3DFMT_R16G16B16A16_SNORM, WINED3D_FFP_EMIT_SHORT4N,   4, GL_SHORT,          4, GL_TRUE,  sizeof(short int)},
 216     {WINED3DFMT_R16G16_UNORM,       WINED3D_FFP_EMIT_USHORT2N,  2, GL_UNSIGNED_SHORT, 2, GL_TRUE,  sizeof(short int)},
 217     {WINED3DFMT_R16G16B16A16_UNORM, WINED3D_FFP_EMIT_USHORT4N,  4, GL_UNSIGNED_SHORT, 4, GL_TRUE,  sizeof(short int)},
 218     {WINED3DFMT_R10G10B10A2_UINT,   WINED3D_FFP_EMIT_UDEC3,     3, GL_UNSIGNED_SHORT, 3, GL_FALSE, sizeof(short int)},
 219     {WINED3DFMT_R10G10B10A2_SNORM,  WINED3D_FFP_EMIT_DEC3N,     3, GL_SHORT,          3, GL_TRUE,  sizeof(short int)},
 220     {WINED3DFMT_R16G16_FLOAT,       WINED3D_FFP_EMIT_FLOAT16_2, 2, GL_FLOAT,          2, GL_FALSE, sizeof(GLhalfNV)},
 221     {WINED3DFMT_R16G16B16A16_FLOAT, WINED3D_FFP_EMIT_FLOAT16_4, 4, GL_FLOAT,          4, GL_FALSE, sizeof(GLhalfNV)}
 222 };
 223
 224 struct wined3d_format_texture_info
 225 {
 226     enum wined3d_format_id id;
 227     GLint gl_internal;
 228     GLint gl_srgb_internal;
 229     GLint gl_rt_internal;
 230     GLint gl_format;
 231     GLint gl_type;
 232     unsigned int conv_byte_count;
 233     unsigned int flags;
 234     enum wined3d_gl_extension extension;
 235     void (*convert)(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height);
 236 };
 237
 238 static void convert_l4a4_unorm(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
 239 {
 240     /* WINED3DFMT_L4A4_UNORM exists as an internal gl format, but for some reason there is not
 241      * format+type combination to load it. Thus convert it to A8L8, then load it
 242      * with A4L4 internal, but A8L8 format+type
 243      */
 244     unsigned int x, y;
 245     const unsigned char *Source;
 246     unsigned char *Dest;
 247     UINT outpitch = pitch * 2;
 248
 249     for(y = 0; y < height; y++) {
 250         Source = src + y * pitch;
 251         Dest = dst + y * outpitch;
 252         for (x = 0; x < width; x++ ) {
 253             unsigned char color = (*Source++);
 254             /* A */ Dest[1] = (color & 0xf0) << 0;
 255             /* L */ Dest[0] = (color & 0x0f) << 4;
 256             Dest += 2;
 257         }
 258     }
 259 }
 260
 261 static void convert_r5g5_snorm_l6_unorm(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
 262 {
 263     unsigned int x, y;
 264     const WORD *Source;
 265
 266     for(y = 0; y < height; y++)
 267     {
 268         unsigned short *Dest_s = (unsigned short *) (dst + y * pitch);
 269         Source = (const WORD *)(src + y * pitch);
 270         for (x = 0; x < width; x++ )
 271         {
 272             short color = (*Source++);
 273             unsigned char l = ((color >> 10) & 0xfc);
 274                     short v = ((color >>  5) & 0x3e);
 275                     short u = ((color      ) & 0x1f);
 276             short v_conv = v + 16;
 277             short u_conv = u + 16;
 278
 279             *Dest_s = ((v_conv << 11) & 0xf800) | ((l << 5) & 0x7e0) | (u_conv & 0x1f);
 280             Dest_s += 1;
 281         }
 282     }
 283 }
 284
 285 static void convert_r5g5_snorm_l6_unorm_nv(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
 286 {
 287     unsigned int x, y;
 288     const WORD *Source;
 289     unsigned char *Dest;
 290     UINT outpitch = (pitch * 3)/2;
 291
 292     /* This makes the gl surface bigger(24 bit instead of 16), but it works with
 293      * fixed function and shaders without further conversion once the surface is
 294      * loaded
 295      */
 296     for(y = 0; y < height; y++) {
 297         Source = (const WORD *)(src + y * pitch);
 298         Dest = dst + y * outpitch;
 299         for (x = 0; x < width; x++ ) {
 300             short color = (*Source++);
 301             unsigned char l = ((color >> 10) & 0xfc);
 302                      char v = ((color >>  5) & 0x3e);
 303                      char u = ((color      ) & 0x1f);
 304
 305             /* 8 bits destination, 6 bits source, 8th bit is the sign. gl ignores the sign
 306              * and doubles the positive range. Thus shift left only once, gl does the 2nd
 307              * shift. GL reads a signed value and converts it into an unsigned value.
 308              */
 309             /* M */ Dest[2] = l << 1;
 310
 311             /* Those are read as signed, but kept signed. Just left-shift 3 times to scale
 312              * from 5 bit values to 8 bit values.
 313              */
 314             /* V */ Dest[1] = v << 3;
 315             /* U */ Dest[0] = u << 3;
 316             Dest += 3;
 317         }
 318     }
 319 }
 320
 321 static void convert_r8g8_snorm(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
 322 {
 323     unsigned int x, y;
 324     const short *Source;
 325     unsigned char *Dest;
 326     UINT outpitch = (pitch * 3)/2;
 327
 328     for(y = 0; y < height; y++)
 329     {
 330         Source = (const short *)(src + y * pitch);
 331         Dest = dst + y * outpitch;
 332         for (x = 0; x < width; x++ )
 333         {
 334             const short color = (*Source++);
 335             /* B */ Dest[0] = 0xff;
 336             /* G */ Dest[1] = (color >> 8) + 128; /* V */
 337             /* R */ Dest[2] = (color & 0xff) + 128;      /* U */
 338             Dest += 3;
 339         }
 340     }
 341 }
 342
 343 static void convert_r8g8_snorm_l8x8_unorm(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
 344 {
 345     unsigned int x, y;
 346     const DWORD *Source;
 347     unsigned char *Dest;
 348
 349     /* Doesn't work correctly with the fixed function pipeline, but can work in
 350      * shaders if the shader is adjusted. (There's no use for this format in gl's
 351      * standard fixed function pipeline anyway).
 352      */
 353     for(y = 0; y < height; y++)
 354     {
 355         Source = (const DWORD *)(src + y * pitch);
 356         Dest = dst + y * pitch;
 357         for (x = 0; x < width; x++ )
 358         {
 359             LONG color = (*Source++);
 360             /* B */ Dest[0] = ((color >> 16) & 0xff);       /* L */
 361             /* G */ Dest[1] = ((color >> 8 ) & 0xff) + 128; /* V */
 362             /* R */ Dest[2] = (color         & 0xff) + 128; /* U */
 363             Dest += 4;
 364         }
 365     }
 366 }
 367
 368 static void convert_r8g8_snorm_l8x8_unorm_nv(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
 369 {
 370     unsigned int x, y;
 371     const DWORD *Source;
 372     unsigned char *Dest;
 373
 374     /* This implementation works with the fixed function pipeline and shaders
 375      * without further modification after converting the surface.
 376      */
 377     for(y = 0; y < height; y++)
 378     {
 379         Source = (const DWORD *)(src + y * pitch);
 380         Dest = dst + y * pitch;
 381         for (x = 0; x < width; x++ )
 382         {
 383             LONG color = (*Source++);
 384             /* L */ Dest[2] = ((color >> 16) & 0xff);   /* L */
 385             /* V */ Dest[1] = ((color >> 8 ) & 0xff);   /* V */
 386             /* U */ Dest[0] = (color         & 0xff);   /* U */
 387             /* I */ Dest[3] = 255;                      /* X */
 388             Dest += 4;
 389         }
 390     }
 391 }
 392
 393 static void convert_r8g8b8a8_snorm(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
 394 {
 395     unsigned int x, y;
 396     const DWORD *Source;
 397     unsigned char *Dest;
 398
 399     for(y = 0; y < height; y++)
 400     {
 401         Source = (const DWORD *)(src + y * pitch);
 402         Dest = dst + y * pitch;
 403         for (x = 0; x < width; x++ )
 404         {
 405             LONG color = (*Source++);
 406             /* B */ Dest[0] = ((color >> 16) & 0xff) + 128; /* W */
 407             /* G */ Dest[1] = ((color >> 8 ) & 0xff) + 128; /* V */
 408             /* R */ Dest[2] = (color         & 0xff) + 128; /* U */
 409             /* A */ Dest[3] = ((color >> 24) & 0xff) + 128; /* Q */
 410             Dest += 4;
 411         }
 412     }
 413 }
 414
 415 static void convert_r16g16_snorm(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
 416 {
 417     unsigned int x, y;
 418     const DWORD *Source;
 419     unsigned short *Dest;
 420     UINT outpitch = (pitch * 3)/2;
 421
 422     for(y = 0; y < height; y++)
 423     {
 424         Source = (const DWORD *)(src + y * pitch);
 425         Dest = (unsigned short *) (dst + y * outpitch);
 426         for (x = 0; x < width; x++ )
 427         {
 428             const DWORD color = (*Source++);
 429             /* B */ Dest[0] = 0xffff;
 430             /* G */ Dest[1] = (color >> 16) + 32768; /* V */
 431             /* R */ Dest[2] = (color & 0xffff) + 32768; /* U */
 432             Dest += 3;
 433         }
 434     }
 435 }
 436
 437 static void convert_r16g16(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
 438 {
 439     unsigned int x, y;
 440     const WORD *Source;
 441     WORD *Dest;
 442     UINT outpitch = (pitch * 3)/2;
 443
 444     for(y = 0; y < height; y++)
 445     {
 446         Source = (const WORD *)(src + y * pitch);
 447         Dest = (WORD *) (dst + y * outpitch);
 448         for (x = 0; x < width; x++ )
 449         {
 450             WORD green = (*Source++);
 451             WORD red = (*Source++);
 452             Dest[0] = green;
 453             Dest[1] = red;
 454             /* Strictly speaking not correct for R16G16F, but it doesn't matter because the
 455              * shader overwrites it anyway
 456              */
 457             Dest[2] = 0xffff;
 458             Dest += 3;
 459         }
 460     }
 461 }
 462
 463 static void convert_r32g32_float(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
 464 {
 465     unsigned int x, y;
 466     const float *Source;
 467     float *Dest;
 468     UINT outpitch = (pitch * 3)/2;
 469
 470     for(y = 0; y < height; y++)
 471     {
 472         Source = (const float *)(src + y * pitch);
 473         Dest = (float *) (dst + y * outpitch);
 474         for (x = 0; x < width; x++ )
 475         {
 476             float green = (*Source++);
 477             float red = (*Source++);
 478             Dest[0] = green;
 479             Dest[1] = red;
 480             Dest[2] = 1.0f;
 481             Dest += 3;
 482         }
 483     }
 484 }
 485
 486 static void convert_s1_uint_d15_unorm(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
 487 {
 488     unsigned int x, y;
 489     UINT outpitch = pitch * 2;
 490
 491     for (y = 0; y < height; ++y)
 492     {
 493         const WORD *source = (const WORD *)(src + y * pitch);
 494         DWORD *dest = (DWORD *)(dst + y * outpitch);
 495
 496         for (x = 0; x < width; ++x)
 497         {
 498             /* The depth data is normalized, so needs to be scaled,
 499              * the stencil data isn't.  Scale depth data by
 500              *      (2^24-1)/(2^15-1) ~~ (2^9 + 2^-6). */
 501             WORD d15 = source[x] >> 1;
 502             DWORD d24 = (d15 << 9) + (d15 >> 6);
 503             dest[x] = (d24 << 8) | (source[x] & 0x1);
 504         }
 505     }
 506 }
 507
 508 static void convert_s4x4_uint_d24_unorm(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
 509 {
 510     unsigned int x, y;
 511
 512     for (y = 0; y < height; ++y)
 513     {
 514         const DWORD *source = (const DWORD *)(src + y * pitch);
 515         DWORD *dest = (DWORD *)(dst + y * pitch);
 516
 517         for (x = 0; x < width; ++x)
 518         {
 519             /* Just need to clear out the X4 part. */
 520             dest[x] = source[x] & ~0xf0;
 521         }
 522     }
 523 }
 524
 525 static void convert_s8_uint_d24_float(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
 526 {
 527     unsigned int x, y;
 528     UINT outpitch = pitch * 2;
 529
 530     for (y = 0; y < height; ++y)
 531     {
 532         const DWORD *source = (const DWORD *)(src + y * pitch);
 533         float *dest_f = (float *)(dst + y * outpitch);
 534         DWORD *dest_s = (DWORD *)(dst + y * outpitch);
 535
 536         for (x = 0; x < width; ++x)
 537         {
 538             dest_f[x * 2] = float_24_to_32((source[x] & 0xffffff00) >> 8);
 539             dest_s[x * 2 + 1] = source[x] & 0xff;
 540         }
 541     }
 542 }
 543
 544 /* The following formats explicitly don't have WINED3DFMT_FLAG_TEXTURE set:
 545  *
 546  * These are never supported on native.
 547  *     WINED3DFMT_B8G8R8_UNORM
 548  *     WINED3DFMT_B2G3R3_UNORM
 549  *     WINED3DFMT_L4A4_UNORM
 550  *     WINED3DFMT_S1_UINT_D15_UNORM
 551  *     WINED3DFMT_S4X4_UINT_D24_UNORM
 552  *
 553  * Only some Geforce/Voodoo3/G400 cards offer 8-bit textures in case of ddraw.
 554  * Since it is not widely available, don't offer it. Further no Windows driver
 555  * offers WINED3DFMT_P8_UINT_A8_NORM, so don't offer it either.
 556  *     WINED3DFMT_P8_UINT
 557  *     WINED3DFMT_P8_UINT_A8_UNORM
 558  *
 559  * These formats seem to be similar to the HILO formats in
 560  * GL_NV_texture_shader. NVHU is said to be GL_UNSIGNED_HILO16,
 561  * NVHS GL_SIGNED_HILO16. Rumours say that D3D computes a 3rd channel
 562  * similarly to D3DFMT_CxV8U8 (So NVHS could be called D3DFMT_CxV16U16). ATI
 563  * refused to support formats which can easily be emulated with pixel shaders,
 564  * so applications have to deal with not having NVHS and NVHU.
 565  *     WINED3DFMT_NVHU
 566  *     WINED3DFMT_NVHS */
 567 static const struct wined3d_format_texture_info format_texture_info[] =
 568 {
 569     /* format id                        gl_internal                       gl_srgb_internal                      gl_rt_internal
 570             gl_format                   gl_type                           conv_byte_count
 571             flags
 572             extension                   convert */
 573     /* FourCC formats */
 574     /* GL_APPLE_ycbcr_422 claims that its '2YUV' format, which is supported via the UNSIGNED_SHORT_8_8_REV_APPLE type
 575      * is equivalent to 'UYVY' format on Windows, and the 'YUVS' via UNSIGNED_SHORT_8_8_APPLE equates to 'YUY2'. The
 576      * d3d9 test however shows that the opposite is true. Since the extension is from 2002, it predates the x86 based
 577      * Macs, so probably the endianness differs. This could be tested as soon as we have a Windows and MacOS on a big
 578      * endian machine
 579      */
 580     {WINED3DFMT_UYVY,                   GL_LUMINANCE_ALPHA,               GL_LUMINANCE_ALPHA,                     0,
 581             GL_LUMINANCE_ALPHA,         GL_UNSIGNED_BYTE,                 0,
 582             WINED3DFMT_FLAG_FILTERING,
 583             WINED3D_GL_EXT_NONE,        NULL},
 584     {WINED3DFMT_UYVY,                   GL_RGB,                           GL_RGB,                                 0,
 585             GL_YCBCR_422_APPLE,         GL_UNSIGNED_SHORT_8_8_APPLE,      0,
 586             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_FILTERING,
 587             APPLE_YCBCR_422,            NULL},
 588     {WINED3DFMT_YUY2,                   GL_LUMINANCE_ALPHA,               GL_LUMINANCE_ALPHA,                     0,
 589             GL_LUMINANCE_ALPHA,         GL_UNSIGNED_BYTE,                 0,
 590             WINED3DFMT_FLAG_FILTERING,
 591             WINED3D_GL_EXT_NONE,        NULL},
 592     {WINED3DFMT_YUY2,                   GL_RGB,                           GL_RGB,                                 0,
 593             GL_YCBCR_422_APPLE,         GL_UNSIGNED_SHORT_8_8_REV_APPLE,  0,
 594             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_FILTERING,
 595             APPLE_YCBCR_422,            NULL},
 596     {WINED3DFMT_YV12,                   GL_ALPHA,                         GL_ALPHA,                               0,
 597             GL_ALPHA,                   GL_UNSIGNED_BYTE,                 0,
 598             WINED3DFMT_FLAG_FILTERING,
 599             WINED3D_GL_EXT_NONE,        NULL},
 600     {WINED3DFMT_DXT1,                   GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, 0,
 601             GL_RGBA,                    GL_UNSIGNED_BYTE,                 0,
 602             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
 603             | WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_COMPRESSED,
 604             EXT_TEXTURE_COMPRESSION_S3TC, NULL},
 605     {WINED3DFMT_DXT2,                   GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, 0,
 606             GL_RGBA,                    GL_UNSIGNED_BYTE,                 0,
 607             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
 608             | WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_COMPRESSED,
 609             EXT_TEXTURE_COMPRESSION_S3TC, NULL},
 610     {WINED3DFMT_DXT3,                   GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, 0,
 611             GL_RGBA,                    GL_UNSIGNED_BYTE,                 0,
 612             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
 613             | WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_COMPRESSED,
 614             EXT_TEXTURE_COMPRESSION_S3TC, NULL},
 615     {WINED3DFMT_DXT4,                   GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, 0,
 616             GL_RGBA,                    GL_UNSIGNED_BYTE,                 0,
 617             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
 618             | WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_COMPRESSED,
 619             EXT_TEXTURE_COMPRESSION_S3TC, NULL},
 620     {WINED3DFMT_DXT5,                   GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, 0,
 621             GL_RGBA,                    GL_UNSIGNED_BYTE,                 0,
 622             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
 623             | WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_COMPRESSED,
 624             EXT_TEXTURE_COMPRESSION_S3TC, NULL},
 625     /* IEEE formats */
 626     {WINED3DFMT_R32_FLOAT,              GL_RGB32F_ARB,                    GL_RGB32F_ARB,                          0,
 627             GL_RED,                     GL_FLOAT,                         0,
 628             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_VTF,
 629             ARB_TEXTURE_FLOAT,          NULL},
 630     {WINED3DFMT_R32_FLOAT,              GL_R32F,                          GL_R32F,                                0,
 631             GL_RED,                     GL_FLOAT,                         0,
 632             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_VTF,
 633             ARB_TEXTURE_RG,             NULL},
 634     {WINED3DFMT_R32G32_FLOAT,           GL_RGB32F_ARB,                    GL_RGB32F_ARB,                          0,
 635             GL_RGB,                     GL_FLOAT,                         12,
 636             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_VTF,
 637             ARB_TEXTURE_FLOAT,          convert_r32g32_float},
 638     {WINED3DFMT_R32G32_FLOAT,           GL_RG32F,                         GL_RG32F,                               0,
 639             GL_RG,                      GL_FLOAT,                         0,
 640             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_VTF,
 641             ARB_TEXTURE_RG,             NULL},
 642     {WINED3DFMT_R32G32B32A32_FLOAT,     GL_RGBA32F_ARB,                   GL_RGBA32F_ARB,                         0,
 643             GL_RGBA,                    GL_FLOAT,                         0,
 644             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_VTF,
 645             ARB_TEXTURE_FLOAT,          NULL},
 646     /* Float */
 647     {WINED3DFMT_R16_FLOAT,              GL_RGB16F_ARB,                    GL_RGB16F_ARB,                          0,
 648             GL_RED,                     GL_HALF_FLOAT_ARB,                0,
 649             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_VTF,
 650             ARB_TEXTURE_FLOAT,          NULL},
 651     {WINED3DFMT_R16_FLOAT,              GL_R16F,                          GL_R16F,                                0,
 652             GL_RED,                     GL_HALF_FLOAT_ARB,                0,
 653             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_VTF,
 654             ARB_TEXTURE_RG,             NULL},
 655     {WINED3DFMT_R16G16_FLOAT,           GL_RGB16F_ARB,                    GL_RGB16F_ARB,                          0,
 656             GL_RGB,                     GL_HALF_FLOAT_ARB,                6,
 657             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_VTF,
 658             ARB_TEXTURE_FLOAT,          convert_r16g16},
 659     {WINED3DFMT_R16G16_FLOAT,           GL_RG16F,                         GL_RG16F,                               0,
 660             GL_RG,                      GL_HALF_FLOAT_ARB,                0,
 661             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_VTF,
 662             ARB_TEXTURE_RG,             NULL},
 663     {WINED3DFMT_R16G16B16A16_FLOAT,     GL_RGBA16F_ARB,                   GL_RGBA16F_ARB,                         0,
 664             GL_RGBA,                    GL_HALF_FLOAT_ARB,                0,
 665             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_RENDERTARGET
 666             | WINED3DFMT_FLAG_VTF,
 667             ARB_TEXTURE_FLOAT,          NULL},
 668     /* Palettized formats */
 669     {WINED3DFMT_P8_UINT,                GL_RGBA,                          GL_RGBA,                                0,
 670             GL_ALPHA,                   GL_UNSIGNED_BYTE,                 0,
 671             0,
 672             ARB_FRAGMENT_PROGRAM,       NULL},
 673     {WINED3DFMT_P8_UINT,                GL_COLOR_INDEX8_EXT,              GL_COLOR_INDEX8_EXT,                    0,
 674             GL_COLOR_INDEX,             GL_UNSIGNED_BYTE,                 0,
 675             0,
 676             EXT_PALETTED_TEXTURE,       NULL},
 677     /* Standard ARGB formats */
 678     {WINED3DFMT_B8G8R8_UNORM,           GL_RGB8,                          GL_RGB8,                                0,
 679             GL_BGR,                     GL_UNSIGNED_BYTE,                 0,
 680             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET,
 681             WINED3D_GL_EXT_NONE,        NULL},
 682     {WINED3DFMT_B8G8R8A8_UNORM,         GL_RGBA8,                         GL_SRGB8_ALPHA8_EXT,                    0,
 683             GL_BGRA,                    GL_UNSIGNED_INT_8_8_8_8_REV,      0,
 684             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
 685             | WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_SRGB_WRITE
 686             | WINED3DFMT_FLAG_VTF,
 687             WINED3D_GL_EXT_NONE,        NULL},
 688     {WINED3DFMT_B8G8R8X8_UNORM,         GL_RGB8,                          GL_SRGB8_EXT,                           0,
 689             GL_BGRA,                    GL_UNSIGNED_INT_8_8_8_8_REV,      0,
 690             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
 691             | WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_SRGB_WRITE,
 692             WINED3D_GL_EXT_NONE,        NULL},
 693     {WINED3DFMT_B5G6R5_UNORM,           GL_RGB5,                          GL_RGB5,                          GL_RGB8,
 694             GL_RGB,                     GL_UNSIGNED_SHORT_5_6_5,          0,
 695             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
 696             | WINED3DFMT_FLAG_RENDERTARGET,
 697             WINED3D_GL_EXT_NONE,        NULL},
 698     {WINED3DFMT_B5G5R5X1_UNORM,         GL_RGB5,                          GL_RGB5_A1,                             0,
 699             GL_BGRA,                    GL_UNSIGNED_SHORT_1_5_5_5_REV,    0,
 700             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
 701             WINED3D_GL_EXT_NONE,        NULL},
 702     {WINED3DFMT_B5G5R5A1_UNORM,         GL_RGB5_A1,                       GL_RGB5_A1,                             0,
 703             GL_BGRA,                    GL_UNSIGNED_SHORT_1_5_5_5_REV,    0,
 704             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
 705             WINED3D_GL_EXT_NONE,        NULL},
 706     {WINED3DFMT_B4G4R4A4_UNORM,         GL_RGBA4,                         GL_SRGB8_ALPHA8_EXT,                    0,
 707             GL_BGRA,                    GL_UNSIGNED_SHORT_4_4_4_4_REV,    0,
 708             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
 709             | WINED3DFMT_FLAG_SRGB_READ,
 710             WINED3D_GL_EXT_NONE,        NULL},
 711     {WINED3DFMT_B2G3R3_UNORM,           GL_R3_G3_B2,                      GL_R3_G3_B2,                            0,
 712             GL_RGB,                     GL_UNSIGNED_BYTE_3_3_2,           0,
 713             WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
 714             WINED3D_GL_EXT_NONE,        NULL},
 715     {WINED3DFMT_A8_UNORM,               GL_ALPHA8,                        GL_ALPHA8,                              0,
 716             GL_ALPHA,                   GL_UNSIGNED_BYTE,                 0,
 717             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
 718             WINED3D_GL_EXT_NONE,        NULL},
 719     {WINED3DFMT_B4G4R4X4_UNORM,         GL_RGB4,                          GL_RGB4,                                0,
 720             GL_BGRA,                    GL_UNSIGNED_SHORT_4_4_4_4_REV,    0,
 721             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
 722             WINED3D_GL_EXT_NONE,        NULL},
 723     {WINED3DFMT_R10G10B10A2_UNORM,      GL_RGB10_A2,                      GL_RGB10_A2,                            0,
 724             GL_RGBA,                    GL_UNSIGNED_INT_2_10_10_10_REV,   0,
 725             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
 726             | WINED3DFMT_FLAG_RENDERTARGET,
 727             WINED3D_GL_EXT_NONE,        NULL},
 728     {WINED3DFMT_R8G8B8A8_UNORM,         GL_RGBA8,                         GL_RGBA8,                               0,
 729             GL_RGBA,                    GL_UNSIGNED_INT_8_8_8_8_REV,      0,
 730             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
 731             WINED3D_GL_EXT_NONE,        NULL},
 732     {WINED3DFMT_R8G8B8X8_UNORM,         GL_RGB8,                          GL_RGB8,                                0,
 733             GL_RGBA,                    GL_UNSIGNED_INT_8_8_8_8_REV,      0,
 734             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
 735             WINED3D_GL_EXT_NONE,        NULL},
 736     {WINED3DFMT_R16G16_UNORM,           GL_RGB16,                         GL_RGB16,                       GL_RGBA16,
 737             GL_RGB,                     GL_UNSIGNED_SHORT,                6,
 738             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
 739             WINED3D_GL_EXT_NONE,        convert_r16g16},
 740     {WINED3DFMT_R16G16_UNORM,           GL_RG16,                          GL_RG16,                                0,
 741             GL_RG,                      GL_UNSIGNED_SHORT,                0,
 742             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
 743             | WINED3DFMT_FLAG_RENDERTARGET,
 744             ARB_TEXTURE_RG,             NULL},
 745     {WINED3DFMT_B10G10R10A2_UNORM,      GL_RGB10_A2,                      GL_RGB10_A2,                            0,
 746             GL_BGRA,                    GL_UNSIGNED_INT_2_10_10_10_REV,   0,
 747             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
 748             | WINED3DFMT_FLAG_RENDERTARGET,
 749             WINED3D_GL_EXT_NONE,        NULL},
 750     {WINED3DFMT_R16G16B16A16_UNORM,     GL_RGBA16,                        GL_RGBA16,                              0,
 751             GL_RGBA,                    GL_UNSIGNED_SHORT,                0,
 752             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
 753             | WINED3DFMT_FLAG_RENDERTARGET,
 754             WINED3D_GL_EXT_NONE,        NULL},
 755     /* Luminance */
 756     {WINED3DFMT_L8_UNORM,               GL_LUMINANCE8,                    GL_SLUMINANCE8_EXT,                     0,
 757             GL_LUMINANCE,               GL_UNSIGNED_BYTE,                 0,
 758             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
 759             | WINED3DFMT_FLAG_SRGB_READ,
 760             WINED3D_GL_EXT_NONE,        NULL},
 761     {WINED3DFMT_L8A8_UNORM,             GL_LUMINANCE8_ALPHA8,             GL_SLUMINANCE8_ALPHA8_EXT,              0,
 762             GL_LUMINANCE_ALPHA,         GL_UNSIGNED_BYTE,                 0,
 763             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
 764             | WINED3DFMT_FLAG_SRGB_READ,
 765             WINED3D_GL_EXT_NONE,        NULL},
 766     {WINED3DFMT_L4A4_UNORM,             GL_LUMINANCE4_ALPHA4,             GL_LUMINANCE4_ALPHA4,                   0,
 767             GL_LUMINANCE_ALPHA,         GL_UNSIGNED_BYTE,                 2,
 768             WINED3DFMT_FLAG_FILTERING,
 769             WINED3D_GL_EXT_NONE,        convert_l4a4_unorm},
 770     /* Bump mapping stuff */
 771     {WINED3DFMT_R8G8_SNORM,             GL_RGB8,                          GL_RGB8,                                0,
 772             GL_BGR,                     GL_UNSIGNED_BYTE,                 3,
 773             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
 774             | WINED3DFMT_FLAG_BUMPMAP,
 775             WINED3D_GL_EXT_NONE,        convert_r8g8_snorm},
 776     {WINED3DFMT_R8G8_SNORM,             GL_DSDT8_NV,                      GL_DSDT8_NV,                            0,
 777             GL_DSDT_NV,                 GL_BYTE,                          0,
 778             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
 779             | WINED3DFMT_FLAG_BUMPMAP,
 780             NV_TEXTURE_SHADER,          NULL},
 781     {WINED3DFMT_R5G5_SNORM_L6_UNORM,    GL_RGB5,                          GL_RGB5,                                0,
 782             GL_RGB,                     GL_UNSIGNED_SHORT_5_6_5,          2,
 783             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
 784             | WINED3DFMT_FLAG_BUMPMAP,
 785             WINED3D_GL_EXT_NONE,        convert_r5g5_snorm_l6_unorm},
 786     {WINED3DFMT_R5G5_SNORM_L6_UNORM,    GL_DSDT8_MAG8_NV,                 GL_DSDT8_MAG8_NV,                       0,
 787             GL_DSDT_MAG_NV,             GL_BYTE,                          3,
 788             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
 789             | WINED3DFMT_FLAG_BUMPMAP,
 790             NV_TEXTURE_SHADER,          convert_r5g5_snorm_l6_unorm_nv},
 791     {WINED3DFMT_R8G8_SNORM_L8X8_UNORM,  GL_RGB8,                          GL_RGB8,                                0,
 792             GL_BGRA,                    GL_UNSIGNED_INT_8_8_8_8_REV,      4,
 793             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
 794             | WINED3DFMT_FLAG_BUMPMAP,
 795             WINED3D_GL_EXT_NONE,        convert_r8g8_snorm_l8x8_unorm},
 796     {WINED3DFMT_R8G8_SNORM_L8X8_UNORM,  GL_DSDT8_MAG8_INTENSITY8_NV,      GL_DSDT8_MAG8_INTENSITY8_NV,            0,
 797             GL_DSDT_MAG_VIB_NV,         GL_UNSIGNED_INT_8_8_S8_S8_REV_NV, 4,
 798             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
 799             | WINED3DFMT_FLAG_BUMPMAP,
 800             NV_TEXTURE_SHADER,          convert_r8g8_snorm_l8x8_unorm_nv},
 801     {WINED3DFMT_R8G8B8A8_SNORM,         GL_RGBA8,                         GL_RGBA8,                               0,
 802             GL_BGRA,                    GL_UNSIGNED_BYTE,                 4,
 803             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
 804             | WINED3DFMT_FLAG_BUMPMAP,
 805             WINED3D_GL_EXT_NONE,        convert_r8g8b8a8_snorm},
 806     {WINED3DFMT_R8G8B8A8_SNORM,         GL_SIGNED_RGBA8_NV,               GL_SIGNED_RGBA8_NV,                     0,
 807             GL_RGBA,                    GL_BYTE,                          0,
 808             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
 809             | WINED3DFMT_FLAG_BUMPMAP,
 810             NV_TEXTURE_SHADER,          NULL},
 811     {WINED3DFMT_R16G16_SNORM,           GL_RGB16,                         GL_RGB16,                               0,
 812             GL_BGR,                     GL_UNSIGNED_SHORT,                6,
 813             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
 814             | WINED3DFMT_FLAG_BUMPMAP,
 815             WINED3D_GL_EXT_NONE,        convert_r16g16_snorm},
 816     {WINED3DFMT_R16G16_SNORM,           GL_SIGNED_HILO16_NV,              GL_SIGNED_HILO16_NV,                    0,
 817             GL_HILO_NV,                 GL_SHORT,                         0,
 818             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
 819             | WINED3DFMT_FLAG_BUMPMAP,
 820             NV_TEXTURE_SHADER,          NULL},
 821     /* Depth stencil formats */
 822     {WINED3DFMT_D16_LOCKABLE,           GL_DEPTH_COMPONENT24_ARB,         GL_DEPTH_COMPONENT24_ARB,               0,
 823             GL_DEPTH_COMPONENT,         GL_UNSIGNED_SHORT,                0,
 824             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_SHADOW,
 825             ARB_DEPTH_TEXTURE,          NULL},
 826     {WINED3DFMT_D32_UNORM,              GL_DEPTH_COMPONENT32_ARB,         GL_DEPTH_COMPONENT32_ARB,               0,
 827             GL_DEPTH_COMPONENT,         GL_UNSIGNED_INT,                  0,
 828             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_SHADOW,
 829             ARB_DEPTH_TEXTURE,          NULL},
 830     {WINED3DFMT_S1_UINT_D15_UNORM,      GL_DEPTH_COMPONENT24_ARB,         GL_DEPTH_COMPONENT24_ARB,               0,
 831             GL_DEPTH_COMPONENT,         GL_UNSIGNED_SHORT,                0,
 832             WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_SHADOW,
 833             ARB_DEPTH_TEXTURE,          NULL},
 834     {WINED3DFMT_S1_UINT_D15_UNORM,      GL_DEPTH24_STENCIL8_EXT,          GL_DEPTH24_STENCIL8_EXT,                0,
 835             GL_DEPTH_STENCIL_EXT,       GL_UNSIGNED_INT_24_8_EXT,         4,
 836             WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL | WINED3DFMT_FLAG_SHADOW,
 837             EXT_PACKED_DEPTH_STENCIL,   convert_s1_uint_d15_unorm},
 838     {WINED3DFMT_S1_UINT_D15_UNORM,      GL_DEPTH24_STENCIL8,              GL_DEPTH24_STENCIL8,                    0,
 839             GL_DEPTH_STENCIL,           GL_UNSIGNED_INT_24_8,             4,
 840             WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL | WINED3DFMT_FLAG_SHADOW,
 841             ARB_FRAMEBUFFER_OBJECT,     convert_s1_uint_d15_unorm},
 842     {WINED3DFMT_D24_UNORM_S8_UINT,      GL_DEPTH_COMPONENT24_ARB,         GL_DEPTH_COMPONENT24_ARB,               0,
 843             GL_DEPTH_COMPONENT,         GL_UNSIGNED_INT,                  0,
 844             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
 845             | WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_SHADOW,
 846             ARB_DEPTH_TEXTURE,          NULL},
 847     {WINED3DFMT_D24_UNORM_S8_UINT,      GL_DEPTH24_STENCIL8_EXT,          GL_DEPTH24_STENCIL8_EXT,                0,
 848             GL_DEPTH_STENCIL_EXT,       GL_UNSIGNED_INT_24_8_EXT,         0,
 849             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
 850             | WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL | WINED3DFMT_FLAG_SHADOW,
 851             EXT_PACKED_DEPTH_STENCIL,   NULL},
 852     {WINED3DFMT_D24_UNORM_S8_UINT,      GL_DEPTH24_STENCIL8,              GL_DEPTH24_STENCIL8,                    0,
 853             GL_DEPTH_STENCIL,           GL_UNSIGNED_INT_24_8,             0,
 854             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
 855             | WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL | WINED3DFMT_FLAG_SHADOW,
 856             ARB_FRAMEBUFFER_OBJECT,     NULL},
 857     {WINED3DFMT_X8D24_UNORM,            GL_DEPTH_COMPONENT24_ARB,         GL_DEPTH_COMPONENT24_ARB,               0,
 858             GL_DEPTH_COMPONENT,         GL_UNSIGNED_INT,                  0,
 859             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
 860             | WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_SHADOW,
 861             ARB_DEPTH_TEXTURE,          NULL},
 862     {WINED3DFMT_S4X4_UINT_D24_UNORM,    GL_DEPTH_COMPONENT24_ARB,         GL_DEPTH_COMPONENT24_ARB,               0,
 863             GL_DEPTH_COMPONENT,         GL_UNSIGNED_INT,                  0,
 864             WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_SHADOW,
 865             ARB_DEPTH_TEXTURE,          NULL},
 866     {WINED3DFMT_S4X4_UINT_D24_UNORM,    GL_DEPTH24_STENCIL8_EXT,          GL_DEPTH24_STENCIL8_EXT,                0,
 867             GL_DEPTH_STENCIL_EXT,       GL_UNSIGNED_INT_24_8_EXT,         4,
 868             WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL | WINED3DFMT_FLAG_SHADOW,
 869             EXT_PACKED_DEPTH_STENCIL,   convert_s4x4_uint_d24_unorm},
 870     {WINED3DFMT_S4X4_UINT_D24_UNORM,    GL_DEPTH24_STENCIL8,              GL_DEPTH24_STENCIL8,                    0,
 871             GL_DEPTH_STENCIL,           GL_UNSIGNED_INT_24_8,             4,
 872             WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL | WINED3DFMT_FLAG_SHADOW,
 873             ARB_FRAMEBUFFER_OBJECT,     convert_s4x4_uint_d24_unorm},
 874     {WINED3DFMT_D16_UNORM,              GL_DEPTH_COMPONENT24_ARB,         GL_DEPTH_COMPONENT24_ARB,               0,
 875             GL_DEPTH_COMPONENT,         GL_UNSIGNED_SHORT,                0,
 876             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
 877             | WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_SHADOW,
 878             ARB_DEPTH_TEXTURE,          NULL},
 879     {WINED3DFMT_L16_UNORM,              GL_LUMINANCE16,                   GL_LUMINANCE16,                         0,
 880             GL_LUMINANCE,               GL_UNSIGNED_SHORT,                0,
 881             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
 882             WINED3D_GL_EXT_NONE,        NULL},
 883     {WINED3DFMT_D32_FLOAT,              GL_DEPTH_COMPONENT32F,            GL_DEPTH_COMPONENT32F,                  0,
 884             GL_DEPTH_COMPONENT,         GL_FLOAT,                         0,
 885             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_SHADOW,
 886             ARB_DEPTH_BUFFER_FLOAT,     NULL},
 887     {WINED3DFMT_S8_UINT_D24_FLOAT,      GL_DEPTH32F_STENCIL8,             GL_DEPTH32F_STENCIL8,                   0,
 888             GL_DEPTH_STENCIL,           GL_FLOAT_32_UNSIGNED_INT_24_8_REV, 8,
 889             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL | WINED3DFMT_FLAG_SHADOW,
 890             ARB_DEPTH_BUFFER_FLOAT,     convert_s8_uint_d24_float},
 891     /* Vendor-specific formats */
 892     {WINED3DFMT_ATI2N,                  GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI, GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI, 0,
 893             GL_LUMINANCE_ALPHA,         GL_UNSIGNED_BYTE,                 0,
 894             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
 895             | WINED3DFMT_FLAG_COMPRESSED,
 896             ATI_TEXTURE_COMPRESSION_3DC, NULL},
 897     {WINED3DFMT_ATI2N,                  GL_COMPRESSED_RG_RGTC2,           GL_COMPRESSED_RG_RGTC2,                 0,
 898             GL_LUMINANCE_ALPHA,         GL_UNSIGNED_BYTE,                 0,
 899             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
 900             | WINED3DFMT_FLAG_COMPRESSED,
 901             ARB_TEXTURE_COMPRESSION_RGTC, NULL},
 902     {WINED3DFMT_INTZ,                   GL_DEPTH24_STENCIL8_EXT,          GL_DEPTH24_STENCIL8_EXT,                0,
 903             GL_DEPTH_STENCIL_EXT,       GL_UNSIGNED_INT_24_8_EXT,         0,
 904             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
 905             | WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL,
 906             EXT_PACKED_DEPTH_STENCIL,   NULL},
 907     {WINED3DFMT_INTZ,                   GL_DEPTH24_STENCIL8,              GL_DEPTH24_STENCIL8,                    0,
 908             GL_DEPTH_STENCIL,           GL_UNSIGNED_INT_24_8,             0,
 909             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
 910             | WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL,
 911             ARB_FRAMEBUFFER_OBJECT,     NULL},
 912     {WINED3DFMT_NULL,                   0,                                0,                                      0,
 913             GL_RGBA,                    GL_UNSIGNED_INT_8_8_8_8_REV,      0,
 914             WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_RENDERTARGET,
 915             ARB_FRAMEBUFFER_OBJECT,     NULL},
 916 };
 917
 918 static inline int getFmtIdx(enum wined3d_format_id format_id)
 919 {
 920     /* First check if the format is at the position of its value.
 921      * This will catch the argb formats before the loop is entered. */
 922     if (format_id < (sizeof(formats) / sizeof(*formats))
 923             && formats[format_id].id == format_id)
 924     {
 925         return format_id;
 926     }
 927     else
 928     {
 929         unsigned int i;
 930
 931         for (i = 0; i < (sizeof(formats) / sizeof(*formats)); ++i)
 932         {
 933             if (formats[i].id == format_id) return i;
 934         }
 935     }
 936     return -1;
 937 }
 938
 939 static BOOL init_format_base_info(struct wined3d_gl_info *gl_info)
 940 {
 941     UINT format_count = sizeof(formats) / sizeof(*formats);
 942     UINT i;
 943
 944     gl_info->formats = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, format_count * sizeof(*gl_info->formats));
 945     if (!gl_info->formats)
 946     {
 947         ERR("Failed to allocate memory.\n");
 948         return FALSE;
 949     }
 950
 951     for (i = 0; i < format_count; ++i)
 952     {
 953         struct wined3d_format *format = &gl_info->formats[i];
 954         format->id = formats[i].id;
 955         format->red_size = formats[i].red_size;
 956         format->green_size = formats[i].green_size;
 957         format->blue_size = formats[i].blue_size;
 958         format->alpha_size = formats[i].alpha_size;
 959         format->red_offset = formats[i].red_offset;
 960         format->green_offset = formats[i].green_offset;
 961         format->blue_offset = formats[i].blue_offset;
 962         format->alpha_offset = formats[i].alpha_offset;
 963         format->byte_count = formats[i].bpp;
 964         format->depth_size = formats[i].depth_size;
 965         format->stencil_size = formats[i].stencil_size;
 966         format->block_width = 1;
 967         format->block_height = 1;
 968         format->block_byte_count = formats[i].bpp;
 969     }
 970
 971     for (i = 0; i < (sizeof(format_base_flags) / sizeof(*format_base_flags)); ++i)
 972     {
 973         int fmt_idx = getFmtIdx(format_base_flags[i].id);
 974
 975         if (fmt_idx == -1)
 976         {
 977             ERR("Format %s (%#x) not found.\n",
 978                     debug_d3dformat(format_base_flags[i].id), format_base_flags[i].id);
 979             HeapFree(GetProcessHeap(), 0, gl_info->formats);
 980             return FALSE;
 981         }
 982
 983         gl_info->formats[fmt_idx].flags |= format_base_flags[i].flags;
 984     }
 985
 986     return TRUE;
 987 }
 988
 989 static BOOL init_format_block_info(struct wined3d_gl_info *gl_info)
 990 {
 991     unsigned int i;
 992
 993     for (i = 0; i < (sizeof(format_block_info) / sizeof(*format_block_info)); ++i)
 994     {
 995         struct wined3d_format *format;
 996         int fmt_idx = getFmtIdx(format_block_info[i].id);
 997
 998         if (fmt_idx == -1)
 999         {
1000             ERR("Format %s (%#x) not found.\n",
1001                     debug_d3dformat(format_block_info[i].id), format_block_info[i].id);
1002             return FALSE;
1003         }
1004
1005         format = &gl_info->formats[fmt_idx];
1006         format->block_width = format_block_info[i].block_width;
1007         format->block_height = format_block_info[i].block_height;
1008         format->block_byte_count = format_block_info[i].block_byte_count;
1009         format->flags |= WINED3DFMT_FLAG_BLOCKS;
1010     }
1011
1012     return TRUE;
1013 }
1014
1015 /* Context activation is done by the caller. */
1016 static void check_fbo_compat(const struct wined3d_gl_info *gl_info, struct wined3d_format *format)
1017 {
1018     /* Check if the default internal format is supported as a frame buffer
1019      * target, otherwise fall back to the render target internal.
1020      *
1021      * Try to stick to the standard format if possible, this limits precision differences. */
1022     GLenum status;
1023     GLuint tex;
1024
1025     while (gl_info->gl_ops.gl.p_glGetError());
1026     gl_info->gl_ops.gl.p_glDisable(GL_BLEND);
1027
1028     gl_info->gl_ops.gl.p_glGenTextures(1, &tex);
1029     gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, tex);
1030
1031     gl_info->gl_ops.gl.p_glTexImage2D(GL_TEXTURE_2D, 0, format->glInternal, 16, 16, 0,
1032             format->glFormat, format->glType, NULL);
1033     gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1034     gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1035
1036     gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0);
1037
1038     status = gl_info->fbo_ops.glCheckFramebufferStatus(GL_FRAMEBUFFER);
1039     checkGLcall("Framebuffer format check");
1040
1041     if (status == GL_FRAMEBUFFER_COMPLETE)
1042     {
1043         TRACE("Format %s is supported as FBO color attachment.\n", debug_d3dformat(format->id));
1044         format->flags |= WINED3DFMT_FLAG_FBO_ATTACHABLE;
1045         format->rtInternal = format->glInternal;
1046     }
1047     else
1048     {
1049         if (!format->rtInternal)
1050         {
1051             if (format->flags & WINED3DFMT_FLAG_RENDERTARGET)
1052             {
1053                 FIXME("Format %s with rendertarget flag is not supported as FBO color attachment,"
1054                         " and no fallback specified.\n", debug_d3dformat(format->id));
1055                 format->flags &= ~WINED3DFMT_FLAG_RENDERTARGET;
1056             }
1057             else
1058             {
1059                 TRACE("Format %s is not supported as FBO color attachment.\n", debug_d3dformat(format->id));
1060             }
1061             format->rtInternal = format->glInternal;
1062         }
1063         else
1064         {
1065             TRACE("Format %s is not supported as FBO color attachment, trying rtInternal format as fallback.\n",
1066                     debug_d3dformat(format->id));
1067
1068             while (gl_info->gl_ops.gl.p_glGetError());
1069
1070             gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
1071
1072             gl_info->gl_ops.gl.p_glTexImage2D(GL_TEXTURE_2D, 0, format->rtInternal, 16, 16, 0,
1073                     format->glFormat, format->glType, NULL);
1074             gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1075             gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1076
1077             gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0);
1078
1079             status = gl_info->fbo_ops.glCheckFramebufferStatus(GL_FRAMEBUFFER);
1080             checkGLcall("Framebuffer format check");
1081
1082             if (status == GL_FRAMEBUFFER_COMPLETE)
1083             {
1084                 TRACE("Format %s rtInternal format is supported as FBO color attachment.\n",
1085                         debug_d3dformat(format->id));
1086             }
1087             else
1088             {
1089                 FIXME("Format %s rtInternal format is not supported as FBO color attachment.\n",
1090                         debug_d3dformat(format->id));
1091                 format->flags &= ~WINED3DFMT_FLAG_RENDERTARGET;
1092             }
1093         }
1094     }
1095
1096     if (status == GL_FRAMEBUFFER_COMPLETE && ((format->flags & WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING)
1097             || !(gl_info->quirks & WINED3D_QUIRK_LIMITED_TEX_FILTERING))
1098             && format->id != WINED3DFMT_NULL && format->id != WINED3DFMT_P8_UINT
1099             && format->glFormat != GL_LUMINANCE && format->glFormat != GL_LUMINANCE_ALPHA
1100             && (format->red_size || format->alpha_size))
1101     {
1102         DWORD readback[16 * 16], color, r_range, a_range;
1103         BYTE r, a;
1104         BOOL match = TRUE;
1105         GLuint rb;
1106
1107         if (gl_info->supported[ARB_FRAMEBUFFER_OBJECT]
1108                 || gl_info->supported[EXT_PACKED_DEPTH_STENCIL])
1109         {
1110             gl_info->fbo_ops.glGenRenderbuffers(1, &rb);
1111             gl_info->fbo_ops.glBindRenderbuffer(GL_RENDERBUFFER, rb);
1112             gl_info->fbo_ops.glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, 16, 16);
1113             gl_info->fbo_ops.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rb);
1114             gl_info->fbo_ops.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, rb);
1115             checkGLcall("RB attachment");
1116         }
1117
1118         gl_info->gl_ops.gl.p_glEnable(GL_BLEND);
1119         gl_info->gl_ops.gl.p_glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
1120         gl_info->gl_ops.gl.p_glClear(GL_COLOR_BUFFER_BIT);
1121         if (gl_info->gl_ops.gl.p_glGetError() == GL_INVALID_FRAMEBUFFER_OPERATION)
1122         {
1123             while (gl_info->gl_ops.gl.p_glGetError());
1124             TRACE("Format doesn't support post-pixelshader blending.\n");
1125             format->flags &= ~WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING;
1126         }
1127         else
1128         {
1129             gl_info->gl_ops.gl.p_glDisable(GL_BLEND);
1130             gl_info->gl_ops.gl.p_glViewport(0, 0, 16, 16);
1131             gl_info->gl_ops.gl.p_glDisable(GL_LIGHTING);
1132             gl_info->gl_ops.gl.p_glMatrixMode(GL_MODELVIEW);
1133             gl_info->gl_ops.gl.p_glLoadIdentity();
1134             gl_info->gl_ops.gl.p_glMatrixMode(GL_PROJECTION);
1135             gl_info->gl_ops.gl.p_glLoadIdentity();
1136
1137             gl_info->gl_ops.gl.p_glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1138
1139             /* Draw a full-black quad */
1140             gl_info->gl_ops.gl.p_glBegin(GL_TRIANGLE_STRIP);
1141             gl_info->gl_ops.gl.p_glColor4f(0.0f, 0.0f, 0.0f, 1.0f);
1142             gl_info->gl_ops.gl.p_glVertex3f(-1.0f, -1.0f, 0.0f);
1143             gl_info->gl_ops.gl.p_glVertex3f(1.0f, -1.0f, 0.0f);
1144             gl_info->gl_ops.gl.p_glVertex3f(-1.0f, 1.0f, 0.0f);
1145             gl_info->gl_ops.gl.p_glVertex3f(1.0f, 1.0f, 0.0f);
1146             gl_info->gl_ops.gl.p_glEnd();
1147
1148             gl_info->gl_ops.gl.p_glEnable(GL_BLEND);
1149             /* Draw a half-transparent red quad */
1150             gl_info->gl_ops.gl.p_glBegin(GL_TRIANGLE_STRIP);
1151             gl_info->gl_ops.gl.p_glColor4f(1.0f, 0.0f, 0.0f, 0.5f);
1152             gl_info->gl_ops.gl.p_glVertex3f(-1.0f, -1.0f, 0.0f);
1153             gl_info->gl_ops.gl.p_glVertex3f(1.0f, -1.0f, 0.0f);
1154             gl_info->gl_ops.gl.p_glVertex3f(-1.0f, 1.0f, 0.0f);
1155             gl_info->gl_ops.gl.p_glVertex3f(1.0f, 1.0f, 0.0f);
1156             gl_info->gl_ops.gl.p_glEnd();
1157
1158             gl_info->gl_ops.gl.p_glDisable(GL_BLEND);
1159
1160             /* Rebinding texture to workaround a fglrx bug. */
1161             gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, tex);
1162             gl_info->gl_ops.gl.p_glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, readback);
1163             checkGLcall("Post-pixelshader blending check");
1164
1165             color = readback[7 * 16 + 7];
1166             a = color >> 24;
1167             r = (color & 0x00ff0000) >> 16;
1168
1169             r_range = format->red_size < 8 ? 1 << (8 - format->red_size) : 1;
1170             a_range = format->alpha_size < 8 ? 1 << (8 - format->alpha_size) : 1;
1171             if (format->red_size && (r < 0x7f - r_range || r > 0x7f + r_range))
1172                 match = FALSE;
1173             else if (format->alpha_size > 1 && (a < 0xbf - a_range || a > 0xbf + a_range))
1174                 match = FALSE;
1175             if (!match)
1176             {
1177                 TRACE("Format doesn't support post-pixelshader blending.\n");
1178                 TRACE("Color output: %#x\n", color);
1179                 format->flags &= ~WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING;
1180             }
1181             else
1182             {
1183                 TRACE("Format supports post-pixelshader blending.\n");
1184                 TRACE("Color output: %#x\n", color);
1185                 format->flags |= WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING;
1186             }
1187         }
1188
1189         if (gl_info->supported[ARB_FRAMEBUFFER_OBJECT]
1190                 || gl_info->supported[EXT_PACKED_DEPTH_STENCIL])
1191         {
1192             gl_info->fbo_ops.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, 0);
1193             gl_info->fbo_ops.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, 0);
1194             gl_info->fbo_ops.glDeleteRenderbuffers(1, &rb);
1195             checkGLcall("RB cleanup");
1196         }
1197     }
1198
1199     if (format->glInternal != format->glGammaInternal)
1200     {
1201         gl_info->gl_ops.gl.p_glTexImage2D(GL_TEXTURE_2D, 0, format->glGammaInternal, 16, 16, 0,
1202                 format->glFormat, format->glType, NULL);
1203         gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0);
1204
1205         status = gl_info->fbo_ops.glCheckFramebufferStatus(GL_FRAMEBUFFER);
1206         checkGLcall("Framebuffer format check");
1207
1208         if (status == GL_FRAMEBUFFER_COMPLETE)
1209         {
1210             TRACE("Format %s's sRGB format is FBO attachable.\n", debug_d3dformat(format->id));
1211             format->flags |= WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB;
1212         }
1213         else
1214         {
1215             WARN("Format %s's sRGB format is not FBO attachable.\n", debug_d3dformat(format->id));
1216         }
1217     }
1218     else if (status == GL_FRAMEBUFFER_COMPLETE)
1219         format->flags |= WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB;
1220
1221     gl_info->gl_ops.gl.p_glDeleteTextures(1, &tex);
1222 }
1223
1224 static void query_format_flag(struct wined3d_gl_info *gl_info, struct wined3d_format *format,
1225         GLint internal, GLenum pname, DWORD flag, const char *string)
1226 {
1227     GLint value;
1228
1229     gl_info->gl_ops.ext.p_glGetInternalformativ(GL_TEXTURE_2D, internal, pname, 1, &value);
1230     if (value == GL_FULL_SUPPORT)
1231     {
1232         TRACE("Format %s supports %s.\n", debug_d3dformat(format->id), string);
1233         format->flags |= flag;
1234     }
1235     else
1236     {
1237         TRACE("Format %s doesn't support %s.\n", debug_d3dformat(format->id), string);
1238         format->flags &= ~flag;
1239     }
1240 }
1241
1242 /* Context activation is done by the caller. */
1243 static void init_format_fbo_compat_info(struct wined3d_gl_info *gl_info)
1244 {
1245     unsigned int i;
1246     GLuint fbo;
1247
1248     if (gl_info->supported[ARB_INTERNALFORMAT_QUERY2])
1249     {
1250         for (i = 0; i < sizeof(formats) / sizeof(*formats); ++i)
1251         {
1252             GLint value;
1253             struct wined3d_format *format = &gl_info->formats[i];
1254
1255             if (!format->glInternal)
1256                 continue;
1257             if (format->flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL))
1258                 continue;
1259
1260             gl_info->gl_ops.ext.p_glGetInternalformativ(GL_TEXTURE_2D, format->glInternal,
1261                     GL_FRAMEBUFFER_RENDERABLE, 1, &value);
1262             if (value == GL_FULL_SUPPORT)
1263             {
1264                 TRACE("Format %s is supported as FBO color attachment.\n", debug_d3dformat(format->id));
1265                 format->flags |= WINED3DFMT_FLAG_FBO_ATTACHABLE;
1266                 format->rtInternal = format->glInternal;
1267
1268                 query_format_flag(gl_info, format, format->glInternal, GL_FRAMEBUFFER_BLEND,
1269                         WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING, "post-pixelshader blending");
1270             }
1271             else
1272             {
1273                 if (!format->rtInternal)
1274                 {
1275                     if (format->flags & WINED3DFMT_FLAG_RENDERTARGET)
1276                     {
1277                         WARN("Format %s with rendertarget flag is not supported as FBO color attachment"
1278                                 " and no fallback specified.\n", debug_d3dformat(format->id));
1279                         format->flags &= ~WINED3DFMT_FLAG_RENDERTARGET;
1280                     }
1281                     else
1282                         TRACE("Format %s is not supported as FBO color attachment.\n", debug_d3dformat(format->id));
1283                     format->rtInternal = format->glInternal;
1284                 }
1285                 else
1286                 {
1287                     gl_info->gl_ops.ext.p_glGetInternalformativ(GL_TEXTURE_2D, format->rtInternal,
1288                             GL_FRAMEBUFFER_RENDERABLE, 1, &value);
1289                     if (value == GL_FULL_SUPPORT)
1290                     {
1291                         TRACE("Format %s rtInternal format is supported as FBO color attachment.\n",
1292                                 debug_d3dformat(format->id));
1293                     }
1294                     else
1295                     {
1296                         WARN("Format %s rtInternal format is not supported as FBO color attachment.\n",
1297                                 debug_d3dformat(format->id));
1298                         format->flags &= ~WINED3DFMT_FLAG_RENDERTARGET;
1299                     }
1300                 }
1301             }
1302
1303             if (format->glInternal != format->glGammaInternal)
1304             {
1305                 gl_info->gl_ops.ext.p_glGetInternalformativ(GL_TEXTURE_2D, format->glGammaInternal,
1306                         GL_FRAMEBUFFER_RENDERABLE, 1, &value);
1307                 if (value == GL_FULL_SUPPORT)
1308                 {
1309                     TRACE("Format %s's sRGB format is FBO attachable.\n", debug_d3dformat(format->id));
1310                     format->flags |= WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB;
1311                 }
1312                 else
1313                 {
1314                     WARN("Format %s's sRGB format is not FBO attachable.\n", debug_d3dformat(format->id));
1315                 }
1316             }
1317             else if (format->flags & WINED3DFMT_FLAG_FBO_ATTACHABLE)
1318                 format->flags |= WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB;
1319         }
1320         return;
1321     }
1322
1323     if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
1324     {
1325         gl_info->fbo_ops.glGenFramebuffers(1, &fbo);
1326         gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
1327         gl_info->gl_ops.gl.p_glDrawBuffer(GL_COLOR_ATTACHMENT0);
1328         gl_info->gl_ops.gl.p_glReadBuffer(GL_COLOR_ATTACHMENT0);
1329     }
1330
1331     for (i = 0; i < sizeof(formats) / sizeof(*formats); ++i)
1332     {
1333         struct wined3d_format *format = &gl_info->formats[i];
1334
1335         if (!format->glInternal) continue;
1336
1337         if (format->flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL))
1338         {
1339             TRACE("Skipping format %s because it's a depth/stencil format.\n",
1340                     debug_d3dformat(format->id));
1341             continue;
1342         }
1343
1344         if (format->flags & WINED3DFMT_FLAG_COMPRESSED)
1345         {
1346             TRACE("Skipping format %s because it's a compressed format.\n",
1347                     debug_d3dformat(format->id));
1348             continue;
1349         }
1350
1351         if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
1352         {
1353             TRACE("Checking if format %s is supported as FBO color attachment...\n", debug_d3dformat(format->id));
1354             check_fbo_compat(gl_info, format);
1355         }
1356         else
1357         {
1358             format->rtInternal = format->glInternal;
1359         }
1360     }
1361
1362     if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
1363         gl_info->fbo_ops.glDeleteFramebuffers(1, &fbo);
1364 }
1365
1366 static BOOL init_format_texture_info(struct wined3d_adapter *adapter, struct wined3d_gl_info *gl_info)
1367 {
1368     struct fragment_caps fragment_caps;
1369     struct shader_caps shader_caps;
1370     BOOL srgb_write;
1371     unsigned int i;
1372
1373     adapter->fragment_pipe->get_caps(gl_info, &fragment_caps);
1374     adapter->shader_backend->shader_get_caps(gl_info, &shader_caps);
1375     srgb_write = (fragment_caps.wined3d_caps & WINED3D_FRAGMENT_CAP_SRGB_WRITE)
1376             && (shader_caps.wined3d_caps & WINED3D_SHADER_CAP_SRGB_WRITE);
1377
1378     for (i = 0; i < sizeof(format_texture_info) / sizeof(*format_texture_info); ++i)
1379     {
1380         int fmt_idx = getFmtIdx(format_texture_info[i].id);
1381         struct wined3d_format *format;
1382
1383         if (fmt_idx == -1)
1384         {
1385             ERR("Format %s (%#x) not found.\n",
1386                     debug_d3dformat(format_texture_info[i].id), format_texture_info[i].id);
1387             return FALSE;
1388         }
1389
1390         if (!gl_info->supported[format_texture_info[i].extension]) continue;
1391
1392         format = &gl_info->formats[fmt_idx];
1393
1394         /* ARB_texture_rg defines floating point formats, but only if
1395          * ARB_texture_float is also supported. */
1396         if (!gl_info->supported[ARB_TEXTURE_FLOAT]
1397                 && (format->flags & WINED3DFMT_FLAG_FLOAT))
1398             continue;
1399
1400         format->glInternal = format_texture_info[i].gl_internal;
1401         format->glGammaInternal = format_texture_info[i].gl_srgb_internal;
1402         format->rtInternal = format_texture_info[i].gl_rt_internal;
1403         format->glFormat = format_texture_info[i].gl_format;
1404         format->glType = format_texture_info[i].gl_type;
1405         format->color_fixup = COLOR_FIXUP_IDENTITY;
1406         format->flags |= format_texture_info[i].flags;
1407         format->height_scale.numerator = 1;
1408         format->height_scale.denominator = 1;
1409
1410         if (gl_info->supported[ARB_INTERNALFORMAT_QUERY2])
1411         {
1412             query_format_flag(gl_info, format, format->glInternal, GL_VERTEX_TEXTURE,
1413                     WINED3DFMT_FLAG_VTF, "vertex texture usage");
1414             query_format_flag(gl_info, format, format->glInternal, GL_FILTER,
1415                     WINED3DFMT_FLAG_FILTERING, "filtering");
1416
1417             if (format->glGammaInternal != format->glInternal)
1418             {
1419                 query_format_flag(gl_info, format, format->glGammaInternal, GL_SRGB_READ,
1420                         WINED3DFMT_FLAG_SRGB_READ, "sRGB read");
1421
1422                 if (srgb_write)
1423                     query_format_flag(gl_info, format, format->glGammaInternal, GL_SRGB_WRITE,
1424                             WINED3DFMT_FLAG_SRGB_WRITE, "sRGB write");
1425                 else
1426                     format->flags &= ~WINED3DFMT_FLAG_SRGB_WRITE;
1427
1428                 if (!(format->flags & (WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_SRGB_WRITE)))
1429                     format->glGammaInternal = format->glInternal;
1430                 else if (gl_info->supported[EXT_TEXTURE_SRGB_DECODE])
1431                     format->glInternal = format->glGammaInternal;
1432             }
1433         }
1434         else
1435         {
1436             if (!gl_info->limits.vertex_samplers)
1437                 format->flags &= ~WINED3DFMT_FLAG_VTF;
1438
1439             if (!(gl_info->quirks & WINED3D_QUIRK_LIMITED_TEX_FILTERING))
1440                 format->flags |= WINED3DFMT_FLAG_FILTERING;
1441             else if (format->id != WINED3DFMT_R32G32B32A32_FLOAT && format->id != WINED3DFMT_R32_FLOAT)
1442                 format->flags &= ~WINED3DFMT_FLAG_VTF;
1443
1444             if (format->glGammaInternal != format->glInternal)
1445             {
1446                 /* Filter sRGB capabilities if EXT_texture_sRGB is not supported. */
1447                 if (!gl_info->supported[EXT_TEXTURE_SRGB])
1448                 {
1449                     format->glGammaInternal = format->glInternal;
1450                     format->flags &= ~(WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_SRGB_WRITE);
1451                 }
1452                 else if (gl_info->supported[EXT_TEXTURE_SRGB_DECODE])
1453                 {
1454                     format->glInternal = format->glGammaInternal;
1455                 }
1456             }
1457
1458             if ((format->flags & WINED3DFMT_FLAG_SRGB_WRITE) && !srgb_write)
1459                 format->flags &= ~WINED3DFMT_FLAG_SRGB_WRITE;
1460         }
1461
1462         /* Texture conversion stuff */
1463         format->convert = format_texture_info[i].convert;
1464         format->conv_byte_count = format_texture_info[i].conv_byte_count;
1465     }
1466
1467     return TRUE;
1468 }
1469
1470 static BOOL color_match(DWORD c1, DWORD c2, BYTE max_diff)
1471 {
1472     if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
1473     c1 >>= 8; c2 >>= 8;
1474     if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
1475     c1 >>= 8; c2 >>= 8;
1476     if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
1477     c1 >>= 8; c2 >>= 8;
1478     if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
1479     return TRUE;
1480 }
1481
1482 /* A context is provided by the caller */
1483 static BOOL check_filter(const struct wined3d_gl_info *gl_info, GLenum internal)
1484 {
1485     static const DWORD data[] = {0x00000000, 0xffffffff};
1486     GLuint tex, fbo, buffer;
1487     DWORD readback[16 * 1];
1488     BOOL ret = FALSE;
1489
1490     /* Render a filtered texture and see what happens. This is intended to detect the lack of
1491      * float16 filtering on ATI X1000 class cards. The drivers disable filtering instead of
1492      * falling back to software. If this changes in the future this code will get fooled and
1493      * apps might hit the software path due to incorrectly advertised caps.
1494      *
1495      * Its unlikely that this changes however. GL Games like Mass Effect depend on the filter
1496      * disable fallback, if Apple or ATI ever change the driver behavior they will break more
1497      * than Wine. The Linux binary <= r500 driver is not maintained any more anyway
1498      */
1499
1500     while (gl_info->gl_ops.gl.p_glGetError());
1501
1502     gl_info->gl_ops.gl.p_glGenTextures(1, &buffer);
1503     gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, buffer);
1504     memset(readback, 0x7e, sizeof(readback));
1505     gl_info->gl_ops.gl.p_glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 16, 1, 0,
1506             GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, readback);
1507     gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1508     gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1509     gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
1510     gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1511     gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
1512
1513     gl_info->gl_ops.gl.p_glGenTextures(1, &tex);
1514     gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, tex);
1515     gl_info->gl_ops.gl.p_glTexImage2D(GL_TEXTURE_2D, 0, internal, 2, 1, 0,
1516             GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, data);
1517     gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1518     gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
1519     gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
1520     gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1521     gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
1522     gl_info->gl_ops.gl.p_glEnable(GL_TEXTURE_2D);
1523
1524     gl_info->fbo_ops.glGenFramebuffers(1, &fbo);
1525     gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
1526     gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, buffer, 0);
1527     gl_info->gl_ops.gl.p_glDrawBuffer(GL_COLOR_ATTACHMENT0);
1528
1529     gl_info->gl_ops.gl.p_glViewport(0, 0, 16, 1);
1530     gl_info->gl_ops.gl.p_glDisable(GL_LIGHTING);
1531     gl_info->gl_ops.gl.p_glMatrixMode(GL_MODELVIEW);
1532     gl_info->gl_ops.gl.p_glLoadIdentity();
1533     gl_info->gl_ops.gl.p_glMatrixMode(GL_PROJECTION);
1534     gl_info->gl_ops.gl.p_glLoadIdentity();
1535
1536     gl_info->gl_ops.gl.p_glClearColor(0, 1, 0, 0);
1537     gl_info->gl_ops.gl.p_glClear(GL_COLOR_BUFFER_BIT);
1538
1539     gl_info->gl_ops.gl.p_glBegin(GL_TRIANGLE_STRIP);
1540     gl_info->gl_ops.gl.p_glTexCoord2f(0.0, 0.0);
1541     gl_info->gl_ops.gl.p_glVertex2f(-1.0f, -1.0f);
1542     gl_info->gl_ops.gl.p_glTexCoord2f(1.0, 0.0);
1543     gl_info->gl_ops.gl.p_glVertex2f(1.0f, -1.0f);
1544     gl_info->gl_ops.gl.p_glTexCoord2f(0.0, 1.0);
1545     gl_info->gl_ops.gl.p_glVertex2f(-1.0f, 1.0f);
1546     gl_info->gl_ops.gl.p_glTexCoord2f(1.0, 1.0);
1547     gl_info->gl_ops.gl.p_glVertex2f(1.0f, 1.0f);
1548     gl_info->gl_ops.gl.p_glEnd();
1549
1550     gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, buffer);
1551     memset(readback, 0x7f, sizeof(readback));
1552     gl_info->gl_ops.gl.p_glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, readback);
1553     if (color_match(readback[6], 0xffffffff, 5) || color_match(readback[6], 0x00000000, 5)
1554             || color_match(readback[9], 0xffffffff, 5) || color_match(readback[9], 0x00000000, 5))
1555     {
1556         TRACE("Read back colors 0x%08x and 0x%08x close to unfiltered color, assuming no filtering\n",
1557               readback[6], readback[9]);
1558         ret = FALSE;
1559     }
1560     else
1561     {
1562         TRACE("Read back colors are 0x%08x and 0x%08x, assuming texture is filtered\n",
1563               readback[6], readback[9]);
1564         ret = TRUE;
1565     }
1566
1567     gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, 0);
1568     gl_info->fbo_ops.glDeleteFramebuffers(1, &fbo);
1569     gl_info->gl_ops.gl.p_glDeleteTextures(1, &tex);
1570     gl_info->gl_ops.gl.p_glDeleteTextures(1, &buffer);
1571
1572     if (gl_info->gl_ops.gl.p_glGetError())
1573     {
1574         FIXME("Error during filtering test for format %x, returning no filtering\n", internal);
1575         ret = FALSE;
1576     }
1577
1578     return ret;
1579 }
1580
1581 static void init_format_filter_info(struct wined3d_gl_info *gl_info, enum wined3d_pci_vendor vendor)
1582 {
1583     struct wined3d_format *format;
1584     unsigned int fmt_idx, i;
1585     static const enum wined3d_format_id fmts16[] =
1586     {
1587         WINED3DFMT_R16_FLOAT,
1588         WINED3DFMT_R16G16_FLOAT,
1589         WINED3DFMT_R16G16B16A16_FLOAT,
1590     };
1591     BOOL filtered;
1592
1593     if (gl_info->supported[ARB_INTERNALFORMAT_QUERY2])
1594         /* This was already handled by init_format_texture_info(). */
1595         return;
1596
1597     if(wined3d_settings.offscreen_rendering_mode != ORM_FBO)
1598     {
1599         WARN("No FBO support, or no FBO ORM, guessing filter info from GL caps\n");
1600         if (vendor == HW_VENDOR_NVIDIA && gl_info->supported[ARB_TEXTURE_FLOAT])
1601         {
1602             TRACE("Nvidia card with texture_float support: Assuming float16 blending\n");
1603             filtered = TRUE;
1604         }
1605         else if (gl_info->limits.glsl_varyings > 44)
1606         {
1607             TRACE("More than 44 GLSL varyings - assuming d3d10 card with float16 blending\n");
1608             filtered = TRUE;
1609         }
1610         else
1611         {
1612             TRACE("Assuming no float16 blending\n");
1613             filtered = FALSE;
1614         }
1615
1616         if(filtered)
1617         {
1618             for(i = 0; i < (sizeof(fmts16) / sizeof(*fmts16)); i++)
1619             {
1620                 fmt_idx = getFmtIdx(fmts16[i]);
1621                 gl_info->formats[fmt_idx].flags |= WINED3DFMT_FLAG_FILTERING;
1622             }
1623         }
1624         return;
1625     }
1626
1627     for(i = 0; i < (sizeof(fmts16) / sizeof(*fmts16)); i++)
1628     {
1629         fmt_idx = getFmtIdx(fmts16[i]);
1630         format = &gl_info->formats[fmt_idx];
1631         if (!format->glInternal) continue; /* Not supported by GL */
1632
1633         filtered = check_filter(gl_info, gl_info->formats[fmt_idx].glInternal);
1634         if(filtered)
1635         {
1636             TRACE("Format %s supports filtering\n", debug_d3dformat(fmts16[i]));
1637             format->flags |= WINED3DFMT_FLAG_FILTERING;
1638         }
1639         else
1640         {
1641             TRACE("Format %s does not support filtering\n", debug_d3dformat(fmts16[i]));
1642         }
1643     }
1644 }
1645
1646 static void apply_format_fixups(struct wined3d_adapter *adapter, struct wined3d_gl_info *gl_info)
1647 {
1648     unsigned int i;
1649     int idx;
1650
1651     idx = getFmtIdx(WINED3DFMT_R16_FLOAT);
1652     gl_info->formats[idx].color_fixup = create_color_fixup_desc(
1653             0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
1654
1655     idx = getFmtIdx(WINED3DFMT_R32_FLOAT);
1656     gl_info->formats[idx].color_fixup = create_color_fixup_desc(
1657             0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
1658
1659     idx = getFmtIdx(WINED3DFMT_R16G16_UNORM);
1660     gl_info->formats[idx].color_fixup = create_color_fixup_desc(
1661             0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
1662
1663     idx = getFmtIdx(WINED3DFMT_R16G16_FLOAT);
1664     gl_info->formats[idx].color_fixup = create_color_fixup_desc(
1665             0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
1666
1667     idx = getFmtIdx(WINED3DFMT_R32G32_FLOAT);
1668     gl_info->formats[idx].color_fixup = create_color_fixup_desc(
1669             0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
1670
1671     /* V8U8 is supported natively by GL_ATI_envmap_bumpmap and GL_NV_texture_shader.
1672      * V16U16 is only supported by GL_NV_texture_shader. The formats need fixup if
1673      * their extensions are not available. GL_ATI_envmap_bumpmap is not used because
1674      * the only driver that implements it(fglrx) has a buggy implementation.
1675      *
1676      * V8U8 and V16U16 need a fixup of the undefined blue channel. OpenGL
1677      * returns 0.0 when sampling from it, DirectX 1.0. So we always have in-shader
1678      * conversion for this format.
1679      */
1680     if (!gl_info->supported[NV_TEXTURE_SHADER])
1681     {
1682         idx = getFmtIdx(WINED3DFMT_R8G8_SNORM);
1683         gl_info->formats[idx].color_fixup = create_color_fixup_desc(
1684                 1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
1685         idx = getFmtIdx(WINED3DFMT_R16G16_SNORM);
1686         gl_info->formats[idx].color_fixup = create_color_fixup_desc(
1687                 1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
1688     }
1689     else
1690     {
1691         idx = getFmtIdx(WINED3DFMT_R8G8_SNORM);
1692         gl_info->formats[idx].color_fixup = create_color_fixup_desc(
1693                 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
1694
1695         idx = getFmtIdx(WINED3DFMT_R16G16_SNORM);
1696         gl_info->formats[idx].color_fixup = create_color_fixup_desc(
1697                 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
1698     }
1699
1700     if (!gl_info->supported[NV_TEXTURE_SHADER])
1701     {
1702         /* If GL_NV_texture_shader is not supported, those formats are converted, incompatibly
1703          * with each other
1704          */
1705         idx = getFmtIdx(WINED3DFMT_R5G5_SNORM_L6_UNORM);
1706         gl_info->formats[idx].color_fixup = create_color_fixup_desc(
1707                 1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Z, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE);
1708         idx = getFmtIdx(WINED3DFMT_R8G8_SNORM_L8X8_UNORM);
1709         gl_info->formats[idx].color_fixup = create_color_fixup_desc(
1710                 1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_Z, 0, CHANNEL_SOURCE_W);
1711         idx = getFmtIdx(WINED3DFMT_R8G8B8A8_SNORM);
1712         gl_info->formats[idx].color_fixup = create_color_fixup_desc(
1713                 1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Y, 1, CHANNEL_SOURCE_Z, 1, CHANNEL_SOURCE_W);
1714     }
1715     else
1716     {
1717         /* If GL_NV_texture_shader is supported, WINED3DFMT_L6V5U5 and WINED3DFMT_X8L8V8U8
1718          * are converted at surface loading time, but they do not need any modification in
1719          * the shader, thus they are compatible with all WINED3DFMT_UNKNOWN group formats.
1720          * WINED3DFMT_Q8W8V8U8 doesn't even need load-time conversion
1721          */
1722     }
1723
1724     if (gl_info->supported[EXT_TEXTURE_COMPRESSION_RGTC])
1725     {
1726         idx = getFmtIdx(WINED3DFMT_ATI2N);
1727         gl_info->formats[idx].color_fixup = create_color_fixup_desc(
1728                 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
1729     }
1730     else if (gl_info->supported[ATI_TEXTURE_COMPRESSION_3DC])
1731     {
1732         idx = getFmtIdx(WINED3DFMT_ATI2N);
1733         gl_info->formats[idx].color_fixup= create_color_fixup_desc(
1734                 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_W, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
1735     }
1736
1737     if (!gl_info->supported[APPLE_YCBCR_422])
1738     {
1739         idx = getFmtIdx(WINED3DFMT_YUY2);
1740         gl_info->formats[idx].color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_YUY2);
1741
1742         idx = getFmtIdx(WINED3DFMT_UYVY);
1743         gl_info->formats[idx].color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_UYVY);
1744     }
1745
1746     idx = getFmtIdx(WINED3DFMT_YV12);
1747     gl_info->formats[idx].flags |= WINED3DFMT_FLAG_HEIGHT_SCALE;
1748     gl_info->formats[idx].height_scale.numerator = 3;
1749     gl_info->formats[idx].height_scale.denominator = 2;
1750     gl_info->formats[idx].color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_YV12);
1751
1752     if (gl_info->supported[EXT_PALETTED_TEXTURE] || gl_info->supported[ARB_FRAGMENT_PROGRAM])
1753     {
1754         idx = getFmtIdx(WINED3DFMT_P8_UINT);
1755         gl_info->formats[idx].color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_P8);
1756     }
1757
1758     if (gl_info->supported[ARB_VERTEX_ARRAY_BGRA])
1759     {
1760         idx = getFmtIdx(WINED3DFMT_B8G8R8A8_UNORM);
1761         gl_info->formats[idx].gl_vtx_format = GL_BGRA;
1762     }
1763
1764     if (gl_info->supported[ARB_HALF_FLOAT_VERTEX])
1765     {
1766         /* Do not change the size of the type, it is CPU side. We have to change the GPU-side information though.
1767          * It is the job of the vertex buffer code to make sure that the vbos have the right format */
1768         idx = getFmtIdx(WINED3DFMT_R16G16_FLOAT);
1769         gl_info->formats[idx].gl_vtx_type = GL_HALF_FLOAT; /* == GL_HALF_FLOAT_NV */
1770
1771         idx = getFmtIdx(WINED3DFMT_R16G16B16A16_FLOAT);
1772         gl_info->formats[idx].gl_vtx_type = GL_HALF_FLOAT;
1773     }
1774
1775     if (!gl_info->supported[ARB_HALF_FLOAT_PIXEL])
1776     {
1777         idx = getFmtIdx(WINED3DFMT_R16_FLOAT);
1778         gl_info->formats[idx].flags &= ~WINED3DFMT_FLAG_TEXTURE;
1779
1780         idx = getFmtIdx(WINED3DFMT_R16G16_FLOAT);
1781         gl_info->formats[idx].flags &= ~WINED3DFMT_FLAG_TEXTURE;
1782
1783         idx = getFmtIdx(WINED3DFMT_R16G16B16A16_FLOAT);
1784         gl_info->formats[idx].flags &= ~WINED3DFMT_FLAG_TEXTURE;
1785     }
1786
1787     if (gl_info->quirks & WINED3D_QUIRK_BROKEN_RGBA16)
1788     {
1789         idx = getFmtIdx(WINED3DFMT_R16G16B16A16_UNORM);
1790         gl_info->formats[idx].flags &= ~WINED3DFMT_FLAG_TEXTURE;
1791     }
1792
1793     /* ATI instancing hack: Although ATI cards do not support Shader Model
1794      * 3.0, they support instancing. To query if the card supports instancing
1795      * CheckDeviceFormat() with the special format MAKEFOURCC('I','N','S','T')
1796      * is used. Should an application check for this, provide a proper return
1797      * value. We can do instancing with all shader versions, but we need
1798      * vertex shaders.
1799      *
1800      * Additionally applications have to set the D3DRS_POINTSIZE render state
1801      * to MAKEFOURCC('I','N','S','T') once to enable instancing. Wined3d
1802      * doesn't need that and just ignores it.
1803      *
1804      * With Shader Model 3.0 capable cards Instancing 'just works' in Windows. */
1805     /* FIXME: This should just check the shader backend caps. */
1806     if (gl_info->supported[ARB_VERTEX_PROGRAM] || gl_info->supported[ARB_VERTEX_SHADER])
1807     {
1808         idx = getFmtIdx(WINED3DFMT_INST);
1809         gl_info->formats[idx].flags |= WINED3DFMT_FLAG_TEXTURE;
1810     }
1811
1812     /* Depth bound test. To query if the card supports it CheckDeviceFormat()
1813      * with the special format MAKEFOURCC('N','V','D','B') is used. It is
1814      * enabled by setting D3DRS_ADAPTIVETESS_X render state to
1815      * MAKEFOURCC('N','V','D','B') and then controlled by setting
1816      * D3DRS_ADAPTIVETESS_Z (zMin) and D3DRS_ADAPTIVETESS_W (zMax) to test
1817      * value. */
1818     if (gl_info->supported[EXT_DEPTH_BOUNDS_TEST])
1819     {
1820         idx = getFmtIdx(WINED3DFMT_NVDB);
1821         gl_info->formats[idx].flags |= WINED3DFMT_FLAG_TEXTURE;
1822     }
1823
1824     /* RESZ aka AMD DX9-level hack for multisampled depth buffer resolve. You query for RESZ
1825      * support by checking for availability of MAKEFOURCC('R','E','S','Z') surfaces with
1826      * RENDERTARGET usage. */
1827     if (gl_info->supported[ARB_FRAMEBUFFER_OBJECT])
1828     {
1829         idx = getFmtIdx(WINED3DFMT_RESZ);
1830         gl_info->formats[idx].flags |= WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_RENDERTARGET;
1831     }
1832
1833     for (i = 0; i < sizeof(formats) / sizeof(*formats); ++i)
1834     {
1835         struct wined3d_format *format = &gl_info->formats[i];
1836
1837         if (!(format->flags & WINED3DFMT_FLAG_TEXTURE))
1838             continue;
1839
1840         if (!adapter->shader_backend->shader_color_fixup_supported(format->color_fixup)
1841                 || !adapter->fragment_pipe->color_fixup_supported(format->color_fixup))
1842             format->flags &= ~WINED3DFMT_FLAG_TEXTURE;
1843     }
1844 }
1845
1846 static BOOL init_format_vertex_info(struct wined3d_gl_info *gl_info)
1847 {
1848     unsigned int i;
1849
1850     for (i = 0; i < (sizeof(format_vertex_info) / sizeof(*format_vertex_info)); ++i)
1851     {
1852         struct wined3d_format *format;
1853         int fmt_idx = getFmtIdx(format_vertex_info[i].id);
1854
1855         if (fmt_idx == -1)
1856         {
1857             ERR("Format %s (%#x) not found.\n",
1858                     debug_d3dformat(format_vertex_info[i].id), format_vertex_info[i].id);
1859             return FALSE;
1860         }
1861
1862         format = &gl_info->formats[fmt_idx];
1863         format->emit_idx = format_vertex_info[i].emit_idx;
1864         format->component_count = format_vertex_info[i].component_count;
1865         format->gl_vtx_type = format_vertex_info[i].gl_vtx_type;
1866         format->gl_vtx_format = format_vertex_info[i].gl_vtx_format;
1867         format->gl_normalized = format_vertex_info[i].gl_normalized;
1868         format->component_size = format_vertex_info[i].component_size;
1869     }
1870
1871     return TRUE;
1872 }
1873
1874 BOOL initPixelFormatsNoGL(struct wined3d_gl_info *gl_info)
1875 {
1876     if (!init_format_base_info(gl_info)) return FALSE;
1877
1878     if (!init_format_block_info(gl_info))
1879     {
1880         HeapFree(GetProcessHeap(), 0, gl_info->formats);
1881         gl_info->formats = NULL;
1882         return FALSE;
1883     }
1884
1885     return TRUE;
1886 }
1887
1888 /* Context activation is done by the caller. */
1889 BOOL wined3d_adapter_init_format_info(struct wined3d_adapter *adapter)
1890 {
1891     struct wined3d_gl_info *gl_info = &adapter->gl_info;
1892
1893     if (!init_format_base_info(gl_info)) return FALSE;
1894
1895     if (!init_format_block_info(gl_info)) goto fail;
1896     if (!init_format_texture_info(adapter, gl_info)) goto fail;
1897     if (!init_format_vertex_info(gl_info)) goto fail;
1898
1899     apply_format_fixups(adapter, gl_info);
1900     init_format_fbo_compat_info(gl_info);
1901     init_format_filter_info(gl_info, adapter->driver_info.vendor);
1902
1903     return TRUE;
1904
1905 fail:
1906     HeapFree(GetProcessHeap(), 0, gl_info->formats);
1907     gl_info->formats = NULL;
1908     return FALSE;
1909 }
1910
1911 const struct wined3d_format *wined3d_get_format(const struct wined3d_gl_info *gl_info,
1912         enum wined3d_format_id format_id)
1913 {
1914     int idx = getFmtIdx(format_id);
1915
1916     if (idx == -1)
1917     {
1918         FIXME("Can't find format %s (%#x) in the format lookup table\n",
1919                 debug_d3dformat(format_id), format_id);
1920         /* Get the caller a valid pointer */
1921         idx = getFmtIdx(WINED3DFMT_UNKNOWN);
1922     }
1923
1924     return &gl_info->formats[idx];
1925 }
1926
1927 UINT wined3d_format_calculate_size(const struct wined3d_format *format, UINT alignment, UINT width, UINT height)
1928 {
1929     UINT size;
1930
1931     if (format->id == WINED3DFMT_UNKNOWN)
1932     {
1933         size = 0;
1934     }
1935     else if (format->flags & WINED3DFMT_FLAG_BLOCKS)
1936     {
1937         UINT row_block_count = (width + format->block_width - 1) / format->block_width;
1938         UINT row_count = (height + format->block_height - 1) / format->block_height;
1939         size = row_count * (((row_block_count * format->block_byte_count) + alignment - 1) & ~(alignment - 1));
1940     }
1941     else
1942     {
1943         size = height * (((width * format->byte_count) + alignment - 1) & ~(alignment - 1));
1944     }
1945
1946     if (format->flags & WINED3DFMT_FLAG_HEIGHT_SCALE)
1947     {
1948         /* The D3D format requirements make sure that the resulting format is an integer again */
1949         size *= format->height_scale.numerator;
1950         size /= format->height_scale.denominator;
1951     }
1952
1953     return size;
1954 }
1955
1956 /*****************************************************************************
1957  * Trace formatting of useful values
1958  */
1959 const char *debug_d3dformat(enum wined3d_format_id format_id)
1960 {
1961     switch (format_id)
1962     {
1963 #define FMT_TO_STR(format_id) case format_id: return #format_id
1964         FMT_TO_STR(WINED3DFMT_UNKNOWN);
1965         FMT_TO_STR(WINED3DFMT_B8G8R8_UNORM);
1966         FMT_TO_STR(WINED3DFMT_B5G5R5X1_UNORM);
1967         FMT_TO_STR(WINED3DFMT_B4G4R4A4_UNORM);
1968         FMT_TO_STR(WINED3DFMT_B2G3R3_UNORM);
1969         FMT_TO_STR(WINED3DFMT_B2G3R3A8_UNORM);
1970         FMT_TO_STR(WINED3DFMT_B4G4R4X4_UNORM);
1971         FMT_TO_STR(WINED3DFMT_R8G8B8X8_UNORM);
1972         FMT_TO_STR(WINED3DFMT_B10G10R10A2_UNORM);
1973         FMT_TO_STR(WINED3DFMT_P8_UINT_A8_UNORM);
1974         FMT_TO_STR(WINED3DFMT_P8_UINT);
1975         FMT_TO_STR(WINED3DFMT_L8_UNORM);
1976         FMT_TO_STR(WINED3DFMT_L8A8_UNORM);
1977         FMT_TO_STR(WINED3DFMT_L4A4_UNORM);
1978         FMT_TO_STR(WINED3DFMT_R5G5_SNORM_L6_UNORM);
1979         FMT_TO_STR(WINED3DFMT_R8G8_SNORM_L8X8_UNORM);
1980         FMT_TO_STR(WINED3DFMT_R10G11B11_SNORM);
1981         FMT_TO_STR(WINED3DFMT_R10G10B10_SNORM_A2_UNORM);
1982         FMT_TO_STR(WINED3DFMT_UYVY);
1983         FMT_TO_STR(WINED3DFMT_YUY2);
1984         FMT_TO_STR(WINED3DFMT_YV12);
1985         FMT_TO_STR(WINED3DFMT_DXT1);
1986         FMT_TO_STR(WINED3DFMT_DXT2);
1987         FMT_TO_STR(WINED3DFMT_DXT3);
1988         FMT_TO_STR(WINED3DFMT_DXT4);
1989         FMT_TO_STR(WINED3DFMT_DXT5);
1990         FMT_TO_STR(WINED3DFMT_MULTI2_ARGB8);
1991         FMT_TO_STR(WINED3DFMT_G8R8_G8B8);
1992         FMT_TO_STR(WINED3DFMT_R8G8_B8G8);
1993         FMT_TO_STR(WINED3DFMT_D16_LOCKABLE);
1994         FMT_TO_STR(WINED3DFMT_D32_UNORM);
1995         FMT_TO_STR(WINED3DFMT_S1_UINT_D15_UNORM);
1996         FMT_TO_STR(WINED3DFMT_X8D24_UNORM);
1997         FMT_TO_STR(WINED3DFMT_S4X4_UINT_D24_UNORM);
1998         FMT_TO_STR(WINED3DFMT_L16_UNORM);
1999         FMT_TO_STR(WINED3DFMT_S8_UINT_D24_FLOAT);
2000         FMT_TO_STR(WINED3DFMT_VERTEXDATA);
2001         FMT_TO_STR(WINED3DFMT_R8G8_SNORM_Cx);
2002         FMT_TO_STR(WINED3DFMT_ATI2N);
2003         FMT_TO_STR(WINED3DFMT_NVDB);
2004         FMT_TO_STR(WINED3DFMT_NVHU);
2005         FMT_TO_STR(WINED3DFMT_NVHS);
2006         FMT_TO_STR(WINED3DFMT_R32G32B32A32_TYPELESS);
2007         FMT_TO_STR(WINED3DFMT_R32G32B32A32_FLOAT);
2008         FMT_TO_STR(WINED3DFMT_R32G32B32A32_UINT);
2009         FMT_TO_STR(WINED3DFMT_R32G32B32A32_SINT);
2010         FMT_TO_STR(WINED3DFMT_R32G32B32_TYPELESS);
2011         FMT_TO_STR(WINED3DFMT_R32G32B32_FLOAT);
2012         FMT_TO_STR(WINED3DFMT_R32G32B32_UINT);
2013         FMT_TO_STR(WINED3DFMT_R32G32B32_SINT);
2014         FMT_TO_STR(WINED3DFMT_R16G16B16A16_TYPELESS);
2015         FMT_TO_STR(WINED3DFMT_R16G16B16A16_FLOAT);
2016         FMT_TO_STR(WINED3DFMT_R16G16B16A16_UNORM);
2017         FMT_TO_STR(WINED3DFMT_R16G16B16A16_UINT);
2018         FMT_TO_STR(WINED3DFMT_R16G16B16A16_SNORM);
2019         FMT_TO_STR(WINED3DFMT_R16G16B16A16_SINT);
2020         FMT_TO_STR(WINED3DFMT_R32G32_TYPELESS);
2021         FMT_TO_STR(WINED3DFMT_R32G32_FLOAT);
2022         FMT_TO_STR(WINED3DFMT_R32G32_UINT);
2023         FMT_TO_STR(WINED3DFMT_R32G32_SINT);
2024         FMT_TO_STR(WINED3DFMT_R32G8X24_TYPELESS);
2025         FMT_TO_STR(WINED3DFMT_D32_FLOAT_S8X24_UINT);
2026         FMT_TO_STR(WINED3DFMT_R32_FLOAT_X8X24_TYPELESS);
2027         FMT_TO_STR(WINED3DFMT_X32_TYPELESS_G8X24_UINT);
2028         FMT_TO_STR(WINED3DFMT_R10G10B10A2_TYPELESS);
2029         FMT_TO_STR(WINED3DFMT_R10G10B10A2_UNORM);
2030         FMT_TO_STR(WINED3DFMT_R10G10B10A2_UINT);
2031         FMT_TO_STR(WINED3DFMT_R10G10B10A2_SNORM);
2032         FMT_TO_STR(WINED3DFMT_R11G11B10_FLOAT);
2033         FMT_TO_STR(WINED3DFMT_R8G8B8A8_TYPELESS);
2034         FMT_TO_STR(WINED3DFMT_R8G8B8A8_UNORM);
2035         FMT_TO_STR(WINED3DFMT_R8G8B8A8_UNORM_SRGB);
2036         FMT_TO_STR(WINED3DFMT_R8G8B8A8_UINT);
2037         FMT_TO_STR(WINED3DFMT_R8G8B8A8_SNORM);
2038         FMT_TO_STR(WINED3DFMT_R8G8B8A8_SINT);
2039         FMT_TO_STR(WINED3DFMT_R16G16_TYPELESS);
2040         FMT_TO_STR(WINED3DFMT_R16G16_FLOAT);
2041         FMT_TO_STR(WINED3DFMT_R16G16_UNORM);
2042         FMT_TO_STR(WINED3DFMT_R16G16_UINT);
2043         FMT_TO_STR(WINED3DFMT_R16G16_SNORM);
2044         FMT_TO_STR(WINED3DFMT_R16G16_SINT);
2045         FMT_TO_STR(WINED3DFMT_R32_TYPELESS);
2046         FMT_TO_STR(WINED3DFMT_D32_FLOAT);
2047         FMT_TO_STR(WINED3DFMT_R32_FLOAT);
2048         FMT_TO_STR(WINED3DFMT_R32_UINT);
2049         FMT_TO_STR(WINED3DFMT_R32_SINT);
2050         FMT_TO_STR(WINED3DFMT_R24G8_TYPELESS);
2051         FMT_TO_STR(WINED3DFMT_D24_UNORM_S8_UINT);
2052         FMT_TO_STR(WINED3DFMT_R24_UNORM_X8_TYPELESS);
2053         FMT_TO_STR(WINED3DFMT_X24_TYPELESS_G8_UINT);
2054         FMT_TO_STR(WINED3DFMT_R8G8_TYPELESS);
2055         FMT_TO_STR(WINED3DFMT_R8G8_UNORM);
2056         FMT_TO_STR(WINED3DFMT_R8G8_UINT);
2057         FMT_TO_STR(WINED3DFMT_R8G8_SNORM);
2058         FMT_TO_STR(WINED3DFMT_R8G8_SINT);
2059         FMT_TO_STR(WINED3DFMT_R16_TYPELESS);
2060         FMT_TO_STR(WINED3DFMT_R16_FLOAT);
2061         FMT_TO_STR(WINED3DFMT_D16_UNORM);
2062         FMT_TO_STR(WINED3DFMT_R16_UNORM);
2063         FMT_TO_STR(WINED3DFMT_R16_UINT);
2064         FMT_TO_STR(WINED3DFMT_R16_SNORM);
2065         FMT_TO_STR(WINED3DFMT_R16_SINT);
2066         FMT_TO_STR(WINED3DFMT_R8_TYPELESS);
2067         FMT_TO_STR(WINED3DFMT_R8_UNORM);
2068         FMT_TO_STR(WINED3DFMT_R8_UINT);
2069         FMT_TO_STR(WINED3DFMT_R8_SNORM);
2070         FMT_TO_STR(WINED3DFMT_R8_SINT);
2071         FMT_TO_STR(WINED3DFMT_A8_UNORM);
2072         FMT_TO_STR(WINED3DFMT_R1_UNORM);
2073         FMT_TO_STR(WINED3DFMT_R9G9B9E5_SHAREDEXP);
2074         FMT_TO_STR(WINED3DFMT_R8G8_B8G8_UNORM);
2075         FMT_TO_STR(WINED3DFMT_G8R8_G8B8_UNORM);
2076         FMT_TO_STR(WINED3DFMT_BC1_TYPELESS);
2077         FMT_TO_STR(WINED3DFMT_BC1_UNORM);
2078         FMT_TO_STR(WINED3DFMT_BC1_UNORM_SRGB);
2079         FMT_TO_STR(WINED3DFMT_BC2_TYPELESS);
2080         FMT_TO_STR(WINED3DFMT_BC2_UNORM);
2081         FMT_TO_STR(WINED3DFMT_BC2_UNORM_SRGB);
2082         FMT_TO_STR(WINED3DFMT_BC3_TYPELESS);
2083         FMT_TO_STR(WINED3DFMT_BC3_UNORM);
2084         FMT_TO_STR(WINED3DFMT_BC3_UNORM_SRGB);
2085         FMT_TO_STR(WINED3DFMT_BC4_TYPELESS);
2086         FMT_TO_STR(WINED3DFMT_BC4_UNORM);
2087         FMT_TO_STR(WINED3DFMT_BC4_SNORM);
2088         FMT_TO_STR(WINED3DFMT_BC5_TYPELESS);
2089         FMT_TO_STR(WINED3DFMT_BC5_UNORM);
2090         FMT_TO_STR(WINED3DFMT_BC5_SNORM);
2091         FMT_TO_STR(WINED3DFMT_B5G6R5_UNORM);
2092         FMT_TO_STR(WINED3DFMT_B5G5R5A1_UNORM);
2093         FMT_TO_STR(WINED3DFMT_B8G8R8A8_UNORM);
2094         FMT_TO_STR(WINED3DFMT_B8G8R8X8_UNORM);
2095         FMT_TO_STR(WINED3DFMT_INTZ);
2096         FMT_TO_STR(WINED3DFMT_RESZ);
2097         FMT_TO_STR(WINED3DFMT_NULL);
2098         FMT_TO_STR(WINED3DFMT_R16);
2099         FMT_TO_STR(WINED3DFMT_AL16);
2100 #undef FMT_TO_STR
2101         default:
2102         {
2103             char fourcc[5];
2104             fourcc[0] = (char)(format_id);
2105             fourcc[1] = (char)(format_id >> 8);
2106             fourcc[2] = (char)(format_id >> 16);
2107             fourcc[3] = (char)(format_id >> 24);
2108             fourcc[4] = 0;
2109             if (isprint(fourcc[0]) && isprint(fourcc[1]) && isprint(fourcc[2]) && isprint(fourcc[3]))
2110                 FIXME("Unrecognized %#x (as fourcc: %s) WINED3DFORMAT!\n", format_id, fourcc);
2111             else
2112                 FIXME("Unrecognized %#x WINED3DFORMAT!\n", format_id);
2113         }
2114         return "unrecognized";
2115     }
2116 }
2117
2118 const char *debug_d3ddevicetype(enum wined3d_device_type device_type)
2119 {
2120     switch (device_type)
2121     {
2122 #define DEVTYPE_TO_STR(dev) case dev: return #dev
2123         DEVTYPE_TO_STR(WINED3D_DEVICE_TYPE_HAL);
2124         DEVTYPE_TO_STR(WINED3D_DEVICE_TYPE_REF);
2125         DEVTYPE_TO_STR(WINED3D_DEVICE_TYPE_SW);
2126 #undef DEVTYPE_TO_STR
2127         default:
2128             FIXME("Unrecognized device type %#x.\n", device_type);
2129             return "unrecognized";
2130     }
2131 }
2132
2133 const char *debug_d3dusage(DWORD usage)
2134 {
2135     char buf[333];
2136
2137     buf[0] = '\0';
2138 #define WINED3DUSAGE_TO_STR(u) if (usage & u) { strcat(buf, " | "#u); usage &= ~u; }
2139     WINED3DUSAGE_TO_STR(WINED3DUSAGE_RENDERTARGET);
2140     WINED3DUSAGE_TO_STR(WINED3DUSAGE_DEPTHSTENCIL);
2141     WINED3DUSAGE_TO_STR(WINED3DUSAGE_WRITEONLY);
2142     WINED3DUSAGE_TO_STR(WINED3DUSAGE_SOFTWAREPROCESSING);
2143     WINED3DUSAGE_TO_STR(WINED3DUSAGE_DONOTCLIP);
2144     WINED3DUSAGE_TO_STR(WINED3DUSAGE_POINTS);
2145     WINED3DUSAGE_TO_STR(WINED3DUSAGE_RTPATCHES);
2146     WINED3DUSAGE_TO_STR(WINED3DUSAGE_NPATCHES);
2147     WINED3DUSAGE_TO_STR(WINED3DUSAGE_DYNAMIC);
2148     WINED3DUSAGE_TO_STR(WINED3DUSAGE_AUTOGENMIPMAP);
2149     WINED3DUSAGE_TO_STR(WINED3DUSAGE_DMAP);
2150     WINED3DUSAGE_TO_STR(WINED3DUSAGE_STATICDECL);
2151     WINED3DUSAGE_TO_STR(WINED3DUSAGE_OVERLAY);
2152 #undef WINED3DUSAGE_TO_STR
2153     if (usage) FIXME("Unrecognized usage flag(s) %#x\n", usage);
2154
2155     return buf[0] ? wine_dbg_sprintf("%s", &buf[3]) : "0";
2156 }
2157
2158 const char *debug_d3dusagequery(DWORD usagequery)
2159 {
2160     char buf[238];
2161
2162     buf[0] = '\0';
2163 #define WINED3DUSAGEQUERY_TO_STR(u) if (usagequery & u) { strcat(buf, " | "#u); usagequery &= ~u; }
2164     WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_FILTER);
2165     WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_LEGACYBUMPMAP);
2166     WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING);
2167     WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_SRGBREAD);
2168     WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_SRGBWRITE);
2169     WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_VERTEXTEXTURE);
2170     WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_WRAPANDMIP);
2171 #undef WINED3DUSAGEQUERY_TO_STR
2172     if (usagequery) FIXME("Unrecognized usage query flag(s) %#x\n", usagequery);
2173
2174     return buf[0] ? wine_dbg_sprintf("%s", &buf[3]) : "0";
2175 }
2176
2177 const char *debug_d3ddeclmethod(enum wined3d_decl_method method)
2178 {
2179     switch (method)
2180     {
2181 #define WINED3DDECLMETHOD_TO_STR(u) case u: return #u
2182         WINED3DDECLMETHOD_TO_STR(WINED3D_DECL_METHOD_DEFAULT);
2183         WINED3DDECLMETHOD_TO_STR(WINED3D_DECL_METHOD_PARTIAL_U);
2184         WINED3DDECLMETHOD_TO_STR(WINED3D_DECL_METHOD_PARTIAL_V);
2185         WINED3DDECLMETHOD_TO_STR(WINED3D_DECL_METHOD_CROSS_UV);
2186         WINED3DDECLMETHOD_TO_STR(WINED3D_DECL_METHOD_UV);
2187         WINED3DDECLMETHOD_TO_STR(WINED3D_DECL_METHOD_LOOKUP);
2188         WINED3DDECLMETHOD_TO_STR(WINED3D_DECL_METHOD_LOOKUP_PRESAMPLED);
2189 #undef WINED3DDECLMETHOD_TO_STR
2190         default:
2191             FIXME("Unrecognized declaration method %#x.\n", method);
2192             return "unrecognized";
2193     }
2194 }
2195
2196 const char *debug_d3ddeclusage(enum wined3d_decl_usage usage)
2197 {
2198     switch (usage)
2199     {
2200 #define WINED3DDECLUSAGE_TO_STR(u) case u: return #u
2201         WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_POSITION);
2202         WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_BLEND_WEIGHT);
2203         WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_BLEND_INDICES);
2204         WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_NORMAL);
2205         WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_PSIZE);
2206         WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_TEXCOORD);
2207         WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_TANGENT);
2208         WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_BINORMAL);
2209         WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_TESS_FACTOR);
2210         WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_POSITIONT);
2211         WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_COLOR);
2212         WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_FOG);
2213         WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_DEPTH);
2214         WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_SAMPLE);
2215 #undef WINED3DDECLUSAGE_TO_STR
2216         default:
2217             FIXME("Unrecognized %u declaration usage!\n", usage);
2218             return "unrecognized";
2219     }
2220 }
2221
2222 const char *debug_d3dresourcetype(enum wined3d_resource_type resource_type)
2223 {
2224     switch (resource_type)
2225     {
2226 #define RES_TO_STR(res) case res: return #res
2227         RES_TO_STR(WINED3D_RTYPE_SURFACE);
2228         RES_TO_STR(WINED3D_RTYPE_VOLUME);
2229         RES_TO_STR(WINED3D_RTYPE_TEXTURE);
2230         RES_TO_STR(WINED3D_RTYPE_VOLUME_TEXTURE);
2231         RES_TO_STR(WINED3D_RTYPE_CUBE_TEXTURE);
2232         RES_TO_STR(WINED3D_RTYPE_BUFFER);
2233 #undef  RES_TO_STR
2234         default:
2235             FIXME("Unrecognized resource type %#x.\n", resource_type);
2236             return "unrecognized";
2237     }
2238 }
2239
2240 const char *debug_d3dprimitivetype(enum wined3d_primitive_type primitive_type)
2241 {
2242     switch (primitive_type)
2243     {
2244 #define PRIM_TO_STR(prim) case prim: return #prim
2245         PRIM_TO_STR(WINED3D_PT_UNDEFINED);
2246         PRIM_TO_STR(WINED3D_PT_POINTLIST);
2247         PRIM_TO_STR(WINED3D_PT_LINELIST);
2248         PRIM_TO_STR(WINED3D_PT_LINESTRIP);
2249         PRIM_TO_STR(WINED3D_PT_TRIANGLELIST);
2250         PRIM_TO_STR(WINED3D_PT_TRIANGLESTRIP);
2251         PRIM_TO_STR(WINED3D_PT_TRIANGLEFAN);
2252         PRIM_TO_STR(WINED3D_PT_LINELIST_ADJ);
2253         PRIM_TO_STR(WINED3D_PT_LINESTRIP_ADJ);
2254         PRIM_TO_STR(WINED3D_PT_TRIANGLELIST_ADJ);
2255         PRIM_TO_STR(WINED3D_PT_TRIANGLESTRIP_ADJ);
2256 #undef  PRIM_TO_STR
2257         default:
2258             FIXME("Unrecognized %u primitive type!\n", primitive_type);
2259             return "unrecognized";
2260     }
2261 }
2262
2263 const char *debug_d3drenderstate(enum wined3d_render_state state)
2264 {
2265     switch (state)
2266     {
2267 #define D3DSTATE_TO_STR(u) case u: return #u
2268         D3DSTATE_TO_STR(WINED3D_RS_ANTIALIAS);
2269         D3DSTATE_TO_STR(WINED3D_RS_TEXTUREPERSPECTIVE);
2270         D3DSTATE_TO_STR(WINED3D_RS_WRAPU);
2271         D3DSTATE_TO_STR(WINED3D_RS_WRAPV);
2272         D3DSTATE_TO_STR(WINED3D_RS_ZENABLE);
2273         D3DSTATE_TO_STR(WINED3D_RS_FILLMODE);
2274         D3DSTATE_TO_STR(WINED3D_RS_SHADEMODE);
2275         D3DSTATE_TO_STR(WINED3D_RS_LINEPATTERN);
2276         D3DSTATE_TO_STR(WINED3D_RS_MONOENABLE);
2277         D3DSTATE_TO_STR(WINED3D_RS_ROP2);
2278         D3DSTATE_TO_STR(WINED3D_RS_PLANEMASK);
2279         D3DSTATE_TO_STR(WINED3D_RS_ZWRITEENABLE);
2280         D3DSTATE_TO_STR(WINED3D_RS_ALPHATESTENABLE);
2281         D3DSTATE_TO_STR(WINED3D_RS_LASTPIXEL);
2282         D3DSTATE_TO_STR(WINED3D_RS_SRCBLEND);
2283         D3DSTATE_TO_STR(WINED3D_RS_DESTBLEND);
2284         D3DSTATE_TO_STR(WINED3D_RS_CULLMODE);
2285         D3DSTATE_TO_STR(WINED3D_RS_ZFUNC);
2286         D3DSTATE_TO_STR(WINED3D_RS_ALPHAREF);
2287         D3DSTATE_TO_STR(WINED3D_RS_ALPHAFUNC);
2288         D3DSTATE_TO_STR(WINED3D_RS_DITHERENABLE);
2289         D3DSTATE_TO_STR(WINED3D_RS_ALPHABLENDENABLE);
2290         D3DSTATE_TO_STR(WINED3D_RS_FOGENABLE);
2291         D3DSTATE_TO_STR(WINED3D_RS_SPECULARENABLE);
2292         D3DSTATE_TO_STR(WINED3D_RS_ZVISIBLE);
2293         D3DSTATE_TO_STR(WINED3D_RS_SUBPIXEL);
2294         D3DSTATE_TO_STR(WINED3D_RS_SUBPIXELX);
2295         D3DSTATE_TO_STR(WINED3D_RS_STIPPLEDALPHA);
2296         D3DSTATE_TO_STR(WINED3D_RS_FOGCOLOR);
2297         D3DSTATE_TO_STR(WINED3D_RS_FOGTABLEMODE);
2298         D3DSTATE_TO_STR(WINED3D_RS_FOGSTART);
2299         D3DSTATE_TO_STR(WINED3D_RS_FOGEND);
2300         D3DSTATE_TO_STR(WINED3D_RS_FOGDENSITY);
2301         D3DSTATE_TO_STR(WINED3D_RS_STIPPLEENABLE);
2302         D3DSTATE_TO_STR(WINED3D_RS_EDGEANTIALIAS);
2303         D3DSTATE_TO_STR(WINED3D_RS_COLORKEYENABLE);
2304         D3DSTATE_TO_STR(WINED3D_RS_MIPMAPLODBIAS);
2305         D3DSTATE_TO_STR(WINED3D_RS_RANGEFOGENABLE);
2306         D3DSTATE_TO_STR(WINED3D_RS_ANISOTROPY);
2307         D3DSTATE_TO_STR(WINED3D_RS_FLUSHBATCH);
2308         D3DSTATE_TO_STR(WINED3D_RS_TRANSLUCENTSORTINDEPENDENT);
2309         D3DSTATE_TO_STR(WINED3D_RS_STENCILENABLE);
2310         D3DSTATE_TO_STR(WINED3D_RS_STENCILFAIL);
2311         D3DSTATE_TO_STR(WINED3D_RS_STENCILZFAIL);
2312         D3DSTATE_TO_STR(WINED3D_RS_STENCILPASS);
2313         D3DSTATE_TO_STR(WINED3D_RS_STENCILFUNC);
2314         D3DSTATE_TO_STR(WINED3D_RS_STENCILREF);
2315         D3DSTATE_TO_STR(WINED3D_RS_STENCILMASK);
2316         D3DSTATE_TO_STR(WINED3D_RS_STENCILWRITEMASK);
2317         D3DSTATE_TO_STR(WINED3D_RS_TEXTUREFACTOR);
2318         D3DSTATE_TO_STR(WINED3D_RS_WRAP0);
2319         D3DSTATE_TO_STR(WINED3D_RS_WRAP1);
2320         D3DSTATE_TO_STR(WINED3D_RS_WRAP2);
2321         D3DSTATE_TO_STR(WINED3D_RS_WRAP3);
2322         D3DSTATE_TO_STR(WINED3D_RS_WRAP4);
2323         D3DSTATE_TO_STR(WINED3D_RS_WRAP5);
2324         D3DSTATE_TO_STR(WINED3D_RS_WRAP6);
2325         D3DSTATE_TO_STR(WINED3D_RS_WRAP7);
2326         D3DSTATE_TO_STR(WINED3D_RS_CLIPPING);
2327         D3DSTATE_TO_STR(WINED3D_RS_LIGHTING);
2328         D3DSTATE_TO_STR(WINED3D_RS_EXTENTS);
2329         D3DSTATE_TO_STR(WINED3D_RS_AMBIENT);
2330         D3DSTATE_TO_STR(WINED3D_RS_FOGVERTEXMODE);
2331         D3DSTATE_TO_STR(WINED3D_RS_COLORVERTEX);
2332         D3DSTATE_TO_STR(WINED3D_RS_LOCALVIEWER);
2333         D3DSTATE_TO_STR(WINED3D_RS_NORMALIZENORMALS);
2334         D3DSTATE_TO_STR(WINED3D_RS_COLORKEYBLENDENABLE);
2335         D3DSTATE_TO_STR(WINED3D_RS_DIFFUSEMATERIALSOURCE);
2336         D3DSTATE_TO_STR(WINED3D_RS_SPECULARMATERIALSOURCE);
2337         D3DSTATE_TO_STR(WINED3D_RS_AMBIENTMATERIALSOURCE);
2338         D3DSTATE_TO_STR(WINED3D_RS_EMISSIVEMATERIALSOURCE);
2339         D3DSTATE_TO_STR(WINED3D_RS_VERTEXBLEND);
2340         D3DSTATE_TO_STR(WINED3D_RS_CLIPPLANEENABLE);
2341         D3DSTATE_TO_STR(WINED3D_RS_SOFTWAREVERTEXPROCESSING);
2342         D3DSTATE_TO_STR(WINED3D_RS_POINTSIZE);
2343         D3DSTATE_TO_STR(WINED3D_RS_POINTSIZE_MIN);
2344         D3DSTATE_TO_STR(WINED3D_RS_POINTSPRITEENABLE);
2345         D3DSTATE_TO_STR(WINED3D_RS_POINTSCALEENABLE);
2346         D3DSTATE_TO_STR(WINED3D_RS_POINTSCALE_A);
2347         D3DSTATE_TO_STR(WINED3D_RS_POINTSCALE_B);
2348         D3DSTATE_TO_STR(WINED3D_RS_POINTSCALE_C);
2349         D3DSTATE_TO_STR(WINED3D_RS_MULTISAMPLEANTIALIAS);
2350         D3DSTATE_TO_STR(WINED3D_RS_MULTISAMPLEMASK);
2351         D3DSTATE_TO_STR(WINED3D_RS_PATCHEDGESTYLE);
2352         D3DSTATE_TO_STR(WINED3D_RS_PATCHSEGMENTS);
2353         D3DSTATE_TO_STR(WINED3D_RS_DEBUGMONITORTOKEN);
2354         D3DSTATE_TO_STR(WINED3D_RS_POINTSIZE_MAX);
2355         D3DSTATE_TO_STR(WINED3D_RS_INDEXEDVERTEXBLENDENABLE);
2356         D3DSTATE_TO_STR(WINED3D_RS_COLORWRITEENABLE);
2357         D3DSTATE_TO_STR(WINED3D_RS_TWEENFACTOR);
2358         D3DSTATE_TO_STR(WINED3D_RS_BLENDOP);
2359         D3DSTATE_TO_STR(WINED3D_RS_POSITIONDEGREE);
2360         D3DSTATE_TO_STR(WINED3D_RS_NORMALDEGREE);
2361         D3DSTATE_TO_STR(WINED3D_RS_SCISSORTESTENABLE);
2362         D3DSTATE_TO_STR(WINED3D_RS_SLOPESCALEDEPTHBIAS);
2363         D3DSTATE_TO_STR(WINED3D_RS_ANTIALIASEDLINEENABLE);
2364         D3DSTATE_TO_STR(WINED3D_RS_MINTESSELLATIONLEVEL);
2365         D3DSTATE_TO_STR(WINED3D_RS_MAXTESSELLATIONLEVEL);
2366         D3DSTATE_TO_STR(WINED3D_RS_ADAPTIVETESS_X);
2367         D3DSTATE_TO_STR(WINED3D_RS_ADAPTIVETESS_Y);
2368         D3DSTATE_TO_STR(WINED3D_RS_ADAPTIVETESS_Z);
2369         D3DSTATE_TO_STR(WINED3D_RS_ADAPTIVETESS_W);
2370         D3DSTATE_TO_STR(WINED3D_RS_ENABLEADAPTIVETESSELLATION);
2371         D3DSTATE_TO_STR(WINED3D_RS_TWOSIDEDSTENCILMODE);
2372         D3DSTATE_TO_STR(WINED3D_RS_CCW_STENCILFAIL);
2373         D3DSTATE_TO_STR(WINED3D_RS_CCW_STENCILZFAIL);
2374         D3DSTATE_TO_STR(WINED3D_RS_CCW_STENCILPASS);
2375         D3DSTATE_TO_STR(WINED3D_RS_CCW_STENCILFUNC);
2376         D3DSTATE_TO_STR(WINED3D_RS_COLORWRITEENABLE1);
2377         D3DSTATE_TO_STR(WINED3D_RS_COLORWRITEENABLE2);
2378         D3DSTATE_TO_STR(WINED3D_RS_COLORWRITEENABLE3);
2379         D3DSTATE_TO_STR(WINED3D_RS_BLENDFACTOR);
2380         D3DSTATE_TO_STR(WINED3D_RS_SRGBWRITEENABLE);
2381         D3DSTATE_TO_STR(WINED3D_RS_DEPTHBIAS);
2382         D3DSTATE_TO_STR(WINED3D_RS_WRAP8);
2383         D3DSTATE_TO_STR(WINED3D_RS_WRAP9);
2384         D3DSTATE_TO_STR(WINED3D_RS_WRAP10);
2385         D3DSTATE_TO_STR(WINED3D_RS_WRAP11);
2386         D3DSTATE_TO_STR(WINED3D_RS_WRAP12);
2387         D3DSTATE_TO_STR(WINED3D_RS_WRAP13);
2388         D3DSTATE_TO_STR(WINED3D_RS_WRAP14);
2389         D3DSTATE_TO_STR(WINED3D_RS_WRAP15);
2390         D3DSTATE_TO_STR(WINED3D_RS_SEPARATEALPHABLENDENABLE);
2391         D3DSTATE_TO_STR(WINED3D_RS_SRCBLENDALPHA);
2392         D3DSTATE_TO_STR(WINED3D_RS_DESTBLENDALPHA);
2393         D3DSTATE_TO_STR(WINED3D_RS_BLENDOPALPHA);
2394 #undef D3DSTATE_TO_STR
2395         default:
2396             FIXME("Unrecognized %u render state!\n", state);
2397             return "unrecognized";
2398     }
2399 }
2400
2401 const char *debug_d3dsamplerstate(enum wined3d_sampler_state state)
2402 {
2403     switch (state)
2404     {
2405 #define D3DSTATE_TO_STR(u) case u: return #u
2406         D3DSTATE_TO_STR(WINED3D_SAMP_BORDER_COLOR);
2407         D3DSTATE_TO_STR(WINED3D_SAMP_ADDRESS_U);
2408         D3DSTATE_TO_STR(WINED3D_SAMP_ADDRESS_V);
2409         D3DSTATE_TO_STR(WINED3D_SAMP_ADDRESS_W);
2410         D3DSTATE_TO_STR(WINED3D_SAMP_MAG_FILTER);
2411         D3DSTATE_TO_STR(WINED3D_SAMP_MIN_FILTER);
2412         D3DSTATE_TO_STR(WINED3D_SAMP_MIP_FILTER);
2413         D3DSTATE_TO_STR(WINED3D_SAMP_MIPMAP_LOD_BIAS);
2414         D3DSTATE_TO_STR(WINED3D_SAMP_MAX_MIP_LEVEL);
2415         D3DSTATE_TO_STR(WINED3D_SAMP_MAX_ANISOTROPY);
2416         D3DSTATE_TO_STR(WINED3D_SAMP_SRGB_TEXTURE);
2417         D3DSTATE_TO_STR(WINED3D_SAMP_ELEMENT_INDEX);
2418         D3DSTATE_TO_STR(WINED3D_SAMP_DMAP_OFFSET);
2419 #undef D3DSTATE_TO_STR
2420         default:
2421             FIXME("Unrecognized %u sampler state!\n", state);
2422             return "unrecognized";
2423     }
2424 }
2425
2426 const char *debug_d3dtexturefiltertype(enum wined3d_texture_filter_type filter_type)
2427 {
2428     switch (filter_type)
2429     {
2430 #define D3DTEXTUREFILTERTYPE_TO_STR(u) case u: return #u
2431         D3DTEXTUREFILTERTYPE_TO_STR(WINED3D_TEXF_NONE);
2432         D3DTEXTUREFILTERTYPE_TO_STR(WINED3D_TEXF_POINT);
2433         D3DTEXTUREFILTERTYPE_TO_STR(WINED3D_TEXF_LINEAR);
2434         D3DTEXTUREFILTERTYPE_TO_STR(WINED3D_TEXF_ANISOTROPIC);
2435         D3DTEXTUREFILTERTYPE_TO_STR(WINED3D_TEXF_FLAT_CUBIC);
2436         D3DTEXTUREFILTERTYPE_TO_STR(WINED3D_TEXF_GAUSSIAN_CUBIC);
2437         D3DTEXTUREFILTERTYPE_TO_STR(WINED3D_TEXF_PYRAMIDAL_QUAD);
2438         D3DTEXTUREFILTERTYPE_TO_STR(WINED3D_TEXF_GAUSSIAN_QUAD);
2439 #undef D3DTEXTUREFILTERTYPE_TO_STR
2440         default:
2441             FIXME("Unrecognied texture filter type 0x%08x.\n", filter_type);
2442             return "unrecognized";
2443     }
2444 }
2445
2446 const char *debug_d3dtexturestate(enum wined3d_texture_stage_state state)
2447 {
2448     switch (state)
2449     {
2450 #define D3DSTATE_TO_STR(u) case u: return #u
2451         D3DSTATE_TO_STR(WINED3D_TSS_COLOR_OP);
2452         D3DSTATE_TO_STR(WINED3D_TSS_COLOR_ARG1);
2453         D3DSTATE_TO_STR(WINED3D_TSS_COLOR_ARG2);
2454         D3DSTATE_TO_STR(WINED3D_TSS_ALPHA_OP);
2455         D3DSTATE_TO_STR(WINED3D_TSS_ALPHA_ARG1);
2456         D3DSTATE_TO_STR(WINED3D_TSS_ALPHA_ARG2);
2457         D3DSTATE_TO_STR(WINED3D_TSS_BUMPENV_MAT00);
2458         D3DSTATE_TO_STR(WINED3D_TSS_BUMPENV_MAT01);
2459         D3DSTATE_TO_STR(WINED3D_TSS_BUMPENV_MAT10);
2460         D3DSTATE_TO_STR(WINED3D_TSS_BUMPENV_MAT11);
2461         D3DSTATE_TO_STR(WINED3D_TSS_TEXCOORD_INDEX);
2462         D3DSTATE_TO_STR(WINED3D_TSS_BUMPENV_LSCALE);
2463         D3DSTATE_TO_STR(WINED3D_TSS_BUMPENV_LOFFSET);
2464         D3DSTATE_TO_STR(WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS);
2465         D3DSTATE_TO_STR(WINED3D_TSS_COLOR_ARG0);
2466         D3DSTATE_TO_STR(WINED3D_TSS_ALPHA_ARG0);
2467         D3DSTATE_TO_STR(WINED3D_TSS_RESULT_ARG);
2468         D3DSTATE_TO_STR(WINED3D_TSS_CONSTANT);
2469 #undef D3DSTATE_TO_STR
2470         default:
2471             FIXME("Unrecognized %u texture state!\n", state);
2472             return "unrecognized";
2473     }
2474 }
2475
2476 const char *debug_d3dtop(enum wined3d_texture_op d3dtop)
2477 {
2478     switch (d3dtop)
2479     {
2480 #define D3DTOP_TO_STR(u) case u: return #u
2481         D3DTOP_TO_STR(WINED3D_TOP_DISABLE);
2482         D3DTOP_TO_STR(WINED3D_TOP_SELECT_ARG1);
2483         D3DTOP_TO_STR(WINED3D_TOP_SELECT_ARG2);
2484         D3DTOP_TO_STR(WINED3D_TOP_MODULATE);
2485         D3DTOP_TO_STR(WINED3D_TOP_MODULATE_2X);
2486         D3DTOP_TO_STR(WINED3D_TOP_MODULATE_4X);
2487         D3DTOP_TO_STR(WINED3D_TOP_ADD);
2488         D3DTOP_TO_STR(WINED3D_TOP_ADD_SIGNED);
2489         D3DTOP_TO_STR(WINED3D_TOP_ADD_SIGNED_2X);
2490         D3DTOP_TO_STR(WINED3D_TOP_SUBTRACT);
2491         D3DTOP_TO_STR(WINED3D_TOP_ADD_SMOOTH);
2492         D3DTOP_TO_STR(WINED3D_TOP_BLEND_DIFFUSE_ALPHA);
2493         D3DTOP_TO_STR(WINED3D_TOP_BLEND_TEXTURE_ALPHA);
2494         D3DTOP_TO_STR(WINED3D_TOP_BLEND_FACTOR_ALPHA);
2495         D3DTOP_TO_STR(WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM);
2496         D3DTOP_TO_STR(WINED3D_TOP_BLEND_CURRENT_ALPHA);
2497         D3DTOP_TO_STR(WINED3D_TOP_PREMODULATE);
2498         D3DTOP_TO_STR(WINED3D_TOP_MODULATE_ALPHA_ADD_COLOR);
2499         D3DTOP_TO_STR(WINED3D_TOP_MODULATE_COLOR_ADD_ALPHA);
2500         D3DTOP_TO_STR(WINED3D_TOP_MODULATE_INVALPHA_ADD_COLOR);
2501         D3DTOP_TO_STR(WINED3D_TOP_MODULATE_INVCOLOR_ADD_ALPHA);
2502         D3DTOP_TO_STR(WINED3D_TOP_BUMPENVMAP);
2503         D3DTOP_TO_STR(WINED3D_TOP_BUMPENVMAP_LUMINANCE);
2504         D3DTOP_TO_STR(WINED3D_TOP_DOTPRODUCT3);
2505         D3DTOP_TO_STR(WINED3D_TOP_MULTIPLY_ADD);
2506         D3DTOP_TO_STR(WINED3D_TOP_LERP);
2507 #undef D3DTOP_TO_STR
2508         default:
2509             FIXME("Unrecognized texture op %#x.\n", d3dtop);
2510             return "unrecognized";
2511     }
2512 }
2513
2514 const char *debug_d3dtstype(enum wined3d_transform_state tstype)
2515 {
2516     switch (tstype)
2517     {
2518 #define TSTYPE_TO_STR(tstype) case tstype: return #tstype
2519     TSTYPE_TO_STR(WINED3D_TS_VIEW);
2520     TSTYPE_TO_STR(WINED3D_TS_PROJECTION);
2521     TSTYPE_TO_STR(WINED3D_TS_TEXTURE0);
2522     TSTYPE_TO_STR(WINED3D_TS_TEXTURE1);
2523     TSTYPE_TO_STR(WINED3D_TS_TEXTURE2);
2524     TSTYPE_TO_STR(WINED3D_TS_TEXTURE3);
2525     TSTYPE_TO_STR(WINED3D_TS_TEXTURE4);
2526     TSTYPE_TO_STR(WINED3D_TS_TEXTURE5);
2527     TSTYPE_TO_STR(WINED3D_TS_TEXTURE6);
2528     TSTYPE_TO_STR(WINED3D_TS_TEXTURE7);
2529     TSTYPE_TO_STR(WINED3D_TS_WORLD_MATRIX(0));
2530 #undef TSTYPE_TO_STR
2531     default:
2532         if (tstype > 256 && tstype < 512)
2533         {
2534             FIXME("WINED3D_TS_WORLD_MATRIX(%u). 1..255 not currently supported.\n", tstype);
2535             return ("WINED3D_TS_WORLD_MATRIX > 0");
2536         }
2537         FIXME("Unrecognized transform state %#x.\n", tstype);
2538         return "unrecognized";
2539     }
2540 }
2541
2542 const char *debug_d3dstate(DWORD state)
2543 {
2544     if (STATE_IS_RENDER(state))
2545         return wine_dbg_sprintf("STATE_RENDER(%s)", debug_d3drenderstate(state - STATE_RENDER(0)));
2546     if (STATE_IS_TEXTURESTAGE(state))
2547     {
2548         DWORD texture_stage = (state - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1);
2549         DWORD texture_state = state - STATE_TEXTURESTAGE(texture_stage, 0);
2550         return wine_dbg_sprintf("STATE_TEXTURESTAGE(%#x, %s)",
2551                 texture_stage, debug_d3dtexturestate(texture_state));
2552     }
2553     if (STATE_IS_SAMPLER(state))
2554         return wine_dbg_sprintf("STATE_SAMPLER(%#x)", state - STATE_SAMPLER(0));
2555     if (STATE_IS_PIXELSHADER(state))
2556         return "STATE_PIXELSHADER";
2557     if (STATE_IS_TRANSFORM(state))
2558         return wine_dbg_sprintf("STATE_TRANSFORM(%s)", debug_d3dtstype(state - STATE_TRANSFORM(0)));
2559     if (STATE_IS_STREAMSRC(state))
2560         return "STATE_STREAMSRC";
2561     if (STATE_IS_INDEXBUFFER(state))
2562         return "STATE_INDEXBUFFER";
2563     if (STATE_IS_VDECL(state))
2564         return "STATE_VDECL";
2565     if (STATE_IS_VSHADER(state))
2566         return "STATE_VSHADER";
2567     if (STATE_IS_GEOMETRY_SHADER(state))
2568         return "STATE_GEOMETRY_SHADER";
2569     if (STATE_IS_VIEWPORT(state))
2570         return "STATE_VIEWPORT";
2571     if (STATE_IS_VERTEXSHADERCONSTANT(state))
2572         return "STATE_VERTEXSHADERCONSTANT";
2573     if (STATE_IS_PIXELSHADERCONSTANT(state))
2574         return "STATE_PIXELSHADERCONSTANT";
2575     if (STATE_IS_ACTIVELIGHT(state))
2576         return wine_dbg_sprintf("STATE_ACTIVELIGHT(%#x)", state - STATE_ACTIVELIGHT(0));
2577     if (STATE_IS_SCISSORRECT(state))
2578         return "STATE_SCISSORRECT";
2579     if (STATE_IS_CLIPPLANE(state))
2580         return wine_dbg_sprintf("STATE_CLIPPLANE(%#x)", state - STATE_CLIPPLANE(0));
2581     if (STATE_IS_MATERIAL(state))
2582         return "STATE_MATERIAL";
2583     if (STATE_IS_FRONTFACE(state))
2584         return "STATE_FRONTFACE";
2585     if (STATE_IS_POINTSPRITECOORDORIGIN(state))
2586         return "STATE_POINTSPRITECOORDORIGIN";
2587     if (STATE_IS_BASEVERTEXINDEX(state))
2588         return "STATE_BASEVERTEXINDEX";
2589     if (STATE_IS_FRAMEBUFFER(state))
2590         return "STATE_FRAMEBUFFER";
2591
2592     return wine_dbg_sprintf("UNKNOWN_STATE(%#x)", state);
2593 }
2594
2595 const char *debug_d3dpool(enum wined3d_pool pool)
2596 {
2597     switch (pool)
2598     {
2599 #define POOL_TO_STR(p) case p: return #p
2600         POOL_TO_STR(WINED3D_POOL_DEFAULT);
2601         POOL_TO_STR(WINED3D_POOL_MANAGED);
2602         POOL_TO_STR(WINED3D_POOL_SYSTEM_MEM);
2603         POOL_TO_STR(WINED3D_POOL_SCRATCH);
2604 #undef  POOL_TO_STR
2605         default:
2606             FIXME("Unrecognized pool %#x.\n", pool);
2607             return "unrecognized";
2608     }
2609 }
2610
2611 const char *debug_fbostatus(GLenum status) {
2612     switch(status) {
2613 #define FBOSTATUS_TO_STR(u) case u: return #u
2614         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_COMPLETE);
2615         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT);
2616         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT);
2617         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT);
2618         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT);
2619         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER);
2620         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER);
2621         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE);
2622         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_UNSUPPORTED);
2623         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_UNDEFINED);
2624 #undef FBOSTATUS_TO_STR
2625         default:
2626             FIXME("Unrecognied FBO status 0x%08x\n", status);
2627             return "unrecognized";
2628     }
2629 }
2630
2631 const char *debug_glerror(GLenum error) {
2632     switch(error) {
2633 #define GLERROR_TO_STR(u) case u: return #u
2634         GLERROR_TO_STR(GL_NO_ERROR);
2635         GLERROR_TO_STR(GL_INVALID_ENUM);
2636         GLERROR_TO_STR(GL_INVALID_VALUE);
2637         GLERROR_TO_STR(GL_INVALID_OPERATION);
2638         GLERROR_TO_STR(GL_STACK_OVERFLOW);
2639         GLERROR_TO_STR(GL_STACK_UNDERFLOW);
2640         GLERROR_TO_STR(GL_OUT_OF_MEMORY);
2641         GLERROR_TO_STR(GL_INVALID_FRAMEBUFFER_OPERATION);
2642 #undef GLERROR_TO_STR
2643         default:
2644             FIXME("Unrecognied GL error 0x%08x\n", error);
2645             return "unrecognized";
2646     }
2647 }
2648
2649 static const char *debug_fixup_channel_source(enum fixup_channel_source source)
2650 {
2651     switch(source)
2652     {
2653 #define WINED3D_TO_STR(x) case x: return #x
2654         WINED3D_TO_STR(CHANNEL_SOURCE_ZERO);
2655         WINED3D_TO_STR(CHANNEL_SOURCE_ONE);
2656         WINED3D_TO_STR(CHANNEL_SOURCE_X);
2657         WINED3D_TO_STR(CHANNEL_SOURCE_Y);
2658         WINED3D_TO_STR(CHANNEL_SOURCE_Z);
2659         WINED3D_TO_STR(CHANNEL_SOURCE_W);
2660         WINED3D_TO_STR(CHANNEL_SOURCE_COMPLEX0);
2661         WINED3D_TO_STR(CHANNEL_SOURCE_COMPLEX1);
2662 #undef WINED3D_TO_STR
2663         default:
2664             FIXME("Unrecognized fixup_channel_source %#x\n", source);
2665             return "unrecognized";
2666     }
2667 }
2668
2669 static const char *debug_complex_fixup(enum complex_fixup fixup)
2670 {
2671     switch(fixup)
2672     {
2673 #define WINED3D_TO_STR(x) case x: return #x
2674         WINED3D_TO_STR(COMPLEX_FIXUP_YUY2);
2675         WINED3D_TO_STR(COMPLEX_FIXUP_UYVY);
2676         WINED3D_TO_STR(COMPLEX_FIXUP_YV12);
2677         WINED3D_TO_STR(COMPLEX_FIXUP_P8);
2678 #undef WINED3D_TO_STR
2679         default:
2680             FIXME("Unrecognized complex fixup %#x\n", fixup);
2681             return "unrecognized";
2682     }
2683 }
2684
2685 void dump_color_fixup_desc(struct color_fixup_desc fixup)
2686 {
2687     if (is_complex_fixup(fixup))
2688     {
2689         TRACE("\tComplex: %s\n", debug_complex_fixup(get_complex_fixup(fixup)));
2690         return;
2691     }
2692
2693     TRACE("\tX: %s%s\n", debug_fixup_channel_source(fixup.x_source), fixup.x_sign_fixup ? ", SIGN_FIXUP" : "");
2694     TRACE("\tY: %s%s\n", debug_fixup_channel_source(fixup.y_source), fixup.y_sign_fixup ? ", SIGN_FIXUP" : "");
2695     TRACE("\tZ: %s%s\n", debug_fixup_channel_source(fixup.z_source), fixup.z_sign_fixup ? ", SIGN_FIXUP" : "");
2696     TRACE("\tW: %s%s\n", debug_fixup_channel_source(fixup.w_source), fixup.w_sign_fixup ? ", SIGN_FIXUP" : "");
2697 }
2698
2699 const char *debug_surflocation(DWORD flag) {
2700     char buf[128];
2701
2702     buf[0] = 0;
2703     if (flag & SFLAG_INSYSMEM) strcat(buf, " | SFLAG_INSYSMEM");                    /* 17 */
2704     if (flag & SFLAG_INDRAWABLE) strcat(buf, " | SFLAG_INDRAWABLE");                /* 19 */
2705     if (flag & SFLAG_INTEXTURE) strcat(buf, " | SFLAG_INTEXTURE");                  /* 18 */
2706     if (flag & SFLAG_INSRGBTEX) strcat(buf, " | SFLAG_INSRGBTEX");                  /* 18 */
2707     if (flag & SFLAG_INRB_MULTISAMPLE) strcat(buf, " | SFLAG_INRB_MULTISAMPLE");    /* 25 */
2708     if (flag & SFLAG_INRB_RESOLVED) strcat(buf, " | SFLAG_INRB_RESOLVED");          /* 22 */
2709     return wine_dbg_sprintf("%s", buf[0] ? buf + 3 : "0");
2710 }
2711
2712 BOOL is_invalid_op(const struct wined3d_state *state, int stage,
2713         enum wined3d_texture_op op, DWORD arg1, DWORD arg2, DWORD arg3)
2714 {
2715     if (op == WINED3D_TOP_DISABLE)
2716         return FALSE;
2717     if (state->textures[stage])
2718         return FALSE;
2719
2720     if ((arg1 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
2721             && op != WINED3D_TOP_SELECT_ARG2)
2722         return TRUE;
2723     if ((arg2 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
2724             && op != WINED3D_TOP_SELECT_ARG1)
2725         return TRUE;
2726     if ((arg3 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
2727             && (op == WINED3D_TOP_MULTIPLY_ADD || op == WINED3D_TOP_LERP))
2728         return TRUE;
2729
2730     return FALSE;
2731 }
2732
2733 /* Setup this textures matrix according to the texture flags. */
2734 /* Context activation is done by the caller (state handler). */
2735 void set_texture_matrix(const struct wined3d_gl_info *gl_info, const float *smat, DWORD flags,
2736         BOOL calculatedCoords, BOOL transformed, enum wined3d_format_id vtx_fmt, BOOL ffp_proj_control)
2737 {
2738     float mat[16];
2739
2740     gl_info->gl_ops.gl.p_glMatrixMode(GL_TEXTURE);
2741     checkGLcall("glMatrixMode(GL_TEXTURE)");
2742
2743     if (flags == WINED3D_TTFF_DISABLE || flags == WINED3D_TTFF_COUNT1 || transformed)
2744     {
2745         gl_info->gl_ops.gl.p_glLoadIdentity();
2746         checkGLcall("glLoadIdentity()");
2747         return;
2748     }
2749
2750     if (flags == (WINED3D_TTFF_COUNT1 | WINED3D_TTFF_PROJECTED))
2751     {
2752         ERR("Invalid texture transform flags: WINED3D_TTFF_COUNT1 | WINED3D_TTFF_PROJECTED.\n");
2753         return;
2754     }
2755
2756     memcpy(mat, smat, 16 * sizeof(float));
2757
2758     if (flags & WINED3D_TTFF_PROJECTED)
2759     {
2760         if (!ffp_proj_control)
2761         {
2762             switch (flags & ~WINED3D_TTFF_PROJECTED)
2763             {
2764                 case WINED3D_TTFF_COUNT2:
2765                     mat[ 3] = mat[ 1];
2766                     mat[ 7] = mat[ 5];
2767                     mat[11] = mat[ 9];
2768                     mat[15] = mat[13];
2769                     mat[ 1] = mat[ 5] = mat[ 9] = mat[13] = 0.0f;
2770                     break;
2771                 case WINED3D_TTFF_COUNT3:
2772                     mat[ 3] = mat[ 2];
2773                     mat[ 7] = mat[ 6];
2774                     mat[11] = mat[10];
2775                     mat[15] = mat[14];
2776                     mat[ 2] = mat[ 6] = mat[10] = mat[14] = 0.0f;
2777                     break;
2778             }
2779         }
2780     } else { /* under directx the R/Z coord can be used for translation, under opengl we use the Q coord instead */
2781         if(!calculatedCoords) {
2782             switch(vtx_fmt)
2783             {
2784                 case WINED3DFMT_R32_FLOAT:
2785                     /* Direct3D passes the default 1.0 in the 2nd coord, while gl passes it in the 4th.
2786                      * swap 2nd and 4th coord. No need to store the value of mat[12] in mat[4] because
2787                      * the input value to the transformation will be 0, so the matrix value is irrelevant
2788                      */
2789                     mat[12] = mat[4];
2790                     mat[13] = mat[5];
2791                     mat[14] = mat[6];
2792                     mat[15] = mat[7];
2793                     break;
2794                 case WINED3DFMT_R32G32_FLOAT:
2795                     /* See above, just 3rd and 4th coord
2796                     */
2797                     mat[12] = mat[8];
2798                     mat[13] = mat[9];
2799                     mat[14] = mat[10];
2800                     mat[15] = mat[11];
2801                     break;
2802                 case WINED3DFMT_R32G32B32_FLOAT: /* Opengl defaults match dx defaults */
2803                 case WINED3DFMT_R32G32B32A32_FLOAT: /* No defaults apply, all app defined */
2804
2805                 /* This is to prevent swapping the matrix lines and put the default 4th coord = 1.0
2806                  * into a bad place. The division elimination below will apply to make sure the
2807                  * 1.0 doesn't do anything bad. The caller will set this value if the stride is 0
2808                  */
2809                 case WINED3DFMT_UNKNOWN: /* No texture coords, 0/0/0/1 defaults are passed */
2810                     break;
2811                 default:
2812                     FIXME("Unexpected fixed function texture coord input\n");
2813             }
2814         }
2815         if (!ffp_proj_control)
2816         {
2817             switch (flags & ~WINED3D_TTFF_PROJECTED)
2818             {
2819                 /* case WINED3D_TTFF_COUNT1: Won't ever get here. */
2820                 case WINED3D_TTFF_COUNT2:
2821                     mat[2] = mat[6] = mat[10] = mat[14] = 0;
2822                 /* OpenGL divides the first 3 vertex coord by the 4th by default,
2823                 * which is essentially the same as D3DTTFF_PROJECTED. Make sure that
2824                 * the 4th coord evaluates to 1.0 to eliminate that.
2825                 *
2826                 * If the fixed function pipeline is used, the 4th value remains unused,
2827                 * so there is no danger in doing this. With vertex shaders we have a
2828                 * problem. Should an app hit that problem, the code here would have to
2829                 * check for pixel shaders, and the shader has to undo the default gl divide.
2830                 *
2831                 * A more serious problem occurs if the app passes 4 coordinates in, and the
2832                 * 4th is != 1.0(opengl default). This would have to be fixed in drawStridedSlow
2833                 * or a replacement shader. */
2834                 default:
2835                     mat[3] = mat[7] = mat[11] = 0; mat[15] = 1;
2836             }
2837         }
2838     }
2839
2840     gl_info->gl_ops.gl.p_glLoadMatrixf(mat);
2841     checkGLcall("glLoadMatrixf(mat)");
2842 }
2843
2844 /* This small helper function is used to convert a bitmask into the number of masked bits */
2845 unsigned int count_bits(unsigned int mask)
2846 {
2847     unsigned int count;
2848     for (count = 0; mask; ++count)
2849     {
2850         mask &= mask - 1;
2851     }
2852     return count;
2853 }
2854
2855 /* Helper function for retrieving color info for ChoosePixelFormat and wglChoosePixelFormatARB.
2856  * The later function requires individual color components. */
2857 BOOL getColorBits(const struct wined3d_format *format,
2858         BYTE *redSize, BYTE *greenSize, BYTE *blueSize, BYTE *alphaSize, BYTE *totalSize)
2859 {
2860     TRACE("format %s.\n", debug_d3dformat(format->id));
2861
2862     switch (format->id)
2863     {
2864         case WINED3DFMT_B10G10R10A2_UNORM:
2865         case WINED3DFMT_R10G10B10A2_UNORM:
2866         case WINED3DFMT_B8G8R8X8_UNORM:
2867         case WINED3DFMT_B8G8R8_UNORM:
2868         case WINED3DFMT_B8G8R8A8_UNORM:
2869         case WINED3DFMT_R8G8B8A8_UNORM:
2870         case WINED3DFMT_B5G5R5X1_UNORM:
2871         case WINED3DFMT_B5G5R5A1_UNORM:
2872         case WINED3DFMT_B5G6R5_UNORM:
2873         case WINED3DFMT_B4G4R4X4_UNORM:
2874         case WINED3DFMT_B4G4R4A4_UNORM:
2875         case WINED3DFMT_B2G3R3_UNORM:
2876         case WINED3DFMT_P8_UINT_A8_UNORM:
2877         case WINED3DFMT_P8_UINT:
2878             break;
2879         default:
2880             FIXME("Unsupported format %s.\n", debug_d3dformat(format->id));
2881             return FALSE;
2882     }
2883
2884     *redSize = format->red_size;
2885     *greenSize = format->green_size;
2886     *blueSize = format->blue_size;
2887     *alphaSize = format->alpha_size;
2888     *totalSize = *redSize + *greenSize + *blueSize + *alphaSize;
2889
2890     TRACE("Returning red: %d, green: %d, blue: %d, alpha: %d, total: %d for format %s.\n",
2891             *redSize, *greenSize, *blueSize, *alphaSize, *totalSize, debug_d3dformat(format->id));
2892     return TRUE;
2893 }
2894
2895 /* Helper function for retrieving depth/stencil info for ChoosePixelFormat and wglChoosePixelFormatARB */
2896 BOOL getDepthStencilBits(const struct wined3d_format *format, BYTE *depthSize, BYTE *stencilSize)
2897 {
2898     TRACE("format %s.\n", debug_d3dformat(format->id));
2899
2900     switch (format->id)
2901     {
2902         case WINED3DFMT_D16_LOCKABLE:
2903         case WINED3DFMT_D16_UNORM:
2904         case WINED3DFMT_S1_UINT_D15_UNORM:
2905         case WINED3DFMT_X8D24_UNORM:
2906         case WINED3DFMT_S4X4_UINT_D24_UNORM:
2907         case WINED3DFMT_D24_UNORM_S8_UINT:
2908         case WINED3DFMT_S8_UINT_D24_FLOAT:
2909         case WINED3DFMT_D32_UNORM:
2910         case WINED3DFMT_D32_FLOAT:
2911         case WINED3DFMT_INTZ:
2912             break;
2913         default:
2914             FIXME("Unsupported depth/stencil format %s.\n", debug_d3dformat(format->id));
2915             return FALSE;
2916     }
2917
2918     *depthSize = format->depth_size;
2919     *stencilSize = format->stencil_size;
2920
2921     TRACE("Returning depthSize: %d and stencilSize: %d for format %s.\n",
2922             *depthSize, *stencilSize, debug_d3dformat(format->id));
2923     return TRUE;
2924 }
2925
2926 /* Note: It's the caller's responsibility to ensure values can be expressed
2927  * in the requested format. UNORM formats for example can only express values
2928  * in the range 0.0f -> 1.0f. */
2929 DWORD wined3d_format_convert_from_float(const struct wined3d_surface *surface, const struct wined3d_color *color)
2930 {
2931     static const struct
2932     {
2933         enum wined3d_format_id format_id;
2934         float r_mul;
2935         float g_mul;
2936         float b_mul;
2937         float a_mul;
2938         BYTE r_shift;
2939         BYTE g_shift;
2940         BYTE b_shift;
2941         BYTE a_shift;
2942     }
2943     conv[] =
2944     {
2945         {WINED3DFMT_B8G8R8A8_UNORM,     255.0f,  255.0f,  255.0f,  255.0f, 16,  8,  0, 24},
2946         {WINED3DFMT_B8G8R8X8_UNORM,     255.0f,  255.0f,  255.0f,  255.0f, 16,  8,  0, 24},
2947         {WINED3DFMT_B8G8R8_UNORM,       255.0f,  255.0f,  255.0f,  255.0f, 16,  8,  0, 24},
2948         {WINED3DFMT_B5G6R5_UNORM,        31.0f,   63.0f,   31.0f,    0.0f, 11,  5,  0,  0},
2949         {WINED3DFMT_B5G5R5A1_UNORM,      31.0f,   31.0f,   31.0f,    1.0f, 10,  5,  0, 15},
2950         {WINED3DFMT_B5G5R5X1_UNORM,      31.0f,   31.0f,   31.0f,    1.0f, 10,  5,  0, 15},
2951         {WINED3DFMT_A8_UNORM,             0.0f,    0.0f,    0.0f,  255.0f,  0,  0,  0,  0},
2952         {WINED3DFMT_B4G4R4A4_UNORM,      15.0f,   15.0f,   15.0f,   15.0f,  8,  4,  0, 12},
2953         {WINED3DFMT_B4G4R4X4_UNORM,      15.0f,   15.0f,   15.0f,   15.0f,  8,  4,  0, 12},
2954         {WINED3DFMT_B2G3R3_UNORM,         7.0f,    7.0f,    3.0f,    0.0f,  5,  2,  0,  0},
2955         {WINED3DFMT_R8G8B8A8_UNORM,     255.0f,  255.0f,  255.0f,  255.0f,  0,  8, 16, 24},
2956         {WINED3DFMT_R8G8B8X8_UNORM,     255.0f,  255.0f,  255.0f,  255.0f,  0,  8, 16, 24},
2957         {WINED3DFMT_B10G10R10A2_UNORM, 1023.0f, 1023.0f, 1023.0f,    3.0f, 20, 10,  0, 30},
2958         {WINED3DFMT_R10G10B10A2_UNORM, 1023.0f, 1023.0f, 1023.0f,    3.0f,  0, 10, 20, 30},
2959     };
2960     const struct wined3d_format *format = surface->resource.format;
2961     unsigned int i;
2962
2963     TRACE("Converting color {%.8e %.8e %.8e %.8e} to format %s.\n",
2964             color->r, color->g, color->b, color->a, debug_d3dformat(format->id));
2965
2966     for (i = 0; i < sizeof(conv) / sizeof(*conv); ++i)
2967     {
2968         DWORD ret;
2969
2970         if (format->id != conv[i].format_id) continue;
2971
2972         ret = ((DWORD)((color->r * conv[i].r_mul) + 0.5f)) << conv[i].r_shift;
2973         ret |= ((DWORD)((color->g * conv[i].g_mul) + 0.5f)) << conv[i].g_shift;
2974         ret |= ((DWORD)((color->b * conv[i].b_mul) + 0.5f)) << conv[i].b_shift;
2975         ret |= ((DWORD)((color->a * conv[i].a_mul) + 0.5f)) << conv[i].a_shift;
2976
2977         TRACE("Returning 0x%08x.\n", ret);
2978
2979         return ret;
2980     }
2981
2982     if (format->id == WINED3DFMT_P8_UINT)
2983     {
2984         PALETTEENTRY *e;
2985         BYTE r, g, b, a;
2986
2987         if (!surface->palette)
2988         {
2989             WARN("Surface doesn't have a palette, returning 0.\n");
2990             return 0;
2991         }
2992
2993         r = (BYTE)((color->r * 255.0f) + 0.5f);
2994         g = (BYTE)((color->g * 255.0f) + 0.5f);
2995         b = (BYTE)((color->b * 255.0f) + 0.5f);
2996         a = (BYTE)((color->a * 255.0f) + 0.5f);
2997
2998         e = &surface->palette->palents[a];
2999         if (e->peRed == r && e->peGreen == g && e->peBlue == b)
3000             return a;
3001
3002         WARN("Alpha didn't match index, searching full palette.\n");
3003
3004         for (i = 0; i < 256; ++i)
3005         {
3006             e = &surface->palette->palents[i];
3007             if (e->peRed == r && e->peGreen == g && e->peBlue == b)
3008                 return i;
3009         }
3010
3011         FIXME("Unable to convert color to palette index.\n");
3012
3013         return 0;
3014     }
3015
3016     FIXME("Conversion for format %s not implemented.\n", debug_d3dformat(format->id));
3017
3018     return 0;
3019 }
3020
3021 /* DirectDraw stuff */
3022 enum wined3d_format_id pixelformat_for_depth(DWORD depth)
3023 {
3024     switch (depth)
3025     {
3026         case 8:  return WINED3DFMT_P8_UINT;
3027         case 15: return WINED3DFMT_B5G5R5X1_UNORM;
3028         case 16: return WINED3DFMT_B5G6R5_UNORM;
3029         case 24: return WINED3DFMT_B8G8R8X8_UNORM; /* Robots needs 24bit to be WINED3DFMT_B8G8R8X8_UNORM */
3030         case 32: return WINED3DFMT_B8G8R8X8_UNORM; /* EVE online and the Fur demo need 32bit AdapterDisplayMode to return WINED3DFMT_B8G8R8X8_UNORM */
3031         default: return WINED3DFMT_UNKNOWN;
3032     }
3033 }
3034
3035 void multiply_matrix(struct wined3d_matrix *dest, const struct wined3d_matrix *src1,
3036         const struct wined3d_matrix *src2)
3037 {
3038     struct wined3d_matrix temp;
3039
3040     /* Now do the multiplication 'by hand'.
3041        I know that all this could be optimised, but this will be done later :-) */
3042     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);
3043     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);
3044     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);
3045     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);
3046
3047     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);
3048     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);
3049     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);
3050     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);
3051
3052     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);
3053     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);
3054     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);
3055     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);
3056
3057     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);
3058     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);
3059     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);
3060     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);
3061
3062     /* And copy the new matrix in the good storage.. */
3063     memcpy(dest, &temp, 16 * sizeof(float));
3064 }
3065
3066 DWORD get_flexible_vertex_size(DWORD d3dvtVertexType) {
3067     DWORD size = 0;
3068     int i;
3069     int numTextures = (d3dvtVertexType & WINED3DFVF_TEXCOUNT_MASK) >> WINED3DFVF_TEXCOUNT_SHIFT;
3070
3071     if (d3dvtVertexType & WINED3DFVF_NORMAL) size += 3 * sizeof(float);
3072     if (d3dvtVertexType & WINED3DFVF_DIFFUSE) size += sizeof(DWORD);
3073     if (d3dvtVertexType & WINED3DFVF_SPECULAR) size += sizeof(DWORD);
3074     if (d3dvtVertexType & WINED3DFVF_PSIZE) size += sizeof(DWORD);
3075     switch (d3dvtVertexType & WINED3DFVF_POSITION_MASK) {
3076         case WINED3DFVF_XYZ:    size += 3 * sizeof(float); break;
3077         case WINED3DFVF_XYZRHW: size += 4 * sizeof(float); break;
3078         case WINED3DFVF_XYZB1:  size += 4 * sizeof(float); break;
3079         case WINED3DFVF_XYZB2:  size += 5 * sizeof(float); break;
3080         case WINED3DFVF_XYZB3:  size += 6 * sizeof(float); break;
3081         case WINED3DFVF_XYZB4:  size += 7 * sizeof(float); break;
3082         case WINED3DFVF_XYZB5:  size += 8 * sizeof(float); break;
3083         case WINED3DFVF_XYZW:   size += 4 * sizeof(float); break;
3084         default: ERR("Unexpected position mask\n");
3085     }
3086     for (i = 0; i < numTextures; i++) {
3087         size += GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType, i) * sizeof(float);
3088     }
3089
3090     return size;
3091 }
3092
3093 void gen_ffp_frag_op(const struct wined3d_device *device, const struct wined3d_state *state,
3094         struct ffp_frag_settings *settings, BOOL ignore_textype)
3095 {
3096 #define ARG1 0x01
3097 #define ARG2 0x02
3098 #define ARG0 0x04
3099     static const unsigned char args[WINED3D_TOP_LERP + 1] =
3100     {
3101         /* undefined                        */  0,
3102         /* D3DTOP_DISABLE                   */  0,
3103         /* D3DTOP_SELECTARG1                */  ARG1,
3104         /* D3DTOP_SELECTARG2                */  ARG2,
3105         /* D3DTOP_MODULATE                  */  ARG1 | ARG2,
3106         /* D3DTOP_MODULATE2X                */  ARG1 | ARG2,
3107         /* D3DTOP_MODULATE4X                */  ARG1 | ARG2,
3108         /* D3DTOP_ADD                       */  ARG1 | ARG2,
3109         /* D3DTOP_ADDSIGNED                 */  ARG1 | ARG2,
3110         /* D3DTOP_ADDSIGNED2X               */  ARG1 | ARG2,
3111         /* D3DTOP_SUBTRACT                  */  ARG1 | ARG2,
3112         /* D3DTOP_ADDSMOOTH                 */  ARG1 | ARG2,
3113         /* D3DTOP_BLENDDIFFUSEALPHA         */  ARG1 | ARG2,
3114         /* D3DTOP_BLENDTEXTUREALPHA         */  ARG1 | ARG2,
3115         /* D3DTOP_BLENDFACTORALPHA          */  ARG1 | ARG2,
3116         /* D3DTOP_BLENDTEXTUREALPHAPM       */  ARG1 | ARG2,
3117         /* D3DTOP_BLENDCURRENTALPHA         */  ARG1 | ARG2,
3118         /* D3DTOP_PREMODULATE               */  ARG1 | ARG2,
3119         /* D3DTOP_MODULATEALPHA_ADDCOLOR    */  ARG1 | ARG2,
3120         /* D3DTOP_MODULATECOLOR_ADDALPHA    */  ARG1 | ARG2,
3121         /* D3DTOP_MODULATEINVALPHA_ADDCOLOR */  ARG1 | ARG2,
3122         /* D3DTOP_MODULATEINVCOLOR_ADDALPHA */  ARG1 | ARG2,
3123         /* D3DTOP_BUMPENVMAP                */  ARG1 | ARG2,
3124         /* D3DTOP_BUMPENVMAPLUMINANCE       */  ARG1 | ARG2,
3125         /* D3DTOP_DOTPRODUCT3               */  ARG1 | ARG2,
3126         /* D3DTOP_MULTIPLYADD               */  ARG1 | ARG2 | ARG0,
3127         /* D3DTOP_LERP                      */  ARG1 | ARG2 | ARG0
3128     };
3129     unsigned int i;
3130     DWORD ttff;
3131     DWORD cop, aop, carg0, carg1, carg2, aarg0, aarg1, aarg2;
3132     const struct wined3d_surface *rt = state->fb->render_targets[0];
3133     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
3134     const struct wined3d_d3d_info *d3d_info = &device->adapter->d3d_info;
3135
3136     for (i = 0; i < gl_info->limits.texture_stages; ++i)
3137     {
3138         const struct wined3d_texture *texture;
3139
3140         settings->op[i].padding = 0;
3141         if (state->texture_states[i][WINED3D_TSS_COLOR_OP] == WINED3D_TOP_DISABLE)
3142         {
3143             settings->op[i].cop = WINED3D_TOP_DISABLE;
3144             settings->op[i].aop = WINED3D_TOP_DISABLE;
3145             settings->op[i].carg0 = settings->op[i].carg1 = settings->op[i].carg2 = ARG_UNUSED;
3146             settings->op[i].aarg0 = settings->op[i].aarg1 = settings->op[i].aarg2 = ARG_UNUSED;
3147             settings->op[i].color_fixup = COLOR_FIXUP_IDENTITY;
3148             settings->op[i].dst = resultreg;
3149             settings->op[i].tex_type = tex_1d;
3150             settings->op[i].projected = proj_none;
3151             i++;
3152             break;
3153         }
3154
3155         if ((texture = state->textures[i]))
3156         {
3157             settings->op[i].color_fixup = texture->resource.format->color_fixup;
3158             if (ignore_textype)
3159             {
3160                 settings->op[i].tex_type = tex_1d;
3161             }
3162             else
3163             {
3164                 switch (texture->target)
3165                 {
3166                     case GL_TEXTURE_1D:
3167                         settings->op[i].tex_type = tex_1d;
3168                         break;
3169                     case GL_TEXTURE_2D:
3170                         settings->op[i].tex_type = tex_2d;
3171                         break;
3172                     case GL_TEXTURE_3D:
3173                         settings->op[i].tex_type = tex_3d;
3174                         break;
3175                     case GL_TEXTURE_CUBE_MAP_ARB:
3176                         settings->op[i].tex_type = tex_cube;
3177                         break;
3178                     case GL_TEXTURE_RECTANGLE_ARB:
3179                         settings->op[i].tex_type = tex_rect;
3180                         break;
3181                 }
3182             }
3183         } else {
3184             settings->op[i].color_fixup = COLOR_FIXUP_IDENTITY;
3185             settings->op[i].tex_type = tex_1d;
3186         }
3187
3188         cop = state->texture_states[i][WINED3D_TSS_COLOR_OP];
3189         aop = state->texture_states[i][WINED3D_TSS_ALPHA_OP];
3190
3191         carg1 = (args[cop] & ARG1) ? state->texture_states[i][WINED3D_TSS_COLOR_ARG1] : ARG_UNUSED;
3192         carg2 = (args[cop] & ARG2) ? state->texture_states[i][WINED3D_TSS_COLOR_ARG2] : ARG_UNUSED;
3193         carg0 = (args[cop] & ARG0) ? state->texture_states[i][WINED3D_TSS_COLOR_ARG0] : ARG_UNUSED;
3194
3195         if (is_invalid_op(state, i, cop, carg1, carg2, carg0))
3196         {
3197             carg0 = ARG_UNUSED;
3198             carg2 = ARG_UNUSED;
3199             carg1 = WINED3DTA_CURRENT;
3200             cop = WINED3D_TOP_SELECT_ARG1;
3201         }
3202
3203         if (cop == WINED3D_TOP_DOTPRODUCT3)
3204         {
3205             /* A dotproduct3 on the colorop overwrites the alphaop operation and replicates
3206              * the color result to the alpha component of the destination
3207              */
3208             aop = cop;
3209             aarg1 = carg1;
3210             aarg2 = carg2;
3211             aarg0 = carg0;
3212         }
3213         else
3214         {
3215             aarg1 = (args[aop] & ARG1) ? state->texture_states[i][WINED3D_TSS_ALPHA_ARG1] : ARG_UNUSED;
3216             aarg2 = (args[aop] & ARG2) ? state->texture_states[i][WINED3D_TSS_ALPHA_ARG2] : ARG_UNUSED;
3217             aarg0 = (args[aop] & ARG0) ? state->texture_states[i][WINED3D_TSS_ALPHA_ARG0] : ARG_UNUSED;
3218         }
3219
3220         if (!i && state->textures[0] && state->render_states[WINED3D_RS_COLORKEYENABLE])
3221         {
3222             GLenum texture_dimensions;
3223
3224             texture = state->textures[0];
3225             texture_dimensions = texture->target;
3226
3227             if (texture_dimensions == GL_TEXTURE_2D || texture_dimensions == GL_TEXTURE_RECTANGLE_ARB)
3228             {
3229                 struct wined3d_surface *surf = surface_from_resource(texture->sub_resources[0]);
3230
3231                 if (surf->CKeyFlags & WINEDDSD_CKSRCBLT && !surf->resource.format->alpha_size)
3232                 {
3233                     if (aop == WINED3D_TOP_DISABLE)
3234                     {
3235                        aarg1 = WINED3DTA_TEXTURE;
3236                        aop = WINED3D_TOP_SELECT_ARG1;
3237                     }
3238                     else if (aop == WINED3D_TOP_SELECT_ARG1 && aarg1 != WINED3DTA_TEXTURE)
3239                     {
3240                         if (state->render_states[WINED3D_RS_ALPHABLENDENABLE])
3241                         {
3242                             aarg2 = WINED3DTA_TEXTURE;
3243                             aop = WINED3D_TOP_MODULATE;
3244                         }
3245                         else aarg1 = WINED3DTA_TEXTURE;
3246                     }
3247                     else if (aop == WINED3D_TOP_SELECT_ARG2 && aarg2 != WINED3DTA_TEXTURE)
3248                     {
3249                         if (state->render_states[WINED3D_RS_ALPHABLENDENABLE])
3250                         {
3251                             aarg1 = WINED3DTA_TEXTURE;
3252                             aop = WINED3D_TOP_MODULATE;
3253                         }
3254                         else aarg2 = WINED3DTA_TEXTURE;
3255                     }
3256                 }
3257             }
3258         }
3259
3260         if (is_invalid_op(state, i, aop, aarg1, aarg2, aarg0))
3261         {
3262                aarg0 = ARG_UNUSED;
3263                aarg2 = ARG_UNUSED;
3264                aarg1 = WINED3DTA_CURRENT;
3265                aop = WINED3D_TOP_SELECT_ARG1;
3266         }
3267
3268         if (carg1 == WINED3DTA_TEXTURE || carg2 == WINED3DTA_TEXTURE || carg0 == WINED3DTA_TEXTURE
3269                 || aarg1 == WINED3DTA_TEXTURE || aarg2 == WINED3DTA_TEXTURE || aarg0 == WINED3DTA_TEXTURE)
3270         {
3271             ttff = state->texture_states[i][WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS];
3272             if (ttff == (WINED3D_TTFF_PROJECTED | WINED3D_TTFF_COUNT3))
3273                 settings->op[i].projected = proj_count3;
3274             else if (ttff & WINED3D_TTFF_PROJECTED)
3275                 settings->op[i].projected = proj_count4;
3276             else
3277                 settings->op[i].projected = proj_none;
3278         }
3279         else
3280         {
3281             settings->op[i].projected = proj_none;
3282         }
3283
3284         settings->op[i].cop = cop;
3285         settings->op[i].aop = aop;
3286         settings->op[i].carg0 = carg0;
3287         settings->op[i].carg1 = carg1;
3288         settings->op[i].carg2 = carg2;
3289         settings->op[i].aarg0 = aarg0;
3290         settings->op[i].aarg1 = aarg1;
3291         settings->op[i].aarg2 = aarg2;
3292
3293         if (state->texture_states[i][WINED3D_TSS_RESULT_ARG] == WINED3DTA_TEMP)
3294             settings->op[i].dst = tempreg;
3295         else
3296             settings->op[i].dst = resultreg;
3297     }
3298
3299     /* Clear unsupported stages */
3300     for(; i < MAX_TEXTURES; i++) {
3301         memset(&settings->op[i], 0xff, sizeof(settings->op[i]));
3302     }
3303
3304     if (!state->render_states[WINED3D_RS_FOGENABLE])
3305     {
3306         settings->fog = FOG_OFF;
3307     }
3308     else if (state->render_states[WINED3D_RS_FOGTABLEMODE] == WINED3D_FOG_NONE)
3309     {
3310         if (use_vs(state) || state->vertex_declaration->position_transformed)
3311         {
3312             settings->fog = FOG_LINEAR;
3313         }
3314         else
3315         {
3316             switch (state->render_states[WINED3D_RS_FOGVERTEXMODE])
3317             {
3318                 case WINED3D_FOG_NONE:
3319                 case WINED3D_FOG_LINEAR:
3320                     settings->fog = FOG_LINEAR;
3321                     break;
3322                 case WINED3D_FOG_EXP:
3323                     settings->fog = FOG_EXP;
3324                     break;
3325                 case WINED3D_FOG_EXP2:
3326                     settings->fog = FOG_EXP2;
3327                     break;
3328             }
3329         }
3330     }
3331     else
3332     {
3333         switch (state->render_states[WINED3D_RS_FOGTABLEMODE])
3334         {
3335             case WINED3D_FOG_LINEAR:
3336                 settings->fog = FOG_LINEAR;
3337                 break;
3338             case WINED3D_FOG_EXP:
3339                 settings->fog = FOG_EXP;
3340                 break;
3341             case WINED3D_FOG_EXP2:
3342                 settings->fog = FOG_EXP2;
3343                 break;
3344         }
3345     }
3346     if (!gl_info->supported[ARB_FRAMEBUFFER_SRGB]
3347             && state->render_states[WINED3D_RS_SRGBWRITEENABLE]
3348             && rt->resource.format->flags & WINED3DFMT_FLAG_SRGB_WRITE)
3349     {
3350         settings->sRGB_write = 1;
3351     } else {
3352         settings->sRGB_write = 0;
3353     }
3354     if (d3d_info->vs_clipping || !use_vs(state) || !state->render_states[WINED3D_RS_CLIPPING]
3355             || !state->render_states[WINED3D_RS_CLIPPLANEENABLE])
3356     {
3357         /* No need to emulate clipplanes if GL supports native vertex shader clipping or if
3358          * the fixed function vertex pipeline is used(which always supports clipplanes), or
3359          * if no clipplane is enabled
3360          */
3361         settings->emul_clipplanes = 0;
3362     } else {
3363         settings->emul_clipplanes = 1;
3364     }
3365 }
3366
3367 const struct ffp_frag_desc *find_ffp_frag_shader(const struct wine_rb_tree *fragment_shaders,
3368         const struct ffp_frag_settings *settings)
3369 {
3370     struct wine_rb_entry *entry = wine_rb_get(fragment_shaders, settings);
3371     return entry ? WINE_RB_ENTRY_VALUE(entry, struct ffp_frag_desc, entry) : NULL;
3372 }
3373
3374 void add_ffp_frag_shader(struct wine_rb_tree *shaders, struct ffp_frag_desc *desc)
3375 {
3376     /* Note that the key is the implementation independent part of the ffp_frag_desc structure,
3377      * whereas desc points to an extended structure with implementation specific parts. */
3378     if (wine_rb_put(shaders, &desc->settings, &desc->entry) == -1)
3379     {
3380         ERR("Failed to insert ffp frag shader.\n");
3381     }
3382 }
3383
3384 /* Activates the texture dimension according to the bound D3D texture. Does
3385  * not care for the colorop or correct gl texture unit (when using nvrc).
3386  * Requires the caller to activate the correct unit. */
3387 /* Context activation is done by the caller (state handler). */
3388 void texture_activate_dimensions(const struct wined3d_texture *texture, const struct wined3d_gl_info *gl_info)
3389 {
3390     if (texture)
3391     {
3392         switch (texture->target)
3393         {
3394             case GL_TEXTURE_2D:
3395                 gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_3D);
3396                 checkGLcall("glDisable(GL_TEXTURE_3D)");
3397                 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
3398                 {
3399                     gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_CUBE_MAP_ARB);
3400                     checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
3401                 }
3402                 if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
3403                 {
3404                     gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_RECTANGLE_ARB);
3405                     checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
3406                 }
3407                 gl_info->gl_ops.gl.p_glEnable(GL_TEXTURE_2D);
3408                 checkGLcall("glEnable(GL_TEXTURE_2D)");
3409                 break;
3410             case GL_TEXTURE_RECTANGLE_ARB:
3411                 gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_2D);
3412                 checkGLcall("glDisable(GL_TEXTURE_2D)");
3413                 gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_3D);
3414                 checkGLcall("glDisable(GL_TEXTURE_3D)");
3415                 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
3416                 {
3417                     gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_CUBE_MAP_ARB);
3418                     checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
3419                 }
3420                 gl_info->gl_ops.gl.p_glEnable(GL_TEXTURE_RECTANGLE_ARB);
3421                 checkGLcall("glEnable(GL_TEXTURE_RECTANGLE_ARB)");
3422                 break;
3423             case GL_TEXTURE_3D:
3424                 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
3425                 {
3426                     gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_CUBE_MAP_ARB);
3427                     checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
3428                 }
3429                 if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
3430                 {
3431                     gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_RECTANGLE_ARB);
3432                     checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
3433                 }
3434                 gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_2D);
3435                 checkGLcall("glDisable(GL_TEXTURE_2D)");
3436                 gl_info->gl_ops.gl.p_glEnable(GL_TEXTURE_3D);
3437                 checkGLcall("glEnable(GL_TEXTURE_3D)");
3438                 break;
3439             case GL_TEXTURE_CUBE_MAP_ARB:
3440                 gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_2D);
3441                 checkGLcall("glDisable(GL_TEXTURE_2D)");
3442                 gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_3D);
3443                 checkGLcall("glDisable(GL_TEXTURE_3D)");
3444                 if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
3445                 {
3446                     gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_RECTANGLE_ARB);
3447                     checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
3448                 }
3449                 gl_info->gl_ops.gl.p_glEnable(GL_TEXTURE_CUBE_MAP_ARB);
3450                 checkGLcall("glEnable(GL_TEXTURE_CUBE_MAP_ARB)");
3451               break;
3452         }
3453     }
3454     else
3455     {
3456         gl_info->gl_ops.gl.p_glEnable(GL_TEXTURE_2D);
3457         checkGLcall("glEnable(GL_TEXTURE_2D)");
3458         gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_3D);
3459         checkGLcall("glDisable(GL_TEXTURE_3D)");
3460         if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
3461         {
3462             gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_CUBE_MAP_ARB);
3463             checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
3464         }
3465         if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
3466         {
3467             gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_RECTANGLE_ARB);
3468             checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
3469         }
3470         /* Binding textures is done by samplers. A dummy texture will be bound */
3471     }
3472 }
3473
3474 /* Context activation is done by the caller (state handler). */
3475 void sampler_texdim(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
3476 {
3477     DWORD sampler = state_id - STATE_SAMPLER(0);
3478     DWORD mapped_stage = context->swapchain->device->texUnitMap[sampler];
3479
3480     /* No need to enable / disable anything here for unused samplers. The
3481      * tex_colorop handler takes care. Also no action is needed with pixel
3482      * shaders, or if tex_colorop will take care of this business. */
3483     if (mapped_stage == WINED3D_UNMAPPED_STAGE || mapped_stage >= context->gl_info->limits.textures)
3484         return;
3485     if (sampler >= state->lowest_disabled_stage)
3486         return;
3487     if (isStateDirty(context, STATE_TEXTURESTAGE(sampler, WINED3D_TSS_COLOR_OP)))
3488         return;
3489
3490     texture_activate_dimensions(state->textures[sampler], context->gl_info);
3491 }
3492
3493 void *wined3d_rb_alloc(size_t size)
3494 {
3495     return HeapAlloc(GetProcessHeap(), 0, size);
3496 }
3497
3498 void *wined3d_rb_realloc(void *ptr, size_t size)
3499 {
3500     return HeapReAlloc(GetProcessHeap(), 0, ptr, size);
3501 }
3502
3503 void wined3d_rb_free(void *ptr)
3504 {
3505     HeapFree(GetProcessHeap(), 0, ptr);
3506 }
3507
3508 static int ffp_frag_program_key_compare(const void *key, const struct wine_rb_entry *entry)
3509 {
3510     const struct ffp_frag_settings *ka = key;
3511     const struct ffp_frag_settings *kb = &WINE_RB_ENTRY_VALUE(entry, const struct ffp_frag_desc, entry)->settings;
3512
3513     return memcmp(ka, kb, sizeof(*ka));
3514 }
3515
3516 const struct wine_rb_functions wined3d_ffp_frag_program_rb_functions =
3517 {
3518     wined3d_rb_alloc,
3519     wined3d_rb_realloc,
3520     wined3d_rb_free,
3521     ffp_frag_program_key_compare,
3522 };
3523
3524 UINT wined3d_log2i(UINT32 x)
3525 {
3526     static const UINT l[] =
3527     {
3528         ~0U, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
3529           4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
3530           5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
3531           5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
3532           6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
3533           6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
3534           6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
3535           6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
3536           7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
3537           7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
3538           7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
3539           7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
3540           7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
3541           7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
3542           7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
3543           7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
3544     };
3545     UINT32 i;
3546
3547     return (i = x >> 16) ? (x = i >> 8) ? l[x] + 24 : l[i] + 16 : (i = x >> 8) ? l[i] + 8 : l[x];
3548 }
3549
3550 const struct blit_shader *wined3d_select_blitter(const struct wined3d_gl_info *gl_info, enum wined3d_blit_op blit_op,
3551         const RECT *src_rect, DWORD src_usage, enum wined3d_pool src_pool, const struct wined3d_format *src_format,
3552         const RECT *dst_rect, DWORD dst_usage, enum wined3d_pool dst_pool, const struct wined3d_format *dst_format)
3553 {
3554     static const struct blit_shader * const blitters[] =
3555     {
3556         &arbfp_blit,
3557         &ffp_blit,
3558         &cpu_blit,
3559     };
3560     unsigned int i;
3561
3562     for (i = 0; i < sizeof(blitters) / sizeof(*blitters); ++i)
3563     {
3564         if (blitters[i]->blit_supported(gl_info, blit_op,
3565                 src_rect, src_usage, src_pool, src_format,
3566                 dst_rect, dst_usage, dst_pool, dst_format))
3567             return blitters[i];
3568     }
3569
3570     return NULL;
3571 }
3572
3573 void wined3d_get_draw_rect(const struct wined3d_state *state, RECT *rect)
3574 {
3575     const struct wined3d_viewport *vp = &state->viewport;
3576
3577     SetRect(rect, vp->x, vp->y, vp->x + vp->width, vp->y + vp->height);
3578
3579     if (state->render_states[WINED3D_RS_SCISSORTESTENABLE])
3580         IntersectRect(rect, rect, &state->scissor_rect);
3581 }