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