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-2007 Henri Verbeet
   9  * Copyright 2007-2008 Stefan Dösinger for CodeWeavers
  10  *
  11  * This library is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Lesser General Public
  13  * License as published by the Free Software Foundation; either
  14  * version 2.1 of the License, or (at your option) any later version.
  15  *
  16  * This library is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public
  22  * License along with this library; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  24  */
  25
  26 #include "config.h"
  27 #include "wined3d_private.h"
  28
  29 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
  30
  31 /*****************************************************************************
  32  * Pixel format array
  33  *
  34  * For the formats WINED3DFMT_A32B32G32R32F, WINED3DFMT_A16B16G16R16F,
  35  * and WINED3DFMT_A16B16G16R16 do not have correct alpha masks, because the
  36  * high masks do not fit into the 32 bit values needed for ddraw. It is only
  37  * used for ddraw mostly, and to figure out if the format has alpha at all, so
  38  * setting a mask like 0x1 for those surfaces is correct. The 64 and 128 bit
  39  * formats are not usable in 2D rendering because ddraw doesn't support them.
  40  */
  41 static const StaticPixelFormatDesc formats[] = {
  42   /*{WINED3DFORMAT          ,alphamask  ,redmask    ,greenmask  ,bluemask   ,bpp    ,depth  ,stencil,    isFourcc*/
  43     {WINED3DFMT_UNKNOWN     ,0x0        ,0x0        ,0x0        ,0x0        ,1      ,0      ,0          ,FALSE },
  44     /* FourCC formats, kept here to have WINED3DFMT_R8G8B8(=20) at position 20 */
  45     {WINED3DFMT_UYVY        ,0x0        ,0x0        ,0x0        ,0x0        ,1/*?*/ ,0      ,0          ,TRUE  },
  46     {WINED3DFMT_YUY2        ,0x0        ,0x0        ,0x0        ,0x0        ,1/*?*/ ,0      ,0          ,TRUE  },
  47     {WINED3DFMT_YV12        ,0x0        ,0x0        ,0x0        ,0x0        ,1/*?*/ ,0      ,0          ,TRUE  },
  48     {WINED3DFMT_DXT1        ,0x0        ,0x0        ,0x0        ,0x0        ,1      ,0      ,0          ,TRUE  },
  49     {WINED3DFMT_DXT2        ,0x0        ,0x0        ,0x0        ,0x0        ,1      ,0      ,0          ,TRUE  },
  50     {WINED3DFMT_DXT3        ,0x0        ,0x0        ,0x0        ,0x0        ,1      ,0      ,0          ,TRUE  },
  51     {WINED3DFMT_DXT4        ,0x0        ,0x0        ,0x0        ,0x0        ,1      ,0      ,0          ,TRUE  },
  52     {WINED3DFMT_DXT5        ,0x0        ,0x0        ,0x0        ,0x0        ,1      ,0      ,0          ,TRUE  },
  53     {WINED3DFMT_MULTI2_ARGB8,0x0        ,0x0        ,0x0        ,0x0        ,1/*?*/ ,0      ,0          ,TRUE  },
  54     {WINED3DFMT_G8R8_G8B8   ,0x0        ,0x0        ,0x0        ,0x0        ,1/*?*/ ,0      ,0          ,TRUE  },
  55     {WINED3DFMT_R8G8_B8G8   ,0x0        ,0x0        ,0x0        ,0x0        ,1/*?*/ ,0      ,0          ,TRUE  },
  56     /* IEEE formats */
  57     {WINED3DFMT_R32F        ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,0      ,0          ,FALSE },
  58     {WINED3DFMT_G32R32F     ,0x0        ,0x0        ,0x0        ,0x0        ,8      ,0      ,0          ,FALSE },
  59     {WINED3DFMT_A32B32G32R32F,0x1       ,0x0        ,0x0        ,0x0        ,16     ,0      ,0          ,FALSE },
  60     /* Hmm? */
  61     {WINED3DFMT_CxV8U8      ,0x0        ,0x0        ,0x0        ,0x0        ,2      ,0      ,0          ,FALSE },
  62     /* Float */
  63     {WINED3DFMT_R16F        ,0x0        ,0x0        ,0x0        ,0x0        ,2      ,0      ,0          ,FALSE },
  64     {WINED3DFMT_G16R16F     ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,0      ,0          ,FALSE },
  65     {WINED3DFMT_A16B16G16R16F,0x1       ,0x0        ,0x0        ,0x0        ,8      ,0      ,0          ,FALSE },
  66     /* Palettized formats */
  67     {WINED3DFMT_A8P8        ,0x0000ff00 ,0x0        ,0x0        ,0x0        ,2      ,0      ,0          ,FALSE },
  68     {WINED3DFMT_P8          ,0x0        ,0x0        ,0x0        ,0x0        ,1      ,0      ,0          ,FALSE },
  69     /* Standard ARGB formats. Keep WINED3DFMT_R8G8B8(=20) at position 20 */
  70     {WINED3DFMT_R8G8B8      ,0x0        ,0x00ff0000 ,0x0000ff00 ,0x000000ff ,3      ,0      ,0          ,FALSE },
  71     {WINED3DFMT_A8R8G8B8    ,0xff000000 ,0x00ff0000 ,0x0000ff00 ,0x000000ff ,4      ,0      ,0          ,FALSE },
  72     {WINED3DFMT_X8R8G8B8    ,0x0        ,0x00ff0000 ,0x0000ff00 ,0x000000ff ,4      ,0      ,0          ,FALSE },
  73     {WINED3DFMT_R5G6B5      ,0x0        ,0x0000F800 ,0x000007e0 ,0x0000001f ,2      ,0      ,0          ,FALSE },
  74     {WINED3DFMT_X1R5G5B5    ,0x0        ,0x00007c00 ,0x000003e0 ,0x0000001f ,2      ,0      ,0          ,FALSE },
  75     {WINED3DFMT_A1R5G5B5    ,0x00008000 ,0x00007c00 ,0x000003e0 ,0x0000001f ,2      ,0      ,0          ,FALSE },
  76     {WINED3DFMT_A4R4G4B4    ,0x0000f000 ,0x00000f00 ,0x000000f0 ,0x0000000f ,2      ,0      ,0          ,FALSE },
  77     {WINED3DFMT_R3G3B2      ,0x0        ,0x000000e0 ,0x0000001c ,0x00000003 ,1      ,0      ,0          ,FALSE },
  78     {WINED3DFMT_A8          ,0x000000ff ,0x0        ,0x0        ,0x0        ,1      ,0      ,0          ,FALSE },
  79     {WINED3DFMT_A8R3G3B2    ,0x0000ff00 ,0x000000e0 ,0x0000001c ,0x00000003 ,2      ,0      ,0          ,FALSE },
  80     {WINED3DFMT_X4R4G4B4    ,0x0        ,0x00000f00 ,0x000000f0 ,0x0000000f ,2      ,0      ,0          ,FALSE },
  81     {WINED3DFMT_A2B10G10R10 ,0xb0000000 ,0x000003ff ,0x000ffc00 ,0x3ff00000 ,4      ,0      ,0          ,FALSE },
  82     {WINED3DFMT_A8B8G8R8    ,0xff000000 ,0x000000ff ,0x0000ff00 ,0x00ff0000 ,4      ,0      ,0          ,FALSE },
  83     {WINED3DFMT_X8B8G8R8    ,0x0        ,0x000000ff ,0x0000ff00 ,0x00ff0000 ,4      ,0      ,0          ,FALSE },
  84     {WINED3DFMT_G16R16      ,0x0        ,0x0000ffff ,0xffff0000 ,0x0        ,4      ,0      ,0          ,FALSE },
  85     {WINED3DFMT_A2R10G10B10 ,0xb0000000 ,0x3ff00000 ,0x000ffc00 ,0x000003ff ,4      ,0      ,0          ,FALSE },
  86     {WINED3DFMT_A16B16G16R16,0x1        ,0x0000ffff ,0xffff0000 ,0x0        ,8      ,0      ,0          ,FALSE },
  87     /* Luminance */
  88     {WINED3DFMT_L8          ,0x0        ,0x0        ,0x0        ,0x0        ,1      ,0      ,0          ,FALSE },
  89     {WINED3DFMT_A8L8        ,0x0000ff00 ,0x0        ,0x0        ,0x0        ,2      ,0      ,0          ,FALSE },
  90     {WINED3DFMT_A4L4        ,0x000000f0 ,0x0        ,0x0        ,0x0        ,1      ,0      ,0          ,FALSE },
  91     /* Bump mapping stuff */
  92     {WINED3DFMT_V8U8        ,0x0        ,0x0        ,0x0        ,0x0        ,2      ,0      ,0          ,FALSE },
  93     {WINED3DFMT_L6V5U5      ,0x0        ,0x0        ,0x0        ,0x0        ,2      ,0      ,0          ,FALSE },
  94     {WINED3DFMT_X8L8V8U8    ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,0      ,0          ,FALSE },
  95     {WINED3DFMT_Q8W8V8U8    ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,0      ,0          ,FALSE },
  96     {WINED3DFMT_V16U16      ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,0      ,0          ,FALSE },
  97     {WINED3DFMT_W11V11U10   ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,0      ,0          ,FALSE },
  98     {WINED3DFMT_A2W10V10U10 ,0xb0000000 ,0x0        ,0x0        ,0x0        ,4      ,0      ,0          ,FALSE },
  99     /* Depth stencil formats */
 100     {WINED3DFMT_D16_LOCKABLE,0x0        ,0x0        ,0x0        ,0x0        ,2      ,16     ,0          ,FALSE },
 101     {WINED3DFMT_D32         ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,32     ,0          ,FALSE },
 102     {WINED3DFMT_D15S1       ,0x0        ,0x0        ,0x0        ,0x0        ,2      ,15     ,1          ,FALSE },
 103     {WINED3DFMT_D24S8       ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,24     ,8          ,FALSE },
 104     {WINED3DFMT_D24X8       ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,24     ,0          ,FALSE },
 105     {WINED3DFMT_D24X4S4     ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,24     ,4          ,FALSE },
 106     {WINED3DFMT_D16         ,0x0        ,0x0        ,0x0        ,0x0        ,2      ,16     ,0          ,FALSE },
 107     {WINED3DFMT_L16         ,0x0        ,0x0        ,0x0        ,0x0        ,2      ,16      ,0          ,FALSE },
 108     {WINED3DFMT_D32F_LOCKABLE,0x0       ,0x0        ,0x0        ,0x0        ,4      ,32     ,0          ,FALSE },
 109     {WINED3DFMT_D24FS8      ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,24     ,8          ,FALSE },
 110     /* Is this a vertex buffer? */
 111     {WINED3DFMT_VERTEXDATA  ,0x0        ,0x0        ,0x0        ,0x0        ,0      ,0      ,0          ,FALSE },
 112     {WINED3DFMT_INDEX16     ,0x0        ,0x0        ,0x0        ,0x0        ,2      ,0      ,0          ,FALSE },
 113     {WINED3DFMT_INDEX32     ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,0      ,0          ,FALSE },
 114     {WINED3DFMT_Q16W16V16U16,0x0        ,0x0        ,0x0        ,0x0        ,8      ,0      ,0          ,FALSE },
 115 };
 116
 117 typedef struct {
 118     WINED3DFORMAT           fmt;
 119     GLint                   glInternal, glGammaInternal, rtInternal, glFormat, glType;
 120     unsigned int            Flags;
 121 } GlPixelFormatDescTemplate;
 122
 123 /*****************************************************************************
 124  * OpenGL format template. Contains unexciting formats which do not need
 125  * extension checks. The order in this table is independent of the order in
 126  * the table StaticPixelFormatDesc above. Not all formats have to be in this
 127  * table.
 128  */
 129 static const GlPixelFormatDescTemplate gl_formats_template[] = {
 130   /*{                           internal                         ,srgbInternal                           , rtInternal,  format                    ,type \
 131         ,Flags }*/
 132     {WINED3DFMT_UNKNOWN        ,0                                ,0                                      , 0,           0                         ,0
 133         ,0 },
 134     /* FourCC formats */
 135     {WINED3DFMT_UYVY           ,0                                ,0                                      , 0,           0                         ,0
 136         ,0 },
 137     {WINED3DFMT_YUY2           ,0                                ,0                                      , 0,           0                         ,0
 138         ,0 },
 139     {WINED3DFMT_DXT1           ,GL_COMPRESSED_RGBA_S3TC_DXT1_EXT ,GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT , 0,           GL_RGBA                   ,GL_UNSIGNED_BYTE
 140         ,WINED3DFMT_FLAG_FILTERING },
 141     {WINED3DFMT_DXT2           ,GL_COMPRESSED_RGBA_S3TC_DXT3_EXT ,GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT , 0,           GL_RGBA                   ,GL_UNSIGNED_BYTE
 142         ,WINED3DFMT_FLAG_FILTERING },
 143     {WINED3DFMT_DXT3           ,GL_COMPRESSED_RGBA_S3TC_DXT3_EXT ,GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT , 0,           GL_RGBA                   ,GL_UNSIGNED_BYTE
 144         ,WINED3DFMT_FLAG_FILTERING },
 145     {WINED3DFMT_DXT4           ,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT ,GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT , 0,           GL_RGBA                   ,GL_UNSIGNED_BYTE
 146         ,WINED3DFMT_FLAG_FILTERING },
 147     {WINED3DFMT_DXT5           ,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT ,GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT , 0,           GL_RGBA                   ,GL_UNSIGNED_BYTE
 148         ,WINED3DFMT_FLAG_FILTERING },
 149     {WINED3DFMT_MULTI2_ARGB8   ,0                                ,0                                      , 0,           0                         ,0
 150         ,0 },
 151     {WINED3DFMT_G8R8_G8B8      ,0                                ,0                                      , 0,           0                         ,0
 152         ,0 },
 153     {WINED3DFMT_R8G8_B8G8      ,0                                ,0                                      , 0,           0                         ,0
 154         ,0 },
 155     /* IEEE formats */
 156     {WINED3DFMT_R32F           ,GL_RGB32F_ARB                    ,GL_RGB32F_ARB                          , 0,           GL_RED                    ,GL_FLOAT
 157         ,WINED3DFMT_FLAG_RENDERTARGET },
 158     {WINED3DFMT_G32R32F        ,0                                ,0                                      , 0,           0                         ,0
 159         ,WINED3DFMT_FLAG_RENDERTARGET },
 160     {WINED3DFMT_A32B32G32R32F  ,GL_RGBA32F_ARB                   ,GL_RGBA32F_ARB                         , 0,           GL_RGBA                   ,GL_FLOAT
 161         ,WINED3DFMT_FLAG_RENDERTARGET },
 162     /* Hmm? */
 163     {WINED3DFMT_CxV8U8         ,0                                ,0                                      , 0,           0                         ,0
 164         ,0 },
 165     /* Float */
 166     {WINED3DFMT_R16F           ,GL_RGB16F_ARB                    ,GL_RGB16F_ARB                          , 0,           GL_RED                    ,GL_HALF_FLOAT_ARB
 167         ,WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET },
 168     {WINED3DFMT_G16R16F        ,0                                ,0                                      , 0,           0                         ,0
 169         ,WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET },
 170     {WINED3DFMT_A16B16G16R16F  ,GL_RGBA16F_ARB                   ,GL_RGBA16F_ARB                         , 0,           GL_RGBA                   ,GL_HALF_FLOAT_ARB
 171         ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET },
 172     /* Palettized formats */
 173     {WINED3DFMT_A8P8,           0                                ,0                                      , 0,           0                         ,0
 174         ,0 },
 175     {WINED3DFMT_P8,             GL_COLOR_INDEX8_EXT              ,GL_COLOR_INDEX8_EXT                    , 0,           GL_COLOR_INDEX            ,GL_UNSIGNED_BYTE
 176         ,0 },
 177     /* Standard ARGB formats */
 178     {WINED3DFMT_R8G8B8         ,GL_RGB8                          ,GL_RGB8                                , 0,           GL_BGR                    ,GL_UNSIGNED_BYTE
 179         ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET },
 180     {WINED3DFMT_A8R8G8B8       ,GL_RGBA8                         ,GL_SRGB8_ALPHA8_EXT                    , 0,           GL_BGRA                   ,GL_UNSIGNED_INT_8_8_8_8_REV
 181         ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET },
 182     {WINED3DFMT_X8R8G8B8       ,GL_RGB8                          ,GL_SRGB8_EXT                           , 0,           GL_BGRA                   ,GL_UNSIGNED_INT_8_8_8_8_REV
 183         ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET },
 184     {WINED3DFMT_R5G6B5         ,GL_RGB5                          ,GL_RGB5                                , GL_RGB8,     GL_RGB                    ,GL_UNSIGNED_SHORT_5_6_5
 185         ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET },
 186     {WINED3DFMT_X1R5G5B5       ,GL_RGB5                          ,GL_RGB5_A1                             , 0,           GL_BGRA                   ,GL_UNSIGNED_SHORT_1_5_5_5_REV
 187         ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING },
 188     {WINED3DFMT_A1R5G5B5       ,GL_RGB5_A1                       ,GL_RGB5_A1                             , 0,           GL_BGRA                   ,GL_UNSIGNED_SHORT_1_5_5_5_REV
 189         ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING },
 190     {WINED3DFMT_A4R4G4B4       ,GL_RGBA4                         ,GL_SRGB8_ALPHA8_EXT                    , 0,           GL_BGRA                   ,GL_UNSIGNED_SHORT_4_4_4_4_REV
 191         ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING },
 192     {WINED3DFMT_R3G3B2         ,GL_R3_G3_B2                      ,GL_R3_G3_B2                            , 0,           GL_RGB                    ,GL_UNSIGNED_BYTE_3_3_2
 193         ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING },
 194     {WINED3DFMT_A8             ,GL_ALPHA8                        ,GL_ALPHA8                              , 0,           GL_ALPHA                  ,GL_UNSIGNED_BYTE
 195         ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING },
 196     {WINED3DFMT_A8R3G3B2       ,0                                ,0                                      , 0,           0                         ,0
 197         ,0 },
 198     {WINED3DFMT_X4R4G4B4       ,GL_RGB4                          ,GL_RGB4                                , 0,           GL_BGRA                   ,GL_UNSIGNED_SHORT_4_4_4_4_REV
 199         ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING},
 200     {WINED3DFMT_A2B10G10R10    ,GL_RGBA                          ,GL_RGBA                                , 0,           GL_RGBA                   ,GL_UNSIGNED_INT_2_10_10_10_REV
 201         ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING},
 202     {WINED3DFMT_A8B8G8R8       ,GL_RGBA8                         ,GL_RGBA8                               , 0,           GL_RGBA                   ,GL_UNSIGNED_INT_8_8_8_8_REV
 203         ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING},
 204     {WINED3DFMT_X8B8G8R8       ,GL_RGB8                          ,GL_RGB8                                , 0,           GL_RGBA                   ,GL_UNSIGNED_INT_8_8_8_8_REV
 205         ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING},
 206     {WINED3DFMT_G16R16         ,GL_RGB16_EXT                     ,GL_RGB16_EXT                           , 0,           GL_RGB                    ,GL_UNSIGNED_SHORT
 207         ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING },
 208     {WINED3DFMT_A2R10G10B10    ,GL_RGBA                          ,GL_RGBA                                , 0,           GL_BGRA                   ,GL_UNSIGNED_INT_2_10_10_10_REV
 209         ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING },
 210     {WINED3DFMT_A16B16G16R16   ,GL_RGBA16_EXT                    ,GL_RGBA16_EXT                          , 0,           GL_RGBA                   ,GL_UNSIGNED_SHORT
 211         ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET },
 212     /* Luminance */
 213     {WINED3DFMT_L8             ,GL_LUMINANCE8                    ,GL_SLUMINANCE8_EXT                     , 0,           GL_LUMINANCE              ,GL_UNSIGNED_BYTE
 214         ,WINED3DFMT_FLAG_FILTERING },
 215     {WINED3DFMT_A8L8           ,GL_LUMINANCE8_ALPHA8             ,GL_SLUMINANCE8_ALPHA8_EXT              , 0,           GL_LUMINANCE_ALPHA        ,GL_UNSIGNED_BYTE
 216         ,WINED3DFMT_FLAG_FILTERING },
 217     {WINED3DFMT_A4L4           ,GL_LUMINANCE4_ALPHA4             ,GL_LUMINANCE4_ALPHA4                   , 0,           GL_LUMINANCE_ALPHA        ,GL_UNSIGNED_BYTE
 218         ,0 },
 219     /* Bump mapping stuff */
 220     {WINED3DFMT_V8U8           ,GL_DSDT8_NV                      ,GL_DSDT8_NV                            , 0,           GL_DSDT_NV                ,GL_BYTE
 221         ,WINED3DFMT_FLAG_FILTERING },
 222     {WINED3DFMT_L6V5U5         ,GL_DSDT8_MAG8_NV                 ,GL_DSDT8_MAG8_NV                       , 0,           GL_DSDT_MAG_NV            ,GL_BYTE
 223         ,WINED3DFMT_FLAG_FILTERING },
 224     {WINED3DFMT_X8L8V8U8       ,GL_DSDT8_MAG8_INTENSITY8_NV      ,GL_DSDT8_MAG8_INTENSITY8_NV            , 0,           GL_DSDT_MAG_VIB_NV        ,GL_UNSIGNED_INT_8_8_S8_S8_REV_NV
 225         ,WINED3DFMT_FLAG_FILTERING },
 226     {WINED3DFMT_Q8W8V8U8       ,GL_SIGNED_RGBA8_NV               ,GL_SIGNED_RGBA8_NV                     , 0,           GL_RGBA                   ,GL_BYTE
 227         ,WINED3DFMT_FLAG_FILTERING },
 228     {WINED3DFMT_V16U16         ,GL_SIGNED_HILO16_NV              ,GL_SIGNED_HILO16_NV                    , 0,           GL_HILO_NV                ,GL_SHORT
 229         ,WINED3DFMT_FLAG_FILTERING },
 230     {WINED3DFMT_W11V11U10      ,0                                ,0                                      , 0,           0                         ,0
 231         ,0 },
 232     {WINED3DFMT_A2W10V10U10    ,0                                ,0                                      , 0,           0                         ,0
 233         ,0 },
 234     /* Depth stencil formats */
 235     {WINED3DFMT_D16_LOCKABLE   ,GL_DEPTH_COMPONENT24_ARB         ,GL_DEPTH_COMPONENT24_ARB               , 0,           GL_DEPTH_COMPONENT        ,GL_UNSIGNED_SHORT
 236         ,WINED3DFMT_FLAG_DEPTH },
 237     {WINED3DFMT_D32            ,GL_DEPTH_COMPONENT32_ARB         ,GL_DEPTH_COMPONENT32_ARB               , 0,           GL_DEPTH_COMPONENT        ,GL_UNSIGNED_INT
 238         ,WINED3DFMT_FLAG_DEPTH },
 239     {WINED3DFMT_D15S1          ,GL_DEPTH_COMPONENT24_ARB         ,GL_DEPTH_COMPONENT24_ARB               , 0,           GL_DEPTH_COMPONENT        ,GL_UNSIGNED_SHORT
 240         ,WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL },
 241     {WINED3DFMT_D24S8          ,GL_DEPTH_COMPONENT24_ARB         ,GL_DEPTH_COMPONENT24_ARB               , 0,           GL_DEPTH_COMPONENT        ,GL_UNSIGNED_INT
 242         ,WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL },
 243     {WINED3DFMT_D24X8          ,GL_DEPTH_COMPONENT24_ARB         ,GL_DEPTH_COMPONENT24_ARB               , 0,           GL_DEPTH_COMPONENT        ,GL_UNSIGNED_INT
 244         ,WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_DEPTH },
 245     {WINED3DFMT_D24X4S4        ,GL_DEPTH_COMPONENT24_ARB         ,GL_DEPTH_COMPONENT24_ARB               , 0,           GL_DEPTH_COMPONENT        ,GL_UNSIGNED_INT
 246         ,WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL },
 247     {WINED3DFMT_D16            ,GL_DEPTH_COMPONENT24_ARB         ,GL_DEPTH_COMPONENT24_ARB               , 0,           GL_DEPTH_COMPONENT        ,GL_UNSIGNED_SHORT
 248         ,WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_DEPTH },
 249     {WINED3DFMT_L16            ,GL_LUMINANCE16_EXT               ,GL_LUMINANCE16_EXT                     , 0,           GL_LUMINANCE              ,GL_UNSIGNED_SHORT
 250         ,WINED3DFMT_FLAG_FILTERING },
 251     {WINED3DFMT_D32F_LOCKABLE  ,GL_DEPTH_COMPONENT32_ARB         ,GL_DEPTH_COMPONENT32_ARB               , 0,           GL_DEPTH_COMPONENT        ,GL_FLOAT
 252         ,WINED3DFMT_FLAG_DEPTH },
 253     {WINED3DFMT_D24FS8         ,GL_DEPTH_COMPONENT24_ARB         ,GL_DEPTH_COMPONENT24_ARB               , 0,           GL_DEPTH_COMPONENT        ,GL_FLOAT
 254         ,WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL},
 255     /* Is this a vertex buffer? */
 256     {WINED3DFMT_VERTEXDATA     ,0                                ,0                                      , 0,           0                         ,0
 257         ,0 },
 258     {WINED3DFMT_INDEX16        ,0                                ,0                                      , 0,           0                         ,0
 259         ,0 },
 260     {WINED3DFMT_INDEX32        ,0                                ,0                                      , 0,           0                         ,0
 261         ,0 },
 262     {WINED3DFMT_Q16W16V16U16   ,GL_COLOR_INDEX                   ,GL_COLOR_INDEX                         , 0,           GL_COLOR_INDEX            ,GL_UNSIGNED_SHORT
 263         ,0 }
 264 };
 265
 266 static inline int getFmtIdx(WINED3DFORMAT fmt) {
 267     /* First check if the format is at the position of its value.
 268      * This will catch the argb formats before the loop is entered
 269      */
 270     if(fmt < (sizeof(formats) / sizeof(formats[0])) && formats[fmt].format == fmt) {
 271         return fmt;
 272     } else {
 273         unsigned int i;
 274         for(i = 0; i < (sizeof(formats) / sizeof(formats[0])); i++) {
 275             if(formats[i].format == fmt) {
 276                 return i;
 277             }
 278         }
 279     }
 280     return -1;
 281 }
 282
 283 #define GLINFO_LOCATION (*gl_info)
 284 BOOL initPixelFormats(WineD3D_GL_Info *gl_info)
 285 {
 286     unsigned int src;
 287     int dst;
 288
 289     gl_info->gl_formats = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 290                                     sizeof(formats) / sizeof(formats[0]) * sizeof(gl_info->gl_formats[0]));
 291     if(!gl_info->gl_formats) return FALSE;
 292
 293     /* If a format depends on some extensions, remove them from the table above and initialize them
 294      * after this loop
 295      */
 296     for(src = 0; src < sizeof(gl_formats_template) / sizeof(gl_formats_template[0]); src++) {
 297         dst = getFmtIdx(gl_formats_template[src].fmt);
 298         gl_info->gl_formats[dst].glInternal      = gl_formats_template[src].glInternal;
 299         gl_info->gl_formats[dst].glGammaInternal = gl_formats_template[src].glGammaInternal;
 300         gl_info->gl_formats[dst].glFormat        = gl_formats_template[src].glFormat;
 301         gl_info->gl_formats[dst].glType          = gl_formats_template[src].glType;
 302         gl_info->gl_formats[dst].conversion_group= WINED3DFMT_UNKNOWN;
 303         gl_info->gl_formats[dst].Flags           = gl_formats_template[src].Flags;
 304
 305         if(wined3d_settings.offscreen_rendering_mode == ORM_FBO &&
 306            gl_formats_template[src].rtInternal != 0) {
 307             GLuint tex, fb;
 308             GLenum status;
 309
 310             /* Check if the default internal format is supported as a frame buffer target, otherwise
 311              * fall back to the render target internal.
 312              *
 313              * Try to stick to the standard format if possible, this limits precision differences
 314              */
 315             while(glGetError());
 316             glGenTextures(1, &tex);
 317             glBindTexture(GL_TEXTURE_2D, tex);
 318             glTexImage2D(GL_TEXTURE_2D, 0, gl_formats_template[src].glInternal, 16, 16, 0,
 319                          GL_RGBA, GL_UNSIGNED_BYTE, NULL);
 320
 321             GL_EXTCALL(glGenFramebuffersEXT(1, &fb));
 322             GL_EXTCALL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb));
 323             GL_EXTCALL(glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
 324                                                  GL_TEXTURE_2D, tex, 0));
 325
 326             status = GL_EXTCALL(glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT));
 327             GL_EXTCALL(glDeleteFramebuffersEXT(1, &fb));
 328             glDeleteTextures(1, &tex);
 329
 330             checkGLcall("Framebuffer format check");
 331
 332             if(status != GL_FRAMEBUFFER_COMPLETE_EXT) {
 333                 TRACE("Internal format of %s not supported as frame buffer target, using render target internal instead\n",
 334                     debug_d3dformat(gl_formats_template[src].fmt));
 335                 gl_info->gl_formats[dst].rtInternal = gl_formats_template[src].rtInternal;
 336             } else {
 337                 TRACE("Format %s is supported as fbo target\n", debug_d3dformat(gl_formats_template[src].fmt));
 338                 gl_info->gl_formats[dst].rtInternal = gl_formats_template[src].glInternal;
 339             }
 340
 341         } else {
 342             gl_info->gl_formats[dst].rtInternal = gl_formats_template[src].glInternal;
 343         }
 344     }
 345
 346     /* V8U8 is supported natively by GL_ATI_envmap_bumpmap and GL_NV_texture_shader.
 347      * V16U16 is only supported by GL_NV_texture_shader. The formats need fixup if
 348      * their extensions are not available.
 349      *
 350      * In theory, V8U8 and V16U16 need a fixup of the undefined blue channel. OpenGL
 351      * returns 0.0 when sampling from it, DirectX 1.0. This is disabled until we find
 352      * an application that needs this because it causes performance problems due to
 353      * shader recompiling in some games.
 354      */
 355     if(!GL_SUPPORT(ATI_ENVMAP_BUMPMAP) && !GL_SUPPORT(NV_TEXTURE_SHADER2)) {
 356         /* signed -> unsigned fixup */
 357         dst = getFmtIdx(WINED3DFMT_V8U8);
 358         gl_info->gl_formats[dst].conversion_group = WINED3DFMT_V8U8;
 359         dst = getFmtIdx(WINED3DFMT_V16U16);
 360         gl_info->gl_formats[dst].conversion_group = WINED3DFMT_V8U8;
 361     } else if(GL_SUPPORT(ATI_ENVMAP_BUMPMAP)) {
 362         /* signed -> unsigned fixup */
 363         dst = getFmtIdx(WINED3DFMT_V16U16);
 364         gl_info->gl_formats[dst].conversion_group = WINED3DFMT_V16U16;
 365     } else {
 366         /* Blue = 1.0 fixup, disabled for now */
 367 #if 0
 368         dst = getFmtIdx(WINED3DFMT_V8U8);
 369         gl_info->gl_formats[dst].conversion_group = WINED3DFMT_V8U8;
 370         dst = getFmtIdx(WINED3DFMT_V16U16);
 371         gl_info->gl_formats[dst].conversion_group = WINED3DFMT_V8U8;
 372 #endif
 373     }
 374
 375     if(!GL_SUPPORT(NV_TEXTURE_SHADER)) {
 376         /* If GL_NV_texture_shader is not supported, those formats are converted, incompatibly
 377          * with each other
 378          */
 379         dst = getFmtIdx(WINED3DFMT_L6V5U5);
 380         gl_info->gl_formats[dst].conversion_group = WINED3DFMT_L6V5U5;
 381         dst = getFmtIdx(WINED3DFMT_X8L8V8U8);
 382         gl_info->gl_formats[dst].conversion_group = WINED3DFMT_X8L8V8U8;
 383         dst = getFmtIdx(WINED3DFMT_Q8W8V8U8);
 384         gl_info->gl_formats[dst].conversion_group = WINED3DFMT_Q8W8V8U8;
 385     } else {
 386         /* If GL_NV_texture_shader is supported, WINED3DFMT_L6V5U5 and WINED3DFMT_X8L8V8U8
 387          * are converted at surface loading time, but they do not need any modification in
 388          * the shader, thus they are compatible with all WINED3DFMT_UNKNOWN group formats.
 389          * WINED3DFMT_Q8W8V8U8 doesn't even need load-time conversion
 390          */
 391     }
 392
 393     return TRUE;
 394 }
 395
 396 /* NOTE: Make sure these are in the correct numerical order. (see /include/wined3d_types.h) */
 397 static WINED3DGLTYPE const glTypeLookupTemplate[WINED3DDECLTYPE_UNUSED] = {
 398                                   {WINED3DDECLTYPE_FLOAT1,    1, GL_FLOAT           , GL_FALSE ,sizeof(float)},
 399                                   {WINED3DDECLTYPE_FLOAT2,    2, GL_FLOAT           , GL_FALSE ,sizeof(float)},
 400                                   {WINED3DDECLTYPE_FLOAT3,    3, GL_FLOAT           , GL_FALSE ,sizeof(float)},
 401                                   {WINED3DDECLTYPE_FLOAT4,    4, GL_FLOAT           , GL_FALSE ,sizeof(float)},
 402                                   {WINED3DDECLTYPE_D3DCOLOR,  4, GL_UNSIGNED_BYTE   , GL_TRUE  ,sizeof(BYTE)},
 403                                   {WINED3DDECLTYPE_UBYTE4,    4, GL_UNSIGNED_BYTE   , GL_FALSE ,sizeof(BYTE)},
 404                                   {WINED3DDECLTYPE_SHORT2,    2, GL_SHORT           , GL_FALSE ,sizeof(short int)},
 405                                   {WINED3DDECLTYPE_SHORT4,    4, GL_SHORT           , GL_FALSE ,sizeof(short int)},
 406                                   {WINED3DDECLTYPE_UBYTE4N,   4, GL_UNSIGNED_BYTE   , GL_TRUE  ,sizeof(BYTE)},
 407                                   {WINED3DDECLTYPE_SHORT2N,   2, GL_SHORT           , GL_TRUE  ,sizeof(short int)},
 408                                   {WINED3DDECLTYPE_SHORT4N,   4, GL_SHORT           , GL_TRUE  ,sizeof(short int)},
 409                                   {WINED3DDECLTYPE_USHORT2N,  2, GL_UNSIGNED_SHORT  , GL_TRUE  ,sizeof(short int)},
 410                                   {WINED3DDECLTYPE_USHORT4N,  4, GL_UNSIGNED_SHORT  , GL_TRUE  ,sizeof(short int)},
 411                                   {WINED3DDECLTYPE_UDEC3,     3, GL_UNSIGNED_SHORT  , GL_FALSE ,sizeof(short int)},
 412                                   {WINED3DDECLTYPE_DEC3N,     3, GL_SHORT           , GL_TRUE  ,sizeof(short int)},
 413                                   {WINED3DDECLTYPE_FLOAT16_2, 2, GL_HALF_FLOAT_NV   , GL_FALSE ,sizeof(GLhalfNV)},
 414                                   {WINED3DDECLTYPE_FLOAT16_4, 4, GL_HALF_FLOAT_NV   , GL_FALSE ,sizeof(GLhalfNV)}};
 415
 416 void init_type_lookup(WineD3D_GL_Info *gl_info) {
 417     memcpy(gl_info->glTypeLookup, glTypeLookupTemplate, sizeof(glTypeLookupTemplate));
 418     if(!GL_SUPPORT(NV_HALF_FLOAT)) {
 419         /* Do not change the size of the type, it is CPU side. We have to change the GPU-side information though.
 420          * It is the job of the vertex buffer code to make sure that the vbos have the right format
 421          */
 422         gl_info->glTypeLookup[WINED3DDECLTYPE_FLOAT16_2].glType = GL_FLOAT;
 423         gl_info->glTypeLookup[WINED3DDECLTYPE_FLOAT16_4].glType = GL_FLOAT;
 424     }
 425 }
 426
 427 #undef GLINFO_LOCATION
 428
 429 #define GLINFO_LOCATION This->adapter->gl_info
 430
 431 const StaticPixelFormatDesc *getFormatDescEntry(WINED3DFORMAT fmt, WineD3D_GL_Info *gl_info, const GlPixelFormatDesc **glDesc)
 432 {
 433     int idx = getFmtIdx(fmt);
 434
 435     if(idx == -1) {
 436         FIXME("Can't find format %s(%d) in the format lookup table\n", debug_d3dformat(fmt), fmt);
 437         /* Get the caller a valid pointer */
 438         idx = getFmtIdx(WINED3DFMT_UNKNOWN);
 439     }
 440     if(glDesc) {
 441         if(!gl_info->gl_formats) {
 442             /* If we do not have gl format information, provide a dummy NULL format. This is an easy way to make
 443              * all gl caps check return "unsupported" than catching the lack of gl all over the code. ANSI C requires
 444              * static variables to be initialized to 0.
 445              */
 446             static const GlPixelFormatDesc dummyFmt;
 447             *glDesc = &dummyFmt;
 448         } else {
 449             *glDesc = &gl_info->gl_formats[idx];
 450         }
 451     }
 452     return &formats[idx];
 453 }
 454
 455 /*****************************************************************************
 456  * Trace formatting of useful values
 457  */
 458 const char* debug_d3dformat(WINED3DFORMAT fmt) {
 459   switch (fmt) {
 460 #define FMT_TO_STR(fmt) case fmt: return #fmt
 461     FMT_TO_STR(WINED3DFMT_UNKNOWN);
 462     FMT_TO_STR(WINED3DFMT_R8G8B8);
 463     FMT_TO_STR(WINED3DFMT_A8R8G8B8);
 464     FMT_TO_STR(WINED3DFMT_X8R8G8B8);
 465     FMT_TO_STR(WINED3DFMT_R5G6B5);
 466     FMT_TO_STR(WINED3DFMT_X1R5G5B5);
 467     FMT_TO_STR(WINED3DFMT_A1R5G5B5);
 468     FMT_TO_STR(WINED3DFMT_A4R4G4B4);
 469     FMT_TO_STR(WINED3DFMT_R3G3B2);
 470     FMT_TO_STR(WINED3DFMT_A8);
 471     FMT_TO_STR(WINED3DFMT_A8R3G3B2);
 472     FMT_TO_STR(WINED3DFMT_X4R4G4B4);
 473     FMT_TO_STR(WINED3DFMT_A2B10G10R10);
 474     FMT_TO_STR(WINED3DFMT_A8B8G8R8);
 475     FMT_TO_STR(WINED3DFMT_X8B8G8R8);
 476     FMT_TO_STR(WINED3DFMT_G16R16);
 477     FMT_TO_STR(WINED3DFMT_A2R10G10B10);
 478     FMT_TO_STR(WINED3DFMT_A16B16G16R16);
 479     FMT_TO_STR(WINED3DFMT_A8P8);
 480     FMT_TO_STR(WINED3DFMT_P8);
 481     FMT_TO_STR(WINED3DFMT_L8);
 482     FMT_TO_STR(WINED3DFMT_A8L8);
 483     FMT_TO_STR(WINED3DFMT_A4L4);
 484     FMT_TO_STR(WINED3DFMT_V8U8);
 485     FMT_TO_STR(WINED3DFMT_L6V5U5);
 486     FMT_TO_STR(WINED3DFMT_X8L8V8U8);
 487     FMT_TO_STR(WINED3DFMT_Q8W8V8U8);
 488     FMT_TO_STR(WINED3DFMT_V16U16);
 489     FMT_TO_STR(WINED3DFMT_W11V11U10);
 490     FMT_TO_STR(WINED3DFMT_A2W10V10U10);
 491     FMT_TO_STR(WINED3DFMT_UYVY);
 492     FMT_TO_STR(WINED3DFMT_YUY2);
 493     FMT_TO_STR(WINED3DFMT_DXT1);
 494     FMT_TO_STR(WINED3DFMT_DXT2);
 495     FMT_TO_STR(WINED3DFMT_DXT3);
 496     FMT_TO_STR(WINED3DFMT_DXT4);
 497     FMT_TO_STR(WINED3DFMT_DXT5);
 498     FMT_TO_STR(WINED3DFMT_MULTI2_ARGB8);
 499     FMT_TO_STR(WINED3DFMT_G8R8_G8B8);
 500     FMT_TO_STR(WINED3DFMT_R8G8_B8G8);
 501     FMT_TO_STR(WINED3DFMT_D16_LOCKABLE);
 502     FMT_TO_STR(WINED3DFMT_D32);
 503     FMT_TO_STR(WINED3DFMT_D15S1);
 504     FMT_TO_STR(WINED3DFMT_D24S8);
 505     FMT_TO_STR(WINED3DFMT_D24X8);
 506     FMT_TO_STR(WINED3DFMT_D24X4S4);
 507     FMT_TO_STR(WINED3DFMT_D16);
 508     FMT_TO_STR(WINED3DFMT_L16);
 509     FMT_TO_STR(WINED3DFMT_D32F_LOCKABLE);
 510     FMT_TO_STR(WINED3DFMT_D24FS8);
 511     FMT_TO_STR(WINED3DFMT_VERTEXDATA);
 512     FMT_TO_STR(WINED3DFMT_INDEX16);
 513     FMT_TO_STR(WINED3DFMT_INDEX32);
 514     FMT_TO_STR(WINED3DFMT_Q16W16V16U16);
 515     FMT_TO_STR(WINED3DFMT_R16F);
 516     FMT_TO_STR(WINED3DFMT_G16R16F);
 517     FMT_TO_STR(WINED3DFMT_A16B16G16R16F);
 518     FMT_TO_STR(WINED3DFMT_R32F);
 519     FMT_TO_STR(WINED3DFMT_G32R32F);
 520     FMT_TO_STR(WINED3DFMT_A32B32G32R32F);
 521     FMT_TO_STR(WINED3DFMT_CxV8U8);
 522 #undef FMT_TO_STR
 523   default:
 524     {
 525       char fourcc[5];
 526       fourcc[0] = (char)(fmt);
 527       fourcc[1] = (char)(fmt >> 8);
 528       fourcc[2] = (char)(fmt >> 16);
 529       fourcc[3] = (char)(fmt >> 24);
 530       fourcc[4] = 0;
 531       if( isprint(fourcc[0]) && isprint(fourcc[1]) && isprint(fourcc[2]) && isprint(fourcc[3]) )
 532         FIXME("Unrecognized %u (as fourcc: %s) WINED3DFORMAT!\n", fmt, fourcc);
 533       else
 534         FIXME("Unrecognized %u WINED3DFORMAT!\n", fmt);
 535     }
 536     return "unrecognized";
 537   }
 538 }
 539
 540 const char* debug_d3ddevicetype(WINED3DDEVTYPE devtype) {
 541   switch (devtype) {
 542 #define DEVTYPE_TO_STR(dev) case dev: return #dev
 543     DEVTYPE_TO_STR(WINED3DDEVTYPE_HAL);
 544     DEVTYPE_TO_STR(WINED3DDEVTYPE_REF);
 545     DEVTYPE_TO_STR(WINED3DDEVTYPE_SW);
 546 #undef DEVTYPE_TO_STR
 547   default:
 548     FIXME("Unrecognized %u WINED3DDEVTYPE!\n", devtype);
 549     return "unrecognized";
 550   }
 551 }
 552
 553 const char* debug_d3dusage(DWORD usage) {
 554   switch (usage & WINED3DUSAGE_MASK) {
 555 #define WINED3DUSAGE_TO_STR(u) case u: return #u
 556     WINED3DUSAGE_TO_STR(WINED3DUSAGE_RENDERTARGET);
 557     WINED3DUSAGE_TO_STR(WINED3DUSAGE_DEPTHSTENCIL);
 558     WINED3DUSAGE_TO_STR(WINED3DUSAGE_WRITEONLY);
 559     WINED3DUSAGE_TO_STR(WINED3DUSAGE_SOFTWAREPROCESSING);
 560     WINED3DUSAGE_TO_STR(WINED3DUSAGE_DONOTCLIP);
 561     WINED3DUSAGE_TO_STR(WINED3DUSAGE_POINTS);
 562     WINED3DUSAGE_TO_STR(WINED3DUSAGE_RTPATCHES);
 563     WINED3DUSAGE_TO_STR(WINED3DUSAGE_NPATCHES);
 564     WINED3DUSAGE_TO_STR(WINED3DUSAGE_DYNAMIC);
 565     WINED3DUSAGE_TO_STR(WINED3DUSAGE_AUTOGENMIPMAP);
 566     WINED3DUSAGE_TO_STR(WINED3DUSAGE_DMAP);
 567 #undef WINED3DUSAGE_TO_STR
 568   case 0: return "none";
 569   default:
 570     FIXME("Unrecognized %u Usage!\n", usage);
 571     return "unrecognized";
 572   }
 573 }
 574
 575 const char* debug_d3dusagequery(DWORD usagequery) {
 576   switch (usagequery & WINED3DUSAGE_QUERY_MASK) {
 577 #define WINED3DUSAGEQUERY_TO_STR(u) case u: return #u
 578     WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_FILTER);
 579     WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_LEGACYBUMPMAP);
 580     WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING);
 581     WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_SRGBREAD);
 582     WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_SRGBWRITE);
 583     WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_VERTEXTEXTURE);
 584     WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_WRAPANDMIP);
 585 #undef WINED3DUSAGEQUERY_TO_STR
 586   case 0: return "none";
 587   default:
 588     FIXME("Unrecognized %u Usage Query!\n", usagequery);
 589     return "unrecognized";
 590   }
 591 }
 592
 593 const char* debug_d3ddeclmethod(WINED3DDECLMETHOD method) {
 594     switch (method) {
 595 #define WINED3DDECLMETHOD_TO_STR(u) case u: return #u
 596         WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_DEFAULT);
 597         WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_PARTIALU);
 598         WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_PARTIALV);
 599         WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_CROSSUV);
 600         WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_UV);
 601         WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_LOOKUP);
 602         WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_LOOKUPPRESAMPLED);
 603 #undef WINED3DDECLMETHOD_TO_STR
 604         default:
 605             FIXME("Unrecognized %u declaration method!\n", method);
 606             return "unrecognized";
 607     }
 608 }
 609
 610 const char* debug_d3ddecltype(WINED3DDECLTYPE type) {
 611     switch (type) {
 612 #define WINED3DDECLTYPE_TO_STR(u) case u: return #u
 613         WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT1);
 614         WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT2);
 615         WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT3);
 616         WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT4);
 617         WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_D3DCOLOR);
 618         WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_UBYTE4);
 619         WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_SHORT2);
 620         WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_SHORT4);
 621         WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_UBYTE4N);
 622         WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_SHORT2N);
 623         WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_SHORT4N);
 624         WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_USHORT2N);
 625         WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_USHORT4N);
 626         WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_UDEC3);
 627         WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_DEC3N);
 628         WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT16_2);
 629         WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT16_4);
 630         WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_UNUSED);
 631 #undef WINED3DDECLTYPE_TO_STR
 632         default:
 633             FIXME("Unrecognized %u declaration type!\n", type);
 634             return "unrecognized";
 635     }
 636 }
 637
 638 const char* debug_d3ddeclusage(BYTE usage) {
 639     switch (usage) {
 640 #define WINED3DDECLUSAGE_TO_STR(u) case u: return #u
 641         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_POSITION);
 642         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BLENDWEIGHT);
 643         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BLENDINDICES);
 644         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_NORMAL);
 645         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_PSIZE);
 646         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TEXCOORD);
 647         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TANGENT);
 648         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BINORMAL);
 649         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TESSFACTOR);
 650         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_POSITIONT);
 651         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_COLOR);
 652         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_FOG);
 653         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_DEPTH);
 654         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_SAMPLE);
 655 #undef WINED3DDECLUSAGE_TO_STR
 656         default:
 657             FIXME("Unrecognized %u declaration usage!\n", usage);
 658             return "unrecognized";
 659     }
 660 }
 661
 662 const char* debug_d3dresourcetype(WINED3DRESOURCETYPE res) {
 663   switch (res) {
 664 #define RES_TO_STR(res) case res: return #res;
 665     RES_TO_STR(WINED3DRTYPE_SURFACE);
 666     RES_TO_STR(WINED3DRTYPE_VOLUME);
 667     RES_TO_STR(WINED3DRTYPE_TEXTURE);
 668     RES_TO_STR(WINED3DRTYPE_VOLUMETEXTURE);
 669     RES_TO_STR(WINED3DRTYPE_CUBETEXTURE);
 670     RES_TO_STR(WINED3DRTYPE_VERTEXBUFFER);
 671     RES_TO_STR(WINED3DRTYPE_INDEXBUFFER);
 672 #undef  RES_TO_STR
 673   default:
 674     FIXME("Unrecognized %u WINED3DRESOURCETYPE!\n", res);
 675     return "unrecognized";
 676   }
 677 }
 678
 679 const char* debug_d3dprimitivetype(WINED3DPRIMITIVETYPE PrimitiveType) {
 680   switch (PrimitiveType) {
 681 #define PRIM_TO_STR(prim) case prim: return #prim;
 682     PRIM_TO_STR(WINED3DPT_POINTLIST);
 683     PRIM_TO_STR(WINED3DPT_LINELIST);
 684     PRIM_TO_STR(WINED3DPT_LINESTRIP);
 685     PRIM_TO_STR(WINED3DPT_TRIANGLELIST);
 686     PRIM_TO_STR(WINED3DPT_TRIANGLESTRIP);
 687     PRIM_TO_STR(WINED3DPT_TRIANGLEFAN);
 688 #undef  PRIM_TO_STR
 689   default:
 690     FIXME("Unrecognized %u WINED3DPRIMITIVETYPE!\n", PrimitiveType);
 691     return "unrecognized";
 692   }
 693 }
 694
 695 const char* debug_d3drenderstate(DWORD state) {
 696   switch (state) {
 697 #define D3DSTATE_TO_STR(u) case u: return #u
 698     D3DSTATE_TO_STR(WINED3DRS_TEXTUREHANDLE             );
 699     D3DSTATE_TO_STR(WINED3DRS_ANTIALIAS                 );
 700     D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESS            );
 701     D3DSTATE_TO_STR(WINED3DRS_TEXTUREPERSPECTIVE        );
 702     D3DSTATE_TO_STR(WINED3DRS_WRAPU                     );
 703     D3DSTATE_TO_STR(WINED3DRS_WRAPV                     );
 704     D3DSTATE_TO_STR(WINED3DRS_ZENABLE                   );
 705     D3DSTATE_TO_STR(WINED3DRS_FILLMODE                  );
 706     D3DSTATE_TO_STR(WINED3DRS_SHADEMODE                 );
 707     D3DSTATE_TO_STR(WINED3DRS_LINEPATTERN               );
 708     D3DSTATE_TO_STR(WINED3DRS_MONOENABLE                );
 709     D3DSTATE_TO_STR(WINED3DRS_ROP2                      );
 710     D3DSTATE_TO_STR(WINED3DRS_PLANEMASK                 );
 711     D3DSTATE_TO_STR(WINED3DRS_ZWRITEENABLE              );
 712     D3DSTATE_TO_STR(WINED3DRS_ALPHATESTENABLE           );
 713     D3DSTATE_TO_STR(WINED3DRS_LASTPIXEL                 );
 714     D3DSTATE_TO_STR(WINED3DRS_TEXTUREMAG                );
 715     D3DSTATE_TO_STR(WINED3DRS_TEXTUREMIN                );
 716     D3DSTATE_TO_STR(WINED3DRS_SRCBLEND                  );
 717     D3DSTATE_TO_STR(WINED3DRS_DESTBLEND                 );
 718     D3DSTATE_TO_STR(WINED3DRS_TEXTUREMAPBLEND           );
 719     D3DSTATE_TO_STR(WINED3DRS_CULLMODE                  );
 720     D3DSTATE_TO_STR(WINED3DRS_ZFUNC                     );
 721     D3DSTATE_TO_STR(WINED3DRS_ALPHAREF                  );
 722     D3DSTATE_TO_STR(WINED3DRS_ALPHAFUNC                 );
 723     D3DSTATE_TO_STR(WINED3DRS_DITHERENABLE              );
 724     D3DSTATE_TO_STR(WINED3DRS_ALPHABLENDENABLE          );
 725     D3DSTATE_TO_STR(WINED3DRS_FOGENABLE                 );
 726     D3DSTATE_TO_STR(WINED3DRS_SPECULARENABLE            );
 727     D3DSTATE_TO_STR(WINED3DRS_ZVISIBLE                  );
 728     D3DSTATE_TO_STR(WINED3DRS_SUBPIXEL                  );
 729     D3DSTATE_TO_STR(WINED3DRS_SUBPIXELX                 );
 730     D3DSTATE_TO_STR(WINED3DRS_STIPPLEDALPHA             );
 731     D3DSTATE_TO_STR(WINED3DRS_FOGCOLOR                  );
 732     D3DSTATE_TO_STR(WINED3DRS_FOGTABLEMODE              );
 733     D3DSTATE_TO_STR(WINED3DRS_FOGSTART                  );
 734     D3DSTATE_TO_STR(WINED3DRS_FOGEND                    );
 735     D3DSTATE_TO_STR(WINED3DRS_FOGDENSITY                );
 736     D3DSTATE_TO_STR(WINED3DRS_STIPPLEENABLE             );
 737     D3DSTATE_TO_STR(WINED3DRS_EDGEANTIALIAS             );
 738     D3DSTATE_TO_STR(WINED3DRS_COLORKEYENABLE            );
 739     D3DSTATE_TO_STR(WINED3DRS_BORDERCOLOR               );
 740     D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESSU           );
 741     D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESSV           );
 742     D3DSTATE_TO_STR(WINED3DRS_MIPMAPLODBIAS             );
 743     D3DSTATE_TO_STR(WINED3DRS_ZBIAS                     );
 744     D3DSTATE_TO_STR(WINED3DRS_RANGEFOGENABLE            );
 745     D3DSTATE_TO_STR(WINED3DRS_ANISOTROPY                );
 746     D3DSTATE_TO_STR(WINED3DRS_FLUSHBATCH                );
 747     D3DSTATE_TO_STR(WINED3DRS_TRANSLUCENTSORTINDEPENDENT);
 748     D3DSTATE_TO_STR(WINED3DRS_STENCILENABLE             );
 749     D3DSTATE_TO_STR(WINED3DRS_STENCILFAIL               );
 750     D3DSTATE_TO_STR(WINED3DRS_STENCILZFAIL              );
 751     D3DSTATE_TO_STR(WINED3DRS_STENCILPASS               );
 752     D3DSTATE_TO_STR(WINED3DRS_STENCILFUNC               );
 753     D3DSTATE_TO_STR(WINED3DRS_STENCILREF                );
 754     D3DSTATE_TO_STR(WINED3DRS_STENCILMASK               );
 755     D3DSTATE_TO_STR(WINED3DRS_STENCILWRITEMASK          );
 756     D3DSTATE_TO_STR(WINED3DRS_TEXTUREFACTOR             );
 757     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN00          );
 758     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN01          );
 759     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN02          );
 760     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN03          );
 761     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN04          );
 762     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN05          );
 763     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN06          );
 764     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN07          );
 765     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN08          );
 766     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN09          );
 767     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN10          );
 768     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN11          );
 769     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN12          );
 770     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN13          );
 771     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN14          );
 772     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN15          );
 773     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN16          );
 774     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN17          );
 775     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN18          );
 776     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN19          );
 777     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN20          );
 778     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN21          );
 779     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN22          );
 780     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN23          );
 781     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN24          );
 782     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN25          );
 783     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN26          );
 784     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN27          );
 785     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN28          );
 786     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN29          );
 787     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN30          );
 788     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN31          );
 789     D3DSTATE_TO_STR(WINED3DRS_WRAP0                     );
 790     D3DSTATE_TO_STR(WINED3DRS_WRAP1                     );
 791     D3DSTATE_TO_STR(WINED3DRS_WRAP2                     );
 792     D3DSTATE_TO_STR(WINED3DRS_WRAP3                     );
 793     D3DSTATE_TO_STR(WINED3DRS_WRAP4                     );
 794     D3DSTATE_TO_STR(WINED3DRS_WRAP5                     );
 795     D3DSTATE_TO_STR(WINED3DRS_WRAP6                     );
 796     D3DSTATE_TO_STR(WINED3DRS_WRAP7                     );
 797     D3DSTATE_TO_STR(WINED3DRS_CLIPPING                  );
 798     D3DSTATE_TO_STR(WINED3DRS_LIGHTING                  );
 799     D3DSTATE_TO_STR(WINED3DRS_EXTENTS                   );
 800     D3DSTATE_TO_STR(WINED3DRS_AMBIENT                   );
 801     D3DSTATE_TO_STR(WINED3DRS_FOGVERTEXMODE             );
 802     D3DSTATE_TO_STR(WINED3DRS_COLORVERTEX               );
 803     D3DSTATE_TO_STR(WINED3DRS_LOCALVIEWER               );
 804     D3DSTATE_TO_STR(WINED3DRS_NORMALIZENORMALS          );
 805     D3DSTATE_TO_STR(WINED3DRS_COLORKEYBLENDENABLE       );
 806     D3DSTATE_TO_STR(WINED3DRS_DIFFUSEMATERIALSOURCE     );
 807     D3DSTATE_TO_STR(WINED3DRS_SPECULARMATERIALSOURCE    );
 808     D3DSTATE_TO_STR(WINED3DRS_AMBIENTMATERIALSOURCE     );
 809     D3DSTATE_TO_STR(WINED3DRS_EMISSIVEMATERIALSOURCE    );
 810     D3DSTATE_TO_STR(WINED3DRS_VERTEXBLEND               );
 811     D3DSTATE_TO_STR(WINED3DRS_CLIPPLANEENABLE           );
 812     D3DSTATE_TO_STR(WINED3DRS_SOFTWAREVERTEXPROCESSING  );
 813     D3DSTATE_TO_STR(WINED3DRS_POINTSIZE                 );
 814     D3DSTATE_TO_STR(WINED3DRS_POINTSIZE_MIN             );
 815     D3DSTATE_TO_STR(WINED3DRS_POINTSPRITEENABLE         );
 816     D3DSTATE_TO_STR(WINED3DRS_POINTSCALEENABLE          );
 817     D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_A              );
 818     D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_B              );
 819     D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_C              );
 820     D3DSTATE_TO_STR(WINED3DRS_MULTISAMPLEANTIALIAS      );
 821     D3DSTATE_TO_STR(WINED3DRS_MULTISAMPLEMASK           );
 822     D3DSTATE_TO_STR(WINED3DRS_PATCHEDGESTYLE            );
 823     D3DSTATE_TO_STR(WINED3DRS_PATCHSEGMENTS             );
 824     D3DSTATE_TO_STR(WINED3DRS_DEBUGMONITORTOKEN         );
 825     D3DSTATE_TO_STR(WINED3DRS_POINTSIZE_MAX             );
 826     D3DSTATE_TO_STR(WINED3DRS_INDEXEDVERTEXBLENDENABLE  );
 827     D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE          );
 828     D3DSTATE_TO_STR(WINED3DRS_TWEENFACTOR               );
 829     D3DSTATE_TO_STR(WINED3DRS_BLENDOP                   );
 830     D3DSTATE_TO_STR(WINED3DRS_POSITIONDEGREE            );
 831     D3DSTATE_TO_STR(WINED3DRS_NORMALDEGREE              );
 832     D3DSTATE_TO_STR(WINED3DRS_SCISSORTESTENABLE         );
 833     D3DSTATE_TO_STR(WINED3DRS_SLOPESCALEDEPTHBIAS       );
 834     D3DSTATE_TO_STR(WINED3DRS_ANTIALIASEDLINEENABLE     );
 835     D3DSTATE_TO_STR(WINED3DRS_MINTESSELLATIONLEVEL      );
 836     D3DSTATE_TO_STR(WINED3DRS_MAXTESSELLATIONLEVEL      );
 837     D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_X            );
 838     D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_Y            );
 839     D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_Z            );
 840     D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_W            );
 841     D3DSTATE_TO_STR(WINED3DRS_ENABLEADAPTIVETESSELLATION);
 842     D3DSTATE_TO_STR(WINED3DRS_TWOSIDEDSTENCILMODE       );
 843     D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILFAIL           );
 844     D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILZFAIL          );
 845     D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILPASS           );
 846     D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILFUNC           );
 847     D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE1         );
 848     D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE2         );
 849     D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE3         );
 850     D3DSTATE_TO_STR(WINED3DRS_BLENDFACTOR               );
 851     D3DSTATE_TO_STR(WINED3DRS_SRGBWRITEENABLE           );
 852     D3DSTATE_TO_STR(WINED3DRS_DEPTHBIAS                 );
 853     D3DSTATE_TO_STR(WINED3DRS_WRAP8                     );
 854     D3DSTATE_TO_STR(WINED3DRS_WRAP9                     );
 855     D3DSTATE_TO_STR(WINED3DRS_WRAP10                    );
 856     D3DSTATE_TO_STR(WINED3DRS_WRAP11                    );
 857     D3DSTATE_TO_STR(WINED3DRS_WRAP12                    );
 858     D3DSTATE_TO_STR(WINED3DRS_WRAP13                    );
 859     D3DSTATE_TO_STR(WINED3DRS_WRAP14                    );
 860     D3DSTATE_TO_STR(WINED3DRS_WRAP15                    );
 861     D3DSTATE_TO_STR(WINED3DRS_SEPARATEALPHABLENDENABLE  );
 862     D3DSTATE_TO_STR(WINED3DRS_SRCBLENDALPHA             );
 863     D3DSTATE_TO_STR(WINED3DRS_DESTBLENDALPHA            );
 864     D3DSTATE_TO_STR(WINED3DRS_BLENDOPALPHA              );
 865 #undef D3DSTATE_TO_STR
 866   default:
 867     FIXME("Unrecognized %u render state!\n", state);
 868     return "unrecognized";
 869   }
 870 }
 871
 872 const char* debug_d3dsamplerstate(DWORD state) {
 873   switch (state) {
 874 #define D3DSTATE_TO_STR(u) case u: return #u
 875     D3DSTATE_TO_STR(WINED3DSAMP_BORDERCOLOR  );
 876     D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSU     );
 877     D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSV     );
 878     D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSW     );
 879     D3DSTATE_TO_STR(WINED3DSAMP_MAGFILTER    );
 880     D3DSTATE_TO_STR(WINED3DSAMP_MINFILTER    );
 881     D3DSTATE_TO_STR(WINED3DSAMP_MIPFILTER    );
 882     D3DSTATE_TO_STR(WINED3DSAMP_MIPMAPLODBIAS);
 883     D3DSTATE_TO_STR(WINED3DSAMP_MAXMIPLEVEL  );
 884     D3DSTATE_TO_STR(WINED3DSAMP_MAXANISOTROPY);
 885     D3DSTATE_TO_STR(WINED3DSAMP_SRGBTEXTURE  );
 886     D3DSTATE_TO_STR(WINED3DSAMP_ELEMENTINDEX );
 887     D3DSTATE_TO_STR(WINED3DSAMP_DMAPOFFSET   );
 888 #undef D3DSTATE_TO_STR
 889   default:
 890     FIXME("Unrecognized %u sampler state!\n", state);
 891     return "unrecognized";
 892   }
 893 }
 894
 895 const char *debug_d3dtexturefiltertype(WINED3DTEXTUREFILTERTYPE filter_type) {
 896     switch (filter_type) {
 897 #define D3DTEXTUREFILTERTYPE_TO_STR(u) case u: return #u
 898         D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_NONE);
 899         D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_POINT);
 900         D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_LINEAR);
 901         D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_ANISOTROPIC);
 902         D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_FLATCUBIC);
 903         D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_GAUSSIANCUBIC);
 904         D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_PYRAMIDALQUAD);
 905         D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_GAUSSIANQUAD);
 906 #undef D3DTEXTUREFILTERTYPE_TO_STR
 907         default:
 908             FIXME("Unrecognied texture filter type 0x%08x\n", filter_type);
 909             return "unrecognized";
 910     }
 911 }
 912
 913 const char* debug_d3dtexturestate(DWORD state) {
 914   switch (state) {
 915 #define D3DSTATE_TO_STR(u) case u: return #u
 916     D3DSTATE_TO_STR(WINED3DTSS_COLOROP               );
 917     D3DSTATE_TO_STR(WINED3DTSS_COLORARG1             );
 918     D3DSTATE_TO_STR(WINED3DTSS_COLORARG2             );
 919     D3DSTATE_TO_STR(WINED3DTSS_ALPHAOP               );
 920     D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG1             );
 921     D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG2             );
 922     D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT00          );
 923     D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT01          );
 924     D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT10          );
 925     D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT11          );
 926     D3DSTATE_TO_STR(WINED3DTSS_TEXCOORDINDEX         );
 927     D3DSTATE_TO_STR(WINED3DTSS_BUMPENVLSCALE         );
 928     D3DSTATE_TO_STR(WINED3DTSS_BUMPENVLOFFSET        );
 929     D3DSTATE_TO_STR(WINED3DTSS_TEXTURETRANSFORMFLAGS );
 930     D3DSTATE_TO_STR(WINED3DTSS_ADDRESSW              );
 931     D3DSTATE_TO_STR(WINED3DTSS_COLORARG0             );
 932     D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG0             );
 933     D3DSTATE_TO_STR(WINED3DTSS_RESULTARG             );
 934     D3DSTATE_TO_STR(WINED3DTSS_CONSTANT              );
 935 #undef D3DSTATE_TO_STR
 936   case 12:
 937     /* Note WINED3DTSS are not consecutive, so skip these */
 938     return "unused";
 939   default:
 940     FIXME("Unrecognized %u texture state!\n", state);
 941     return "unrecognized";
 942   }
 943 }
 944
 945 const char* debug_d3dtop(WINED3DTEXTUREOP d3dtop) {
 946     switch (d3dtop) {
 947 #define D3DTOP_TO_STR(u) case u: return #u
 948         D3DTOP_TO_STR(WINED3DTOP_DISABLE);
 949         D3DTOP_TO_STR(WINED3DTOP_SELECTARG1);
 950         D3DTOP_TO_STR(WINED3DTOP_SELECTARG2);
 951         D3DTOP_TO_STR(WINED3DTOP_MODULATE);
 952         D3DTOP_TO_STR(WINED3DTOP_MODULATE2X);
 953         D3DTOP_TO_STR(WINED3DTOP_MODULATE4X);
 954         D3DTOP_TO_STR(WINED3DTOP_ADD);
 955         D3DTOP_TO_STR(WINED3DTOP_ADDSIGNED);
 956         D3DTOP_TO_STR(WINED3DTOP_ADDSIGNED2X);
 957         D3DTOP_TO_STR(WINED3DTOP_SUBTRACT);
 958         D3DTOP_TO_STR(WINED3DTOP_ADDSMOOTH);
 959         D3DTOP_TO_STR(WINED3DTOP_BLENDDIFFUSEALPHA);
 960         D3DTOP_TO_STR(WINED3DTOP_BLENDTEXTUREALPHA);
 961         D3DTOP_TO_STR(WINED3DTOP_BLENDFACTORALPHA);
 962         D3DTOP_TO_STR(WINED3DTOP_BLENDTEXTUREALPHAPM);
 963         D3DTOP_TO_STR(WINED3DTOP_BLENDCURRENTALPHA);
 964         D3DTOP_TO_STR(WINED3DTOP_PREMODULATE);
 965         D3DTOP_TO_STR(WINED3DTOP_MODULATEALPHA_ADDCOLOR);
 966         D3DTOP_TO_STR(WINED3DTOP_MODULATECOLOR_ADDALPHA);
 967         D3DTOP_TO_STR(WINED3DTOP_MODULATEINVALPHA_ADDCOLOR);
 968         D3DTOP_TO_STR(WINED3DTOP_MODULATEINVCOLOR_ADDALPHA);
 969         D3DTOP_TO_STR(WINED3DTOP_BUMPENVMAP);
 970         D3DTOP_TO_STR(WINED3DTOP_BUMPENVMAPLUMINANCE);
 971         D3DTOP_TO_STR(WINED3DTOP_DOTPRODUCT3);
 972         D3DTOP_TO_STR(WINED3DTOP_MULTIPLYADD);
 973         D3DTOP_TO_STR(WINED3DTOP_LERP);
 974 #undef D3DTOP_TO_STR
 975         default:
 976             FIXME("Unrecognized %u WINED3DTOP\n", d3dtop);
 977             return "unrecognized";
 978     }
 979 }
 980
 981 const char* debug_d3dtstype(WINED3DTRANSFORMSTATETYPE tstype) {
 982     switch (tstype) {
 983 #define TSTYPE_TO_STR(tstype) case tstype: return #tstype
 984     TSTYPE_TO_STR(WINED3DTS_VIEW);
 985     TSTYPE_TO_STR(WINED3DTS_PROJECTION);
 986     TSTYPE_TO_STR(WINED3DTS_TEXTURE0);
 987     TSTYPE_TO_STR(WINED3DTS_TEXTURE1);
 988     TSTYPE_TO_STR(WINED3DTS_TEXTURE2);
 989     TSTYPE_TO_STR(WINED3DTS_TEXTURE3);
 990     TSTYPE_TO_STR(WINED3DTS_TEXTURE4);
 991     TSTYPE_TO_STR(WINED3DTS_TEXTURE5);
 992     TSTYPE_TO_STR(WINED3DTS_TEXTURE6);
 993     TSTYPE_TO_STR(WINED3DTS_TEXTURE7);
 994     TSTYPE_TO_STR(WINED3DTS_WORLDMATRIX(0));
 995 #undef TSTYPE_TO_STR
 996     default:
 997         if (tstype > 256 && tstype < 512) {
 998             FIXME("WINED3DTS_WORLDMATRIX(%u). 1..255 not currently supported\n", tstype);
 999             return ("WINED3DTS_WORLDMATRIX > 0");
1000         }
1001         FIXME("Unrecognized %u WINED3DTS\n", tstype);
1002         return "unrecognized";
1003     }
1004 }
1005
1006 const char* debug_d3dpool(WINED3DPOOL Pool) {
1007   switch (Pool) {
1008 #define POOL_TO_STR(p) case p: return #p;
1009     POOL_TO_STR(WINED3DPOOL_DEFAULT);
1010     POOL_TO_STR(WINED3DPOOL_MANAGED);
1011     POOL_TO_STR(WINED3DPOOL_SYSTEMMEM);
1012     POOL_TO_STR(WINED3DPOOL_SCRATCH);
1013 #undef  POOL_TO_STR
1014   default:
1015     FIXME("Unrecognized %u WINED3DPOOL!\n", Pool);
1016     return "unrecognized";
1017   }
1018 }
1019
1020 const char *debug_fbostatus(GLenum status) {
1021     switch(status) {
1022 #define FBOSTATUS_TO_STR(u) case u: return #u
1023         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_COMPLETE_EXT);
1024         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT);
1025         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT);
1026         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT);
1027         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT);
1028         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT);
1029         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT);
1030         FBOSTATUS_TO_STR(GL_FRAMEBUFFER_UNSUPPORTED_EXT);
1031 #undef FBOSTATUS_TO_STR
1032         default:
1033             FIXME("Unrecognied FBO status 0x%08x\n", status);
1034             return "unrecognized";
1035     }
1036 }
1037
1038 const char *debug_glerror(GLenum error) {
1039     switch(error) {
1040 #define GLERROR_TO_STR(u) case u: return #u
1041         GLERROR_TO_STR(GL_NO_ERROR);
1042         GLERROR_TO_STR(GL_INVALID_ENUM);
1043         GLERROR_TO_STR(GL_INVALID_VALUE);
1044         GLERROR_TO_STR(GL_INVALID_OPERATION);
1045         GLERROR_TO_STR(GL_STACK_OVERFLOW);
1046         GLERROR_TO_STR(GL_STACK_UNDERFLOW);
1047         GLERROR_TO_STR(GL_OUT_OF_MEMORY);
1048         GLERROR_TO_STR(GL_INVALID_FRAMEBUFFER_OPERATION_EXT);
1049 #undef GLERROR_TO_STR
1050         default:
1051             FIXME("Unrecognied GL error 0x%08x\n", error);
1052             return "unrecognized";
1053     }
1054 }
1055
1056 const char *debug_d3dbasis(WINED3DBASISTYPE basis) {
1057     switch(basis) {
1058         case WINED3DBASIS_BEZIER:       return "WINED3DBASIS_BEZIER";
1059         case WINED3DBASIS_BSPLINE:      return "WINED3DBASIS_BSPLINE";
1060         case WINED3DBASIS_INTERPOLATE:  return "WINED3DBASIS_INTERPOLATE";
1061         default:                        return "unrecognized";
1062     }
1063 }
1064
1065 const char *debug_d3ddegree(WINED3DDEGREETYPE degree) {
1066     switch(degree) {
1067         case WINED3DDEGREE_LINEAR:      return "WINED3DDEGREE_LINEAR";
1068         case WINED3DDEGREE_QUADRATIC:   return "WINED3DDEGREE_QUADRATIC";
1069         case WINED3DDEGREE_CUBIC:       return "WINED3DDEGREE_CUBIC";
1070         case WINED3DDEGREE_QUINTIC:     return "WINED3DDEGREE_QUINTIC";
1071         default:                        return "unrecognized";
1072     }
1073 }
1074
1075 /*****************************************************************************
1076  * Useful functions mapping GL <-> D3D values
1077  */
1078 GLenum StencilOp(DWORD op) {
1079     switch(op) {
1080     case WINED3DSTENCILOP_KEEP    : return GL_KEEP;
1081     case WINED3DSTENCILOP_ZERO    : return GL_ZERO;
1082     case WINED3DSTENCILOP_REPLACE : return GL_REPLACE;
1083     case WINED3DSTENCILOP_INCRSAT : return GL_INCR;
1084     case WINED3DSTENCILOP_DECRSAT : return GL_DECR;
1085     case WINED3DSTENCILOP_INVERT  : return GL_INVERT;
1086     case WINED3DSTENCILOP_INCR    : return GL_INCR_WRAP_EXT;
1087     case WINED3DSTENCILOP_DECR    : return GL_DECR_WRAP_EXT;
1088     default:
1089         FIXME("Unrecognized stencil op %d\n", op);
1090         return GL_KEEP;
1091     }
1092 }
1093
1094 GLenum CompareFunc(DWORD func) {
1095     switch ((WINED3DCMPFUNC)func) {
1096     case WINED3DCMP_NEVER        : return GL_NEVER;
1097     case WINED3DCMP_LESS         : return GL_LESS;
1098     case WINED3DCMP_EQUAL        : return GL_EQUAL;
1099     case WINED3DCMP_LESSEQUAL    : return GL_LEQUAL;
1100     case WINED3DCMP_GREATER      : return GL_GREATER;
1101     case WINED3DCMP_NOTEQUAL     : return GL_NOTEQUAL;
1102     case WINED3DCMP_GREATEREQUAL : return GL_GEQUAL;
1103     case WINED3DCMP_ALWAYS       : return GL_ALWAYS;
1104     default:
1105         FIXME("Unrecognized WINED3DCMPFUNC value %d\n", func);
1106         return 0;
1107     }
1108 }
1109
1110 BOOL is_invalid_op(IWineD3DDeviceImpl *This, int stage, WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3) {
1111     if (op == WINED3DTOP_DISABLE) return FALSE;
1112     if (This->stateBlock->textures[stage]) return FALSE;
1113
1114     if ((arg1 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
1115             && op != WINED3DTOP_SELECTARG2) return TRUE;
1116     if ((arg2 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
1117             && op != WINED3DTOP_SELECTARG1) return TRUE;
1118     if ((arg3 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
1119             && (op == WINED3DTOP_MULTIPLYADD || op == WINED3DTOP_LERP)) return TRUE;
1120
1121     return FALSE;
1122 }
1123
1124 /* Setup this textures matrix according to the texture flags*/
1125 void set_texture_matrix(const float *smat, DWORD flags, BOOL calculatedCoords, BOOL transformed, DWORD coordtype)
1126 {
1127     float mat[16];
1128
1129     glMatrixMode(GL_TEXTURE);
1130     checkGLcall("glMatrixMode(GL_TEXTURE)");
1131
1132     if (flags == WINED3DTTFF_DISABLE || flags == WINED3DTTFF_COUNT1 || transformed) {
1133         glLoadIdentity();
1134         checkGLcall("glLoadIdentity()");
1135         return;
1136     }
1137
1138     if (flags == (WINED3DTTFF_COUNT1|WINED3DTTFF_PROJECTED)) {
1139         ERR("Invalid texture transform flags: WINED3DTTFF_COUNT1|WINED3DTTFF_PROJECTED\n");
1140         return;
1141     }
1142
1143     memcpy(mat, smat, 16 * sizeof(float));
1144
1145     if (flags & WINED3DTTFF_PROJECTED) {
1146         switch (flags & ~WINED3DTTFF_PROJECTED) {
1147         case WINED3DTTFF_COUNT2:
1148             mat[3] = mat[1], mat[7] = mat[5], mat[11] = mat[9], mat[15] = mat[13];
1149             mat[1] = mat[5] = mat[9] = mat[13] = 0;
1150             break;
1151         case WINED3DTTFF_COUNT3:
1152             mat[3] = mat[2], mat[7] = mat[6], mat[11] = mat[10], mat[15] = mat[14];
1153             mat[2] = mat[6] = mat[10] = mat[14] = 0;
1154             break;
1155         }
1156     } else { /* under directx the R/Z coord can be used for translation, under opengl we use the Q coord instead */
1157         if(!calculatedCoords) {
1158             switch(coordtype) {
1159                 case WINED3DDECLTYPE_FLOAT1:
1160                     /* Direct3D passes the default 1.0 in the 2nd coord, while gl passes it in the 4th.
1161                      * swap 2nd and 4th coord. No need to store the value of mat[12] in mat[4] because
1162                      * the input value to the transformation will be 0, so the matrix value is irrelevant
1163                      */
1164                     mat[12] = mat[4];
1165                     mat[13] = mat[5];
1166                     mat[14] = mat[6];
1167                     mat[15] = mat[7];
1168                     break;
1169                 case WINED3DDECLTYPE_FLOAT2:
1170                     /* See above, just 3rd and 4th coord
1171                     */
1172                     mat[12] = mat[8];
1173                     mat[13] = mat[9];
1174                     mat[14] = mat[10];
1175                     mat[15] = mat[11];
1176                     break;
1177                 case WINED3DDECLTYPE_FLOAT3: /* Opengl defaults match dx defaults */
1178                 case WINED3DDECLTYPE_FLOAT4: /* No defaults apply, all app defined */
1179
1180                 /* This is to prevent swapping the matrix lines and put the default 4th coord = 1.0
1181                  * into a bad place. The division elimination below will apply to make sure the
1182                  * 1.0 doesn't do anything bad. The caller will set this value if the stride is 0
1183                  */
1184                 case WINED3DDECLTYPE_UNUSED: /* No texture coords, 0/0/0/1 defaults are passed */
1185                     break;
1186                 default:
1187                     FIXME("Unexpected fixed function texture coord input\n");
1188             }
1189         }
1190         switch (flags & ~WINED3DTTFF_PROJECTED) {
1191             /* case WINED3DTTFF_COUNT1: Won't ever get here */
1192             case WINED3DTTFF_COUNT2: mat[2] = mat[6] = mat[10] = mat[14] = 0;
1193             /* OpenGL divides the first 3 vertex coord by the 4th by default,
1194              * which is essentially the same as D3DTTFF_PROJECTED. Make sure that
1195              * the 4th coord evaluates to 1.0 to eliminate that.
1196              *
1197              * If the fixed function pipeline is used, the 4th value remains unused,
1198              * so there is no danger in doing this. With vertex shaders we have a
1199              * problem. Should an app hit that problem, the code here would have to
1200              * check for pixel shaders, and the shader has to undo the default gl divide.
1201              *
1202              * A more serious problem occurs if the app passes 4 coordinates in, and the
1203              * 4th is != 1.0(opengl default). This would have to be fixed in drawStridedSlow
1204              * or a replacement shader
1205              */
1206             default: mat[3] = mat[7] = mat[11] = 0; mat[15] = 1;
1207         }
1208     }
1209
1210     glLoadMatrixf(mat);
1211     checkGLcall("glLoadMatrixf(mat)");
1212 }
1213 #undef GLINFO_LOCATION
1214
1215 #define GLINFO_LOCATION ((IWineD3DImpl *)(This->wineD3D))->gl_info
1216
1217 /* This small helper function is used to convert a bitmask into the number of masked bits */
1218 unsigned int count_bits(unsigned int mask)
1219 {
1220     unsigned int count;
1221     for (count = 0; mask; ++count)
1222     {
1223         mask &= mask - 1;
1224     }
1225     return count;
1226 }
1227
1228 /* Helper function for retrieving color info for ChoosePixelFormat and wglChoosePixelFormatARB.
1229  * The later function requires individual color components. */
1230 BOOL getColorBits(WINED3DFORMAT fmt, short *redSize, short *greenSize, short *blueSize, short *alphaSize, short *totalSize)
1231 {
1232     const StaticPixelFormatDesc *desc;
1233
1234     TRACE("fmt: %s\n", debug_d3dformat(fmt));
1235     switch(fmt)
1236     {
1237         case WINED3DFMT_X8R8G8B8:
1238         case WINED3DFMT_R8G8B8:
1239         case WINED3DFMT_A8R8G8B8:
1240         case WINED3DFMT_A2R10G10B10:
1241         case WINED3DFMT_X1R5G5B5:
1242         case WINED3DFMT_A1R5G5B5:
1243         case WINED3DFMT_R5G6B5:
1244         case WINED3DFMT_X4R4G4B4:
1245         case WINED3DFMT_A4R4G4B4:
1246         case WINED3DFMT_R3G3B2:
1247         case WINED3DFMT_A8P8:
1248         case WINED3DFMT_P8:
1249             break;
1250         default:
1251             ERR("Unsupported format: %s\n", debug_d3dformat(fmt));
1252             return FALSE;
1253     }
1254
1255     desc = getFormatDescEntry(fmt, NULL, NULL);
1256     if(!desc)
1257     {
1258         ERR("Unable to look up format: 0x%x\n", fmt);
1259         return FALSE;
1260     }
1261     *redSize = count_bits(desc->redMask);
1262     *greenSize = count_bits(desc->greenMask);
1263     *blueSize = count_bits(desc->blueMask);
1264     *alphaSize = count_bits(desc->alphaMask);
1265     *totalSize = *redSize + *greenSize + *blueSize + *alphaSize;
1266
1267     TRACE("Returning red:  %d, green: %d, blue: %d, alpha: %d, total: %d for fmt=%s\n", *redSize, *greenSize, *blueSize, *alphaSize, *totalSize, debug_d3dformat(fmt));
1268     return TRUE;
1269 }
1270
1271 /* Helper function for retrieving depth/stencil info for ChoosePixelFormat and wglChoosePixelFormatARB */
1272 BOOL getDepthStencilBits(WINED3DFORMAT fmt, short *depthSize, short *stencilSize)
1273 {
1274     const StaticPixelFormatDesc *desc;
1275
1276     TRACE("fmt: %s\n", debug_d3dformat(fmt));
1277     switch(fmt)
1278     {
1279         case WINED3DFMT_D16_LOCKABLE:
1280         case WINED3DFMT_D16:
1281         case WINED3DFMT_D15S1:
1282         case WINED3DFMT_D24X8:
1283         case WINED3DFMT_D24X4S4:
1284         case WINED3DFMT_D24S8:
1285         case WINED3DFMT_D24FS8:
1286         case WINED3DFMT_D32:
1287         case WINED3DFMT_D32F_LOCKABLE:
1288             break;
1289         default:
1290             FIXME("Unsupported stencil format: %s\n", debug_d3dformat(fmt));
1291             return FALSE;
1292     }
1293
1294     desc = getFormatDescEntry(fmt, NULL, NULL);
1295     if(!desc)
1296     {
1297         ERR("Unable to look up format: 0x%x\n", fmt);
1298         return FALSE;
1299     }
1300     *depthSize = desc->depthSize;
1301     *stencilSize = desc->stencilSize;
1302
1303     TRACE("Returning depthSize: %d and stencilSize: %d for fmt=%s\n", *depthSize, *stencilSize, debug_d3dformat(fmt));
1304     return TRUE;
1305 }
1306
1307 #undef GLINFO_LOCATION
1308
1309 /* DirectDraw stuff */
1310 WINED3DFORMAT pixelformat_for_depth(DWORD depth) {
1311     switch(depth) {
1312         case 8:  return WINED3DFMT_P8;
1313         case 15: return WINED3DFMT_X1R5G5B5;
1314         case 16: return WINED3DFMT_R5G6B5;
1315         case 24: return WINED3DFMT_X8R8G8B8; /* Robots needs 24bit to be X8R8G8B8 */
1316         case 32: return WINED3DFMT_X8R8G8B8; /* EVE online and the Fur demo need 32bit AdapterDisplayMode to return X8R8G8B8 */
1317         default: return WINED3DFMT_UNKNOWN;
1318     }
1319 }
1320
1321 void multiply_matrix(WINED3DMATRIX *dest, const WINED3DMATRIX *src1, const WINED3DMATRIX *src2) {
1322     WINED3DMATRIX temp;
1323
1324     /* Now do the multiplication 'by hand'.
1325        I know that all this could be optimised, but this will be done later :-) */
1326     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);
1327     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);
1328     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);
1329     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);
1330
1331     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);
1332     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);
1333     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);
1334     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);
1335
1336     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);
1337     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);
1338     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);
1339     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);
1340
1341     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);
1342     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);
1343     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);
1344     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);
1345
1346     /* And copy the new matrix in the good storage.. */
1347     memcpy(dest, &temp, 16 * sizeof(float));
1348 }
1349
1350 DWORD get_flexible_vertex_size(DWORD d3dvtVertexType) {
1351     DWORD size = 0;
1352     int i;
1353     int numTextures = (d3dvtVertexType & WINED3DFVF_TEXCOUNT_MASK) >> WINED3DFVF_TEXCOUNT_SHIFT;
1354
1355     if (d3dvtVertexType & WINED3DFVF_NORMAL) size += 3 * sizeof(float);
1356     if (d3dvtVertexType & WINED3DFVF_DIFFUSE) size += sizeof(DWORD);
1357     if (d3dvtVertexType & WINED3DFVF_SPECULAR) size += sizeof(DWORD);
1358     if (d3dvtVertexType & WINED3DFVF_PSIZE) size += sizeof(DWORD);
1359     switch (d3dvtVertexType & WINED3DFVF_POSITION_MASK) {
1360         case WINED3DFVF_XYZ:    size += 3 * sizeof(float); break;
1361         case WINED3DFVF_XYZRHW: size += 4 * sizeof(float); break;
1362         case WINED3DFVF_XYZB1:  size += 4 * sizeof(float); break;
1363         case WINED3DFVF_XYZB2:  size += 5 * sizeof(float); break;
1364         case WINED3DFVF_XYZB3:  size += 6 * sizeof(float); break;
1365         case WINED3DFVF_XYZB4:  size += 7 * sizeof(float); break;
1366         case WINED3DFVF_XYZB5:  size += 8 * sizeof(float); break;
1367         default: ERR("Unexpected position mask\n");
1368     }
1369     for (i = 0; i < numTextures; i++) {
1370         size += GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType, i) * sizeof(float);
1371     }
1372
1373     return size;
1374 }
1375
1376 /***********************************************************************
1377  * CalculateTexRect
1378  *
1379  * Calculates the dimensions of the opengl texture used for blits.
1380  * Handled oversized opengl textures and updates the source rectangle
1381  * accordingly
1382  *
1383  * Params:
1384  *  This: Surface to operate on
1385  *  Rect: Requested rectangle
1386  *
1387  * Returns:
1388  *  TRUE if the texture part can be loaded,
1389  *  FALSE otherwise
1390  *
1391  *********************************************************************/
1392 #define GLINFO_LOCATION This->resource.wineD3DDevice->adapter->gl_info
1393
1394 BOOL CalculateTexRect(IWineD3DSurfaceImpl *This, RECT *Rect, float glTexCoord[4]) {
1395     int x1 = Rect->left, x2 = Rect->right;
1396     int y1 = Rect->top, y2 = Rect->bottom;
1397     GLint maxSize = GL_LIMITS(texture_size);
1398
1399     TRACE("(%p)->(%d,%d)-(%d,%d)\n", This,
1400           Rect->left, Rect->top, Rect->right, Rect->bottom);
1401
1402     /* The sizes might be reversed */
1403     if(Rect->left > Rect->right) {
1404         x1 = Rect->right;
1405         x2 = Rect->left;
1406     }
1407     if(Rect->top > Rect->bottom) {
1408         y1 = Rect->bottom;
1409         y2 = Rect->top;
1410     }
1411
1412     /* No oversized texture? This is easy */
1413     if(!(This->Flags & SFLAG_OVERSIZE)) {
1414         /* Which rect from the texture do I need? */
1415         if(This->glDescription.target == GL_TEXTURE_RECTANGLE_ARB) {
1416             glTexCoord[0] = (float) Rect->left;
1417             glTexCoord[2] = (float) Rect->top;
1418             glTexCoord[1] = (float) Rect->right;
1419             glTexCoord[3] = (float) Rect->bottom;
1420         } else {
1421             glTexCoord[0] = (float) Rect->left / (float) This->pow2Width;
1422             glTexCoord[2] = (float) Rect->top / (float) This->pow2Height;
1423             glTexCoord[1] = (float) Rect->right / (float) This->pow2Width;
1424             glTexCoord[3] = (float) Rect->bottom / (float) This->pow2Height;
1425         }
1426
1427         return TRUE;
1428     } else {
1429         /* Check if we can succeed at all */
1430         if( (x2 - x1) > maxSize ||
1431             (y2 - y1) > maxSize ) {
1432             TRACE("Requested rectangle is too large for gl\n");
1433             return FALSE;
1434         }
1435
1436         /* A part of the texture has to be picked. First, check if
1437          * some texture part is loaded already, if yes try to re-use it.
1438          * If the texture is dirty, or the part can't be used,
1439          * re-position the part to load
1440          */
1441         if(This->Flags & SFLAG_INTEXTURE) {
1442             if(This->glRect.left <= x1 && This->glRect.right >= x2 &&
1443                This->glRect.top <= y1 && This->glRect.bottom >= x2 ) {
1444                 /* Ok, the rectangle is ok, re-use it */
1445                 TRACE("Using existing gl Texture\n");
1446             } else {
1447                 /* Rectangle is not ok, dirtify the texture to reload it */
1448                 TRACE("Dirtifying texture to force reload\n");
1449                 This->Flags &= ~SFLAG_INTEXTURE;
1450             }
1451         }
1452
1453         /* Now if we are dirty(no else if!) */
1454         if(!(This->Flags & SFLAG_INTEXTURE)) {
1455             /* Set the new rectangle. Use the following strategy:
1456              * 1) Use as big textures as possible.
1457              * 2) Place the texture part in the way that the requested
1458              *    part is in the middle of the texture(well, almost)
1459              * 3) If the texture is moved over the edges of the
1460              *    surface, replace it nicely
1461              * 4) If the coord is not limiting the texture size,
1462              *    use the whole size
1463              */
1464             if((This->pow2Width) > maxSize) {
1465                 This->glRect.left = x1 - maxSize / 2;
1466                 if(This->glRect.left < 0) {
1467                     This->glRect.left = 0;
1468                 }
1469                 This->glRect.right = This->glRect.left + maxSize;
1470                 if(This->glRect.right > This->currentDesc.Width) {
1471                     This->glRect.right = This->currentDesc.Width;
1472                     This->glRect.left = This->glRect.right - maxSize;
1473                 }
1474             } else {
1475                 This->glRect.left = 0;
1476                 This->glRect.right = This->pow2Width;
1477             }
1478
1479             if(This->pow2Height > maxSize) {
1480                 This->glRect.top = x1 - GL_LIMITS(texture_size) / 2;
1481                 if(This->glRect.top < 0) This->glRect.top = 0;
1482                 This->glRect.bottom = This->glRect.left + maxSize;
1483                 if(This->glRect.bottom > This->currentDesc.Height) {
1484                     This->glRect.bottom = This->currentDesc.Height;
1485                     This->glRect.top = This->glRect.bottom - maxSize;
1486                 }
1487             } else {
1488                 This->glRect.top = 0;
1489                 This->glRect.bottom = This->pow2Height;
1490             }
1491             TRACE("(%p): Using rect (%d,%d)-(%d,%d)\n", This,
1492                    This->glRect.left, This->glRect.top, This->glRect.right, This->glRect.bottom);
1493         }
1494
1495         /* Re-calculate the rect to draw */
1496         Rect->left -= This->glRect.left;
1497         Rect->right -= This->glRect.left;
1498         Rect->top -= This->glRect.top;
1499         Rect->bottom -= This->glRect.top;
1500
1501         /* Get the gl coordinates. The gl rectangle is a power of 2, eigher the max size,
1502          * or the pow2Width / pow2Height of the surface.
1503          *
1504          * Can never be GL_TEXTURE_RECTANGLE_ARB because oversized surfaces are always set up
1505          * as regular GL_TEXTURE_2D.
1506          */
1507         glTexCoord[0] = (float) Rect->left / (float) (This->glRect.right - This->glRect.left);
1508         glTexCoord[2] = (float) Rect->top / (float) (This->glRect.bottom - This->glRect.top);
1509         glTexCoord[1] = (float) Rect->right / (float) (This->glRect.right - This->glRect.left);
1510         glTexCoord[3] = (float) Rect->bottom / (float) (This->glRect.bottom - This->glRect.top);
1511     }
1512     return TRUE;
1513 }
1514 #undef GLINFO_LOCATION
1515
1516 /* Hash table functions */
1517
1518 hash_table_t *hash_table_create(hash_function_t *hash_function, compare_function_t *compare_function)
1519 {
1520     hash_table_t *table;
1521     unsigned int initial_size = 8;
1522
1523     table = HeapAlloc(GetProcessHeap(), 0, sizeof(hash_table_t) + (initial_size * sizeof(struct list)));
1524     if (!table)
1525     {
1526         ERR("Failed to allocate table, returning NULL.\n");
1527         return NULL;
1528     }
1529
1530     table->hash_function = hash_function;
1531     table->compare_function = compare_function;
1532
1533     table->grow_size = initial_size - (initial_size >> 2);
1534     table->shrink_size = 0;
1535
1536     table->buckets = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, initial_size * sizeof(struct list));
1537     if (!table->buckets)
1538     {
1539         ERR("Failed to allocate table buckets, returning NULL.\n");
1540         HeapFree(GetProcessHeap(), 0, table);
1541         return NULL;
1542     }
1543     table->bucket_count = initial_size;
1544
1545     table->entries = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, table->grow_size * sizeof(hash_table_entry_t));
1546     if (!table->entries)
1547     {
1548         ERR("Failed to allocate table entries, returning NULL.\n");
1549         HeapFree(GetProcessHeap(), 0, table->buckets);
1550         HeapFree(GetProcessHeap(), 0, table);
1551         return NULL;
1552     }
1553     table->entry_count = 0;
1554
1555     list_init(&table->free_entries);
1556     table->count = 0;
1557
1558     return table;
1559 }
1560
1561 void hash_table_destroy(hash_table_t *table)
1562 {
1563     unsigned int i = 0;
1564
1565     for (i = 0; i < table->entry_count; ++i)
1566     {
1567         HeapFree(GetProcessHeap(), 0, table->entries[i].key);
1568     }
1569
1570     HeapFree(GetProcessHeap(), 0, table->entries);
1571     HeapFree(GetProcessHeap(), 0, table->buckets);
1572     HeapFree(GetProcessHeap(), 0, table);
1573 }
1574
1575 static inline hash_table_entry_t *hash_table_get_by_idx(hash_table_t *table, void *key, unsigned int idx)
1576 {
1577     hash_table_entry_t *entry;
1578
1579     if (table->buckets[idx].next)
1580         LIST_FOR_EACH_ENTRY(entry, &(table->buckets[idx]), hash_table_entry_t, entry)
1581             if (table->compare_function(entry->key, key)) return entry;
1582
1583     return NULL;
1584 }
1585
1586 static BOOL hash_table_resize(hash_table_t *table, unsigned int new_bucket_count)
1587 {
1588     unsigned int new_entry_count = 0;
1589     hash_table_entry_t *new_entries;
1590     struct list *new_buckets;
1591     unsigned int grow_size = new_bucket_count - (new_bucket_count >> 2);
1592     unsigned int i;
1593
1594     new_buckets = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, new_bucket_count * sizeof(struct list));
1595     if (!new_buckets)
1596     {
1597         ERR("Failed to allocate new buckets, returning FALSE.\n");
1598         return FALSE;
1599     }
1600
1601     new_entries = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, grow_size * sizeof(hash_table_entry_t));
1602     if (!new_entries)
1603     {
1604         ERR("Failed to allocate new entries, returning FALSE.\n");
1605         HeapFree(GetProcessHeap(), 0, new_buckets);
1606         return FALSE;
1607     }
1608
1609     for (i = 0; i < table->bucket_count; ++i)
1610     {
1611         if (table->buckets[i].next)
1612         {
1613             hash_table_entry_t *entry, *entry2;
1614
1615             LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &table->buckets[i], hash_table_entry_t, entry)
1616             {
1617                 int j;
1618                 hash_table_entry_t *new_entry = new_entries + (new_entry_count++);
1619                 *new_entry = *entry;
1620
1621                 j = new_entry->hash & (new_bucket_count - 1);
1622
1623                 if (!new_buckets[j].next) list_init(&new_buckets[j]);
1624                 list_add_head(&new_buckets[j], &new_entry->entry);
1625             }
1626         }
1627     }
1628
1629     HeapFree(GetProcessHeap(), 0, table->buckets);
1630     table->buckets = new_buckets;
1631
1632     HeapFree(GetProcessHeap(), 0, table->entries);
1633     table->entries = new_entries;
1634
1635     table->entry_count = new_entry_count;
1636     list_init(&table->free_entries);
1637
1638     table->bucket_count = new_bucket_count;
1639     table->grow_size = grow_size;
1640     table->shrink_size = new_bucket_count > 8 ? new_bucket_count >> 2 : 0;
1641
1642     return TRUE;
1643 }
1644
1645 void hash_table_put(hash_table_t *table, void *key, void *value)
1646 {
1647     unsigned int idx;
1648     unsigned int hash;
1649     hash_table_entry_t *entry;
1650
1651     hash = table->hash_function(key);
1652     idx = hash & (table->bucket_count - 1);
1653     entry = hash_table_get_by_idx(table, key, idx);
1654
1655     if (entry)
1656     {
1657         HeapFree(GetProcessHeap(), 0, key);
1658         entry->value = value;
1659
1660         if (!value)
1661         {
1662             HeapFree(GetProcessHeap(), 0, entry->key);
1663             entry->key = NULL;
1664
1665             /* Remove the entry */
1666             list_remove(&entry->entry);
1667             list_add_head(&table->free_entries, &entry->entry);
1668
1669             --table->count;
1670
1671             /* Shrink if necessary */
1672             if (table->count < table->shrink_size) {
1673                 if (!hash_table_resize(table, table->bucket_count >> 1))
1674                 {
1675                     ERR("Failed to shrink the table...\n");
1676                 }
1677             }
1678         }
1679
1680         return;
1681     }
1682
1683     if (!value) return;
1684
1685     /* Grow if necessary */
1686     if (table->count >= table->grow_size)
1687     {
1688         if (!hash_table_resize(table, table->bucket_count << 1))
1689         {
1690             ERR("Failed to grow the table, returning.\n");
1691             return;
1692         }
1693
1694         idx = hash & (table->bucket_count - 1);
1695     }
1696
1697     /* Find an entry to insert */
1698     if (!list_empty(&table->free_entries))
1699     {
1700         struct list *elem = list_head(&table->free_entries);
1701
1702         list_remove(elem);
1703         entry = LIST_ENTRY(elem, hash_table_entry_t, entry);
1704     } else {
1705         entry = table->entries + (table->entry_count++);
1706     }
1707
1708     /* Insert the entry */
1709     entry->key = key;
1710     entry->value = value;
1711     entry->hash = hash;
1712     if (!table->buckets[idx].next) list_init(&table->buckets[idx]);
1713     list_add_head(&table->buckets[idx], &entry->entry);
1714
1715     ++table->count;
1716 }
1717
1718 void hash_table_remove(hash_table_t *table, void *key)
1719 {
1720     hash_table_put(table, key, NULL);
1721 }
1722
1723 void *hash_table_get(hash_table_t *table, void *key)
1724 {
1725     unsigned int idx;
1726     hash_table_entry_t *entry;
1727
1728     idx = table->hash_function(key) & (table->bucket_count - 1);
1729     entry = hash_table_get_by_idx(table, key, idx);
1730
1731     return entry ? entry->value : NULL;
1732 }
1733
1734 #define GLINFO_LOCATION stateblock->wineD3DDevice->adapter->gl_info
1735 void gen_ffp_op(IWineD3DStateBlockImpl *stateblock, struct texture_stage_op op[MAX_TEXTURES]) {
1736 #define ARG1 0x01
1737 #define ARG2 0x02
1738 #define ARG0 0x04
1739     static const unsigned char args[WINED3DTOP_LERP + 1] = {
1740         /* undefined                        */  0,
1741         /* D3DTOP_DISABLE                   */  0,
1742         /* D3DTOP_SELECTARG1                */  ARG1,
1743         /* D3DTOP_SELECTARG2                */  ARG2,
1744         /* D3DTOP_MODULATE                  */  ARG1 | ARG2,
1745         /* D3DTOP_MODULATE2X                */  ARG1 | ARG2,
1746         /* D3DTOP_MODULATE4X                */  ARG1 | ARG2,
1747         /* D3DTOP_ADD                       */  ARG1 | ARG2,
1748         /* D3DTOP_ADDSIGNED                 */  ARG1 | ARG2,
1749         /* D3DTOP_ADDSIGNED2X               */  ARG1 | ARG2,
1750         /* D3DTOP_SUBTRACT                  */  ARG1 | ARG2,
1751         /* D3DTOP_ADDSMOOTH                 */  ARG1 | ARG2,
1752         /* D3DTOP_BLENDDIFFUSEALPHA         */  ARG1 | ARG2,
1753         /* D3DTOP_BLENDTEXTUREALPHA         */  ARG1 | ARG2,
1754         /* D3DTOP_BLENDFACTORALPHA          */  ARG1 | ARG2,
1755         /* D3DTOP_BLENDTEXTUREALPHAPM       */  ARG1 | ARG2,
1756         /* D3DTOP_BLENDCURRENTALPHA         */  ARG1 | ARG2,
1757         /* D3DTOP_PREMODULATE               */  ARG1 | ARG2,
1758         /* D3DTOP_MODULATEALPHA_ADDCOLOR    */  ARG1 | ARG2,
1759         /* D3DTOP_MODULATECOLOR_ADDALPHA    */  ARG1 | ARG2,
1760         /* D3DTOP_MODULATEINVALPHA_ADDCOLOR */  ARG1 | ARG2,
1761         /* D3DTOP_MODULATEINVCOLOR_ADDALPHA */  ARG1 | ARG2,
1762         /* D3DTOP_BUMPENVMAP                */  ARG1 | ARG2,
1763         /* D3DTOP_BUMPENVMAPLUMINANCE       */  ARG1 | ARG2,
1764         /* D3DTOP_DOTPRODUCT3               */  ARG1 | ARG2,
1765         /* D3DTOP_MULTIPLYADD               */  ARG1 | ARG2 | ARG0,
1766         /* D3DTOP_LERP                      */  ARG1 | ARG2 | ARG0
1767     };
1768     unsigned int i;
1769     DWORD ttff;
1770
1771     for(i = 0; i < GL_LIMITS(texture_stages); i++) {
1772         IWineD3DBaseTextureImpl *texture;
1773         if(stateblock->textureState[i][WINED3DTSS_COLOROP] == WINED3DTOP_DISABLE) {
1774             op[i].cop = WINED3DTOP_DISABLE;
1775             op[i].aop = WINED3DTOP_DISABLE;
1776             op[i].carg0 = op[i].carg1 = op[i].carg2 = 0xffffffff;
1777             op[i].aarg0 = op[i].aarg1 = op[i].aarg2 = 0xffffffff;
1778             op[i].color_correction = WINED3DFMT_UNKNOWN;
1779             op[i].dst = 0xffffffff;
1780             i++;
1781             break;
1782         }
1783
1784         texture = (IWineD3DBaseTextureImpl *) stateblock->textures[i];
1785         op[i].color_correction = texture ? texture->baseTexture.shader_conversion_group : WINED3DFMT_UNKNOWN;
1786
1787         op[i].cop = stateblock->textureState[i][WINED3DTSS_COLOROP];
1788         op[i].aop = stateblock->textureState[i][WINED3DTSS_ALPHAOP];
1789
1790         op[i].carg1 = (args[op[i].cop] & ARG1) ? stateblock->textureState[i][WINED3DTSS_COLORARG1] : 0xffffffff;
1791         op[i].carg2 = (args[op[i].cop] & ARG2) ? stateblock->textureState[i][WINED3DTSS_COLORARG2] : 0xffffffff;
1792         op[i].carg0 = (args[op[i].cop] & ARG0) ? stateblock->textureState[i][WINED3DTSS_COLORARG0] : 0xffffffff;
1793
1794         if(is_invalid_op(stateblock->wineD3DDevice, i, op[i].cop, op[i].carg1, op[i].carg2, op[i].carg0)) {
1795             op[i].carg0 = 0xffffffff;
1796             op[i].carg2 = 0xffffffff;
1797             op[i].carg1 = WINED3DTA_CURRENT;
1798             op[i].cop = WINED3DTOP_SELECTARG1;
1799         }
1800
1801         op[i].aarg1 = (args[op[i].aop] & ARG1) ? stateblock->textureState[i][WINED3DTSS_ALPHAARG1] : 0xffffffff;
1802         op[i].aarg2 = (args[op[i].aop] & ARG2) ? stateblock->textureState[i][WINED3DTSS_ALPHAARG2] : 0xffffffff;
1803         op[i].aarg0 = (args[op[i].aop] & ARG0) ? stateblock->textureState[i][WINED3DTSS_ALPHAARG0] : 0xffffffff;
1804
1805         if(is_invalid_op(stateblock->wineD3DDevice, i, op[i].aop, op[i].aarg1, op[i].aarg2, op[i].aarg0)) {
1806             op[i].aarg0 = 0xffffffff;
1807             op[i].aarg2 = 0xffffffff;
1808             op[i].aarg1 = WINED3DTA_CURRENT;
1809             op[i].aop = WINED3DTOP_SELECTARG1;
1810         } else if(i == 0 && stateblock->textures[0] &&
1811                   stateblock->renderState[WINED3DRS_COLORKEYENABLE] &&
1812                  (stateblock->textureDimensions[0] == GL_TEXTURE_2D ||
1813                   stateblock->textureDimensions[0] == GL_TEXTURE_RECTANGLE_ARB)) {
1814             IWineD3DSurfaceImpl *surf = (IWineD3DSurfaceImpl *) ((IWineD3DTextureImpl *) stateblock->textures[0])->surfaces[0];
1815
1816             if(surf->CKeyFlags & WINEDDSD_CKSRCBLT &&
1817                getFormatDescEntry(surf->resource.format, NULL, NULL)->alphaMask == 0x00000000) {
1818
1819                 if(op[0].aop == WINED3DTOP_DISABLE) {
1820                     op[0].aarg1 = WINED3DTA_TEXTURE;
1821                     op[0].aop = WINED3DTOP_SELECTARG1;
1822                 }
1823                 else if(op[0].aop == WINED3DTOP_SELECTARG1 && op[0].aarg1 != WINED3DTA_TEXTURE) {
1824                     if (stateblock->renderState[WINED3DRS_ALPHABLENDENABLE]) {
1825                         op[0].aarg2 = WINED3DTA_TEXTURE;
1826                         op[0].aop = WINED3DTOP_MODULATE;
1827                     }
1828                     else op[0].aarg1 = WINED3DTA_TEXTURE;
1829                 }
1830                 else if(op[0].aop == WINED3DTOP_SELECTARG2 && op[0].aarg2 != WINED3DTA_TEXTURE) {
1831                     if (stateblock->renderState[WINED3DRS_ALPHABLENDENABLE]) {
1832                         op[0].aarg1 = WINED3DTA_TEXTURE;
1833                         op[0].aop = WINED3DTOP_MODULATE;
1834                     }
1835                     else op[0].aarg2 = WINED3DTA_TEXTURE;
1836                 }
1837             }
1838         }
1839
1840         if(op[i].carg1 == WINED3DTA_TEXTURE || op[i].carg2 == WINED3DTA_TEXTURE || op[i].carg0 == WINED3DTA_TEXTURE ||
1841            op[i].aarg1 == WINED3DTA_TEXTURE || op[i].aarg2 == WINED3DTA_TEXTURE || op[i].aarg0 == WINED3DTA_TEXTURE) {
1842             ttff = stateblock->textureState[i][WINED3DTSS_TEXTURETRANSFORMFLAGS];
1843             if(ttff == (WINED3DTTFF_PROJECTED | WINED3DTTFF_COUNT3)) {
1844                 op[i].projected = proj_count3;
1845             } else if(ttff == (WINED3DTTFF_PROJECTED | WINED3DTTFF_COUNT4)) {
1846                 op[i].projected = proj_count4;
1847             } else {
1848                 op[i].projected = proj_none;
1849             }
1850         } else {
1851             op[i].projected = proj_none;
1852         }
1853
1854         op[i].dst = stateblock->textureState[i][WINED3DTSS_RESULTARG];
1855     }
1856
1857     /* Clear unsupported stages */
1858     for(; i < MAX_TEXTURES; i++) {
1859         memset(&op[i], 0xff, sizeof(op[i]));
1860     }
1861 }
1862 #undef GLINFO_LOCATION
1863
1864 struct ffp_desc *find_ffp_shader(struct list *shaders, struct texture_stage_op op[MAX_TEXTURES])
1865 {
1866     struct ffp_desc *entry;
1867
1868     /* TODO: Optimize this. Finding the shader can be optimized by e.g. sorting the list,
1869      * or maybe consider using hashtables
1870      */
1871     LIST_FOR_EACH_ENTRY(entry, shaders, struct ffp_desc, entry) {
1872         if(memcmp(op, entry->op, sizeof(struct texture_stage_op) * MAX_TEXTURES) == 0) {
1873             TRACE("Found shader entry %p\n", entry);
1874             return entry;
1875         }
1876     }
1877
1878     TRACE("Shader not found\n");
1879     return NULL;
1880 }
1881
1882 void add_ffp_shader(struct list *shaders, struct ffp_desc *desc) {
1883     list_add_head(shaders, &desc->entry);
1884 }
1885
1886 /* Activates the texture dimension according to the bound D3D texture.
1887  * Does not care for the colorop or correct gl texture unit(when using nvrc)
1888  * Requires the caller to activate the correct unit before
1889  */
1890 #define GLINFO_LOCATION stateblock->wineD3DDevice->adapter->gl_info
1891 void texture_activate_dimensions(DWORD stage, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1892     if(stateblock->textures[stage]) {
1893         switch(stateblock->textureDimensions[stage]) {
1894             case GL_TEXTURE_2D:
1895                 glDisable(GL_TEXTURE_3D);
1896                 checkGLcall("glDisable(GL_TEXTURE_3D)");
1897                 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
1898                     glDisable(GL_TEXTURE_CUBE_MAP_ARB);
1899                     checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
1900                 }
1901                 if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE)) {
1902                     glDisable(GL_TEXTURE_RECTANGLE_ARB);
1903                     checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
1904                 }
1905                 glEnable(GL_TEXTURE_2D);
1906                 checkGLcall("glEnable(GL_TEXTURE_2D)");
1907                 break;
1908             case GL_TEXTURE_RECTANGLE_ARB:
1909                 glDisable(GL_TEXTURE_2D);
1910                 checkGLcall("glDisable(GL_TEXTURE_2D)");
1911                 glDisable(GL_TEXTURE_3D);
1912                 checkGLcall("glDisable(GL_TEXTURE_3D)");
1913                 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
1914                     glDisable(GL_TEXTURE_CUBE_MAP_ARB);
1915                     checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
1916                 }
1917                 glEnable(GL_TEXTURE_RECTANGLE_ARB);
1918                 checkGLcall("glEnable(GL_TEXTURE_RECTANGLE_ARB)");
1919                 break;
1920             case GL_TEXTURE_3D:
1921                 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
1922                     glDisable(GL_TEXTURE_CUBE_MAP_ARB);
1923                     checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
1924                 }
1925                 if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE)) {
1926                     glDisable(GL_TEXTURE_RECTANGLE_ARB);
1927                     checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
1928                 }
1929                 glDisable(GL_TEXTURE_2D);
1930                 checkGLcall("glDisable(GL_TEXTURE_2D)");
1931                 glEnable(GL_TEXTURE_3D);
1932                 checkGLcall("glEnable(GL_TEXTURE_3D)");
1933                 break;
1934             case GL_TEXTURE_CUBE_MAP_ARB:
1935                 glDisable(GL_TEXTURE_2D);
1936                 checkGLcall("glDisable(GL_TEXTURE_2D)");
1937                 glDisable(GL_TEXTURE_3D);
1938                 checkGLcall("glDisable(GL_TEXTURE_3D)");
1939                 if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE)) {
1940                     glDisable(GL_TEXTURE_RECTANGLE_ARB);
1941                     checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
1942                 }
1943                 glEnable(GL_TEXTURE_CUBE_MAP_ARB);
1944                 checkGLcall("glEnable(GL_TEXTURE_CUBE_MAP_ARB)");
1945               break;
1946         }
1947     } else {
1948         glEnable(GL_TEXTURE_2D);
1949         checkGLcall("glEnable(GL_TEXTURE_2D)");
1950         glDisable(GL_TEXTURE_3D);
1951         checkGLcall("glDisable(GL_TEXTURE_3D)");
1952         if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
1953             glDisable(GL_TEXTURE_CUBE_MAP_ARB);
1954             checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
1955         }
1956         if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE)) {
1957             glDisable(GL_TEXTURE_RECTANGLE_ARB);
1958             checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
1959         }
1960         /* Binding textures is done by samplers. A dummy texture will be bound */
1961     }
1962 }
1963
1964 void sampler_texdim(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1965     DWORD sampler = state - STATE_SAMPLER(0);
1966     DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[sampler];
1967
1968     /* No need to enable / disable anything here for unused samplers. The tex_colorop
1969     * handler takes care. Also no action is needed with pixel shaders, or if tex_colorop
1970     * will take care of this business
1971     */
1972     if(mapped_stage == -1 || mapped_stage >= GL_LIMITS(textures)) return;
1973     if(sampler >= stateblock->lowest_disabled_stage) return;
1974     if(use_ps(stateblock->wineD3DDevice)) return;
1975     if(isStateDirty(context, STATE_TEXTURESTAGE(sampler, WINED3DTSS_COLOROP))) return;
1976
1977     texture_activate_dimensions(sampler, stateblock, context);
1978 }
1979 #undef GLINFO_LOCATION