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  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  23  */
  24
  25 #include "config.h"
  26 #include "wined3d_private.h"
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
  29
  30 #define GLINFO_LOCATION ((IWineD3DImpl *)(This->wineD3D))->gl_info
  31
  32 /*****************************************************************************
  33  * Pixel format array
  34  */
  35 static const PixelFormatDesc formats[] = {
  36   /*{WINED3DFORMAT          ,alphamask  ,redmask    ,greenmask  ,bluemask   ,bpp    ,isFourcc   ,internal   ,format ,type   }*/
  37     {WINED3DFMT_UNKNOWN     ,0x0        ,0x0        ,0x0        ,0x0        ,1      ,FALSE      ,0                      ,0                  ,0                              },
  38     /* FourCC formats, kept here to have WINED3DFMT_R8G8B8(=20) at position 20 */
  39     {WINED3DFMT_UYVY        ,0x0        ,0x0        ,0x0        ,0x0        ,1/*?*/ ,TRUE       ,0                      ,0                  ,0                              },
  40     {WINED3DFMT_YUY2        ,0x0        ,0x0        ,0x0        ,0x0        ,1/*?*/ ,TRUE       ,0                      ,0                  ,0                              },
  41     {WINED3DFMT_DXT1        ,0x0        ,0x0        ,0x0        ,0x0        ,1      ,TRUE       ,GL_COMPRESSED_RGBA_S3TC_DXT1_EXT,GL_RGBA   ,GL_UNSIGNED_BYTE               },
  42     {WINED3DFMT_DXT2        ,0x0        ,0x0        ,0x0        ,0x0        ,1      ,TRUE       ,GL_COMPRESSED_RGBA_S3TC_DXT3_EXT,GL_RGBA   ,GL_UNSIGNED_BYTE               },
  43     {WINED3DFMT_DXT3        ,0x0        ,0x0        ,0x0        ,0x0        ,1      ,TRUE       ,GL_COMPRESSED_RGBA_S3TC_DXT3_EXT,GL_RGBA   ,GL_UNSIGNED_BYTE               },
  44     {WINED3DFMT_DXT4        ,0x0        ,0x0        ,0x0        ,0x0        ,1      ,TRUE       ,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,GL_RGBA   ,GL_UNSIGNED_BYTE               },
  45     {WINED3DFMT_DXT5        ,0x0        ,0x0        ,0x0        ,0x0        ,1      ,TRUE       ,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,GL_RGBA   ,GL_UNSIGNED_BYTE               },
  46     {WINED3DFMT_MULTI2_ARGB8,0x0        ,0x0        ,0x0        ,0x0        ,1/*?*/ ,TRUE       ,0                      ,0                  ,0                              },
  47     {WINED3DFMT_G8R8_G8B8   ,0x0        ,0x0        ,0x0        ,0x0        ,1/*?*/ ,TRUE       ,0                      ,0                  ,0                              },
  48     {WINED3DFMT_R8G8_B8G8   ,0x0        ,0x0        ,0x0        ,0x0        ,1/*?*/ ,TRUE       ,0                      ,0                  ,0                              },
  49     /* IEEE formats */
  50     {WINED3DFMT_R32F        ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,FALSE      ,GL_RGB32F_ARB         ,GL_RED             ,GL_FLOAT                       },
  51     {WINED3DFMT_G32R32F     ,0x0        ,0x0        ,0x0        ,0x0        ,8      ,FALSE      ,0                      ,0                  ,0                              },
  52     {WINED3DFMT_A32B32G32R32F,0x0       ,0x0        ,0x0        ,0x0        ,16     ,FALSE      ,GL_RGBA32F_ARB         ,GL_RGBA            ,GL_FLOAT                       },
  53     /* Hmm? */
  54     {WINED3DFMT_CxV8U8      ,0x0        ,0x0        ,0x0        ,0x0        ,2      ,FALSE      ,0                      ,0                  ,0                              },
  55     /* Float */
  56     {WINED3DFMT_R16F        ,0x0        ,0x0        ,0x0        ,0x0        ,2      ,FALSE      ,GL_RGB16F_ARB         ,GL_RED             ,GL_HALF_FLOAT_ARB              },
  57     {WINED3DFMT_G16R16F     ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,FALSE      ,0                      ,0                  ,0                              },
  58     {WINED3DFMT_A16B16G16R16F,0x0       ,0x0        ,0x0        ,0x0        ,8      ,FALSE      ,GL_RGBA16F_ARB         ,GL_RGBA            ,GL_HALF_FLOAT_ARB              },
  59     /* Palettized formats */
  60     {WINED3DFMT_A8P8        ,0x0000ff00 ,0x0        ,0x0        ,0x0        ,2      ,FALSE      ,0                      ,0                  ,0                              },
  61     {WINED3DFMT_P8          ,0x0        ,0x0        ,0x0        ,0x0        ,1      ,FALSE      ,GL_COLOR_INDEX8_EXT    ,GL_COLOR_INDEX     ,GL_UNSIGNED_BYTE               },
  62     /* Standard ARGB formats. Keep WINED3DFMT_R8G8B8(=20) at position 20 */
  63     {WINED3DFMT_R8G8B8      ,0x0        ,0x00ff0000 ,0x0000ff00 ,0x000000ff ,3      ,FALSE      ,GL_RGB8                ,GL_BGR             ,GL_UNSIGNED_BYTE               },
  64     {WINED3DFMT_A8R8G8B8    ,0xff000000 ,0x00ff0000 ,0x0000ff00 ,0x000000ff ,4      ,FALSE      ,GL_RGBA8               ,GL_BGRA            ,GL_UNSIGNED_INT_8_8_8_8_REV    },
  65     {WINED3DFMT_X8R8G8B8    ,0x0        ,0x00ff0000 ,0x0000ff00 ,0x000000ff ,4      ,FALSE      ,GL_RGB8                ,GL_BGRA            ,GL_UNSIGNED_INT_8_8_8_8_REV    },
  66     {WINED3DFMT_R5G6B5      ,0x0        ,0x0000F800 ,0x000007e0 ,0x0000001f ,2      ,FALSE      ,GL_RGB5                ,GL_RGB             ,GL_UNSIGNED_SHORT_5_6_5        },
  67     {WINED3DFMT_X1R5G5B5    ,0x0        ,0x00007c00 ,0x000003e0 ,0x0000001f ,2      ,FALSE      ,GL_RGB5_A1             ,GL_BGRA            ,GL_UNSIGNED_SHORT_1_5_5_5_REV  },
  68     {WINED3DFMT_A1R5G5B5    ,0x00008000 ,0x00007c00 ,0x000003e0 ,0x0000001f ,2      ,FALSE      ,GL_RGB5_A1             ,GL_BGRA            ,GL_UNSIGNED_SHORT_1_5_5_5_REV  },
  69     {WINED3DFMT_A4R4G4B4    ,0x0000f000 ,0x00000f00 ,0x000000f0 ,0x0000000f ,2      ,FALSE      ,GL_RGBA4               ,GL_BGRA            ,GL_UNSIGNED_SHORT_4_4_4_4_REV  },
  70     {WINED3DFMT_R3G3B2      ,0x0        ,0x000000e0 ,0x0000001c ,0x00000003 ,1      ,FALSE      ,GL_R3_G3_B2            ,GL_RGB             ,GL_UNSIGNED_BYTE_2_3_3_REV     },
  71     {WINED3DFMT_A8          ,0x000000ff ,0x0        ,0x0        ,0x0        ,1      ,FALSE      ,GL_ALPHA8              ,GL_ALPHA           ,GL_ALPHA                       },
  72     {WINED3DFMT_A8R3G3B2    ,0x0000ff00 ,0x000000e0 ,0x0000001c ,0x00000003 ,2      ,FALSE      ,0                      ,0                  ,0                              },
  73     {WINED3DFMT_X4R4G4B4    ,0x0        ,0x00000f00 ,0x000000f0 ,0x0000000f ,2      ,FALSE      ,GL_RGB4                ,GL_BGRA            ,GL_UNSIGNED_SHORT_4_4_4_4_REV  },
  74     {WINED3DFMT_A2B10G10R10 ,0xb0000000 ,0x000003ff ,0x000ffc00 ,0x3ff00000 ,4      ,FALSE      ,GL_RGB                 ,GL_RGBA            ,GL_UNSIGNED_INT_2_10_10_10_REV },
  75     {WINED3DFMT_A8B8G8R8    ,0xff000000 ,0x000000ff ,0x0000ff00 ,0x00ff0000 ,4      ,FALSE      ,GL_RGBA8               ,GL_RGBA            ,GL_UNSIGNED_INT_8_8_8_8_REV    },
  76     {WINED3DFMT_X8B8G8R8    ,0x0        ,0x000000ff ,0x0000ff00 ,0x00ff0000 ,4      ,FALSE      ,GL_RGB8                ,GL_RGBA            ,GL_UNSIGNED_INT_8_8_8_8_REV    },
  77     {WINED3DFMT_G16R16      ,0x0        ,0x0000ffff ,0xffff0000 ,0x0        ,4      ,FALSE      ,0                      ,0                  ,0                              },
  78     {WINED3DFMT_A2R10G10B10 ,0xb0000000 ,0x3ff00000 ,0x000ffc00 ,0x000003ff ,4      ,FALSE      ,GL_RGBA                ,GL_BGRA            ,GL_UNSIGNED_INT_2_10_10_10_REV },
  79     {WINED3DFMT_A16B16G16R16,0x0        ,0x0000ffff ,0xffff0000 ,0x0        ,8      ,FALSE      ,GL_RGBA16_EXT          ,GL_RGBA            ,GL_UNSIGNED_SHORT              },
  80     /* Luminance */
  81     {WINED3DFMT_L8          ,0x0        ,0x0        ,0x0        ,0x0        ,1      ,FALSE      ,GL_LUMINANCE8          ,GL_LUMINANCE       ,GL_UNSIGNED_BYTE               },
  82     {WINED3DFMT_A8L8        ,0x0000ff00 ,0x0        ,0x0        ,0x0        ,2      ,FALSE      ,GL_LUMINANCE8_ALPHA8   ,GL_LUMINANCE_ALPHA ,GL_UNSIGNED_BYTE               },
  83     {WINED3DFMT_A4L4        ,0x000000f0 ,0x0        ,0x0        ,0x0        ,1      ,FALSE      ,GL_LUMINANCE4_ALPHA4   ,GL_LUMINANCE_ALPHA ,GL_UNSIGNED_BYTE               },
  84     /* Bump mapping stuff */
  85     {WINED3DFMT_V8U8        ,0x0        ,0x0        ,0x0        ,0x0        ,2      ,FALSE      ,GL_RGB8                ,GL_BGR             ,GL_BYTE /* needs conversion! */},
  86     {WINED3DFMT_L6V5U5      ,0x0        ,0x0        ,0x0        ,0x0        ,2      ,FALSE      ,GL_COLOR_INDEX8_EXT    ,GL_COLOR_INDEX     ,GL_UNSIGNED_SHORT_5_5_5_1      },
  87     {WINED3DFMT_X8L8V8U8    ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,FALSE      ,GL_RGBA8               ,GL_BGRA            ,GL_UNSIGNED_BYTE               },
  88     {WINED3DFMT_Q8W8V8U8    ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,FALSE      ,GL_RGBA8               ,GL_RGBA            ,GL_UNSIGNED_INT_8_8_8_8_REV/*?*/},
  89     {WINED3DFMT_V16U16      ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,FALSE      ,GL_COLOR_INDEX         ,GL_COLOR_INDEX     ,GL_UNSIGNED_SHORT              },
  90     {WINED3DFMT_W11V11U10   ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,FALSE      ,0                      ,0                  ,0                              },
  91     {WINED3DFMT_A2W10V10U10 ,0xb0000000 ,0x0        ,0x0        ,0x0        ,4      ,FALSE      ,0                      ,0                  ,0                              },
  92     /* Depth stencil formats */
  93     {WINED3DFMT_D16_LOCKABLE,0x0        ,0x0        ,0x0        ,0x0        ,2      ,FALSE      ,GL_DEPTH_COMPONENT24_ARB,GL_DEPTH_COMPONENT,GL_UNSIGNED_SHORT              },
  94     {WINED3DFMT_D32         ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,FALSE      ,GL_DEPTH_COMPONENT32_ARB,GL_DEPTH_COMPONENT,GL_UNSIGNED_INT                },
  95     {WINED3DFMT_D15S1       ,0x0        ,0x0        ,0x0        ,0x0        ,2      ,FALSE      ,GL_DEPTH_COMPONENT24_ARB,GL_DEPTH_COMPONENT,GL_UNSIGNED_SHORT              },
  96     {WINED3DFMT_D24S8       ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,FALSE      ,GL_DEPTH_COMPONENT24_ARB,GL_DEPTH_COMPONENT,GL_UNSIGNED_INT                },
  97     {WINED3DFMT_D24X8       ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,FALSE      ,GL_DEPTH_COMPONENT24_ARB,GL_DEPTH_COMPONENT,GL_UNSIGNED_INT                },
  98     {WINED3DFMT_D24X4S4     ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,FALSE      ,GL_DEPTH_COMPONENT24_ARB,GL_DEPTH_COMPONENT,GL_UNSIGNED_INT                },
  99     {WINED3DFMT_D16         ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,FALSE      ,GL_DEPTH_COMPONENT24_ARB,GL_DEPTH_COMPONENT,GL_UNSIGNED_SHORT              },
 100     {WINED3DFMT_L16         ,0x0        ,0x0        ,0x0        ,0x0        ,2      ,FALSE      ,GL_LUMINANCE16_EXT     ,GL_LUMINANCE       ,GL_UNSIGNED_SHORT              },
 101     {WINED3DFMT_D32F_LOCKABLE,0x0       ,0x0        ,0x0        ,0x0        ,4      ,FALSE      ,GL_DEPTH_COMPONENT32_ARB,GL_DEPTH_COMPONENT,GL_FLOAT                       },
 102     {WINED3DFMT_D24FS8      ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,FALSE      ,GL_DEPTH_COMPONENT24_ARB,GL_DEPTH_COMPONENT,GL_FLOAT                       },
 103     /* Is this a vertex buffer? */
 104     {WINED3DFMT_VERTEXDATA  ,0x0        ,0x0        ,0x0        ,0x0        ,0      ,FALSE      ,0                      ,0                  ,0                              },
 105     {WINED3DFMT_INDEX16     ,0x0        ,0x0        ,0x0        ,0x0        ,2      ,FALSE      ,0                      ,0                  ,0                              },
 106     {WINED3DFMT_INDEX32     ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,FALSE      ,0                      ,0                  ,0                              },
 107     {WINED3DFMT_Q16W16V16U16,0x0        ,0x0        ,0x0        ,0x0        ,8      ,FALSE      ,GL_COLOR_INDEX         ,GL_COLOR_INDEX     ,GL_UNSIGNED_SHORT              }
 108 };
 109
 110 const PixelFormatDesc *getFormatDescEntry(WINED3DFORMAT fmt)
 111 {
 112     /* First check if the format is at the position of its value.
 113      * This will catch the argb formats before the loop is entered
 114      */
 115     if(fmt < (sizeof(formats) / sizeof(formats[0])) && formats[fmt].format == fmt) {
 116         return &formats[fmt];
 117     } else {
 118         unsigned int i;
 119         for(i = 0; i < (sizeof(formats) / sizeof(formats[0])); i++) {
 120             if(formats[i].format == fmt) {
 121                 return &formats[i];
 122             }
 123         }
 124     }
 125     FIXME("Can't find format %s(%d) in the format lookup table\n", debug_d3dformat(fmt), fmt);
 126     if(fmt == WINED3DFMT_UNKNOWN) {
 127         ERR("Format table corrupt - Can't find WINED3DFMT_UNKNOWN\n");
 128         return NULL;
 129     }
 130     /* Get the caller a valid pointer */
 131     return getFormatDescEntry(WINED3DFMT_UNKNOWN);
 132 }
 133
 134 /*****************************************************************************
 135  * Trace formatting of useful values
 136  */
 137 const char* debug_d3dformat(WINED3DFORMAT fmt) {
 138   switch (fmt) {
 139 #define FMT_TO_STR(fmt) case fmt: return #fmt
 140     FMT_TO_STR(WINED3DFMT_UNKNOWN);
 141     FMT_TO_STR(WINED3DFMT_R8G8B8);
 142     FMT_TO_STR(WINED3DFMT_A8R8G8B8);
 143     FMT_TO_STR(WINED3DFMT_X8R8G8B8);
 144     FMT_TO_STR(WINED3DFMT_R5G6B5);
 145     FMT_TO_STR(WINED3DFMT_X1R5G5B5);
 146     FMT_TO_STR(WINED3DFMT_A1R5G5B5);
 147     FMT_TO_STR(WINED3DFMT_A4R4G4B4);
 148     FMT_TO_STR(WINED3DFMT_R3G3B2);
 149     FMT_TO_STR(WINED3DFMT_A8);
 150     FMT_TO_STR(WINED3DFMT_A8R3G3B2);
 151     FMT_TO_STR(WINED3DFMT_X4R4G4B4);
 152     FMT_TO_STR(WINED3DFMT_A2B10G10R10);
 153     FMT_TO_STR(WINED3DFMT_A8B8G8R8);
 154     FMT_TO_STR(WINED3DFMT_X8B8G8R8);
 155     FMT_TO_STR(WINED3DFMT_G16R16);
 156     FMT_TO_STR(WINED3DFMT_A2R10G10B10);
 157     FMT_TO_STR(WINED3DFMT_A16B16G16R16);
 158     FMT_TO_STR(WINED3DFMT_A8P8);
 159     FMT_TO_STR(WINED3DFMT_P8);
 160     FMT_TO_STR(WINED3DFMT_L8);
 161     FMT_TO_STR(WINED3DFMT_A8L8);
 162     FMT_TO_STR(WINED3DFMT_A4L4);
 163     FMT_TO_STR(WINED3DFMT_V8U8);
 164     FMT_TO_STR(WINED3DFMT_L6V5U5);
 165     FMT_TO_STR(WINED3DFMT_X8L8V8U8);
 166     FMT_TO_STR(WINED3DFMT_Q8W8V8U8);
 167     FMT_TO_STR(WINED3DFMT_V16U16);
 168     FMT_TO_STR(WINED3DFMT_W11V11U10);
 169     FMT_TO_STR(WINED3DFMT_A2W10V10U10);
 170     FMT_TO_STR(WINED3DFMT_UYVY);
 171     FMT_TO_STR(WINED3DFMT_YUY2);
 172     FMT_TO_STR(WINED3DFMT_DXT1);
 173     FMT_TO_STR(WINED3DFMT_DXT2);
 174     FMT_TO_STR(WINED3DFMT_DXT3);
 175     FMT_TO_STR(WINED3DFMT_DXT4);
 176     FMT_TO_STR(WINED3DFMT_DXT5);
 177     FMT_TO_STR(WINED3DFMT_MULTI2_ARGB8);
 178     FMT_TO_STR(WINED3DFMT_G8R8_G8B8);
 179     FMT_TO_STR(WINED3DFMT_R8G8_B8G8);
 180     FMT_TO_STR(WINED3DFMT_D16_LOCKABLE);
 181     FMT_TO_STR(WINED3DFMT_D32);
 182     FMT_TO_STR(WINED3DFMT_D15S1);
 183     FMT_TO_STR(WINED3DFMT_D24S8);
 184     FMT_TO_STR(WINED3DFMT_D24X8);
 185     FMT_TO_STR(WINED3DFMT_D24X4S4);
 186     FMT_TO_STR(WINED3DFMT_D16);
 187     FMT_TO_STR(WINED3DFMT_L16);
 188     FMT_TO_STR(WINED3DFMT_D32F_LOCKABLE);
 189     FMT_TO_STR(WINED3DFMT_D24FS8);
 190     FMT_TO_STR(WINED3DFMT_VERTEXDATA);
 191     FMT_TO_STR(WINED3DFMT_INDEX16);
 192     FMT_TO_STR(WINED3DFMT_INDEX32);
 193     FMT_TO_STR(WINED3DFMT_Q16W16V16U16);
 194     FMT_TO_STR(WINED3DFMT_R16F);
 195     FMT_TO_STR(WINED3DFMT_G16R16F);
 196     FMT_TO_STR(WINED3DFMT_A16B16G16R16F);
 197     FMT_TO_STR(WINED3DFMT_R32F);
 198     FMT_TO_STR(WINED3DFMT_G32R32F);
 199     FMT_TO_STR(WINED3DFMT_A32B32G32R32F);
 200     FMT_TO_STR(WINED3DFMT_CxV8U8);
 201 #undef FMT_TO_STR
 202   default:
 203     {
 204       char fourcc[5];
 205       fourcc[0] = (char)(fmt);
 206       fourcc[1] = (char)(fmt >> 8);
 207       fourcc[2] = (char)(fmt >> 16);
 208       fourcc[3] = (char)(fmt >> 24);
 209       fourcc[4] = 0;
 210       if( isprint(fourcc[0]) && isprint(fourcc[1]) && isprint(fourcc[2]) && isprint(fourcc[3]) )
 211         FIXME("Unrecognized %u (as fourcc: %s) WINED3DFORMAT!\n", fmt, fourcc);
 212       else
 213         FIXME("Unrecognized %u WINED3DFORMAT!\n", fmt);
 214     }
 215     return "unrecognized";
 216   }
 217 }
 218
 219 const char* debug_d3ddevicetype(WINED3DDEVTYPE devtype) {
 220   switch (devtype) {
 221 #define DEVTYPE_TO_STR(dev) case dev: return #dev
 222     DEVTYPE_TO_STR(WINED3DDEVTYPE_HAL);
 223     DEVTYPE_TO_STR(WINED3DDEVTYPE_REF);
 224     DEVTYPE_TO_STR(WINED3DDEVTYPE_SW);
 225 #undef DEVTYPE_TO_STR
 226   default:
 227     FIXME("Unrecognized %u WINED3DDEVTYPE!\n", devtype);
 228     return "unrecognized";
 229   }
 230 }
 231
 232 const char* debug_d3dusage(DWORD usage) {
 233   switch (usage & WINED3DUSAGE_MASK) {
 234 #define WINED3DUSAGE_TO_STR(u) case u: return #u
 235     WINED3DUSAGE_TO_STR(WINED3DUSAGE_RENDERTARGET);
 236     WINED3DUSAGE_TO_STR(WINED3DUSAGE_DEPTHSTENCIL);
 237     WINED3DUSAGE_TO_STR(WINED3DUSAGE_WRITEONLY);
 238     WINED3DUSAGE_TO_STR(WINED3DUSAGE_SOFTWAREPROCESSING);
 239     WINED3DUSAGE_TO_STR(WINED3DUSAGE_DONOTCLIP);
 240     WINED3DUSAGE_TO_STR(WINED3DUSAGE_POINTS);
 241     WINED3DUSAGE_TO_STR(WINED3DUSAGE_RTPATCHES);
 242     WINED3DUSAGE_TO_STR(WINED3DUSAGE_NPATCHES);
 243     WINED3DUSAGE_TO_STR(WINED3DUSAGE_DYNAMIC);
 244     WINED3DUSAGE_TO_STR(WINED3DUSAGE_AUTOGENMIPMAP);
 245     WINED3DUSAGE_TO_STR(WINED3DUSAGE_DMAP);
 246 #undef WINED3DUSAGE_TO_STR
 247   case 0: return "none";
 248   default:
 249     FIXME("Unrecognized %u Usage!\n", usage);
 250     return "unrecognized";
 251   }
 252 }
 253
 254 const char* debug_d3dusagequery(DWORD usagequery) {
 255   switch (usagequery & WINED3DUSAGE_QUERY_MASK) {
 256 #define WINED3DUSAGEQUERY_TO_STR(u) case u: return #u
 257     WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_FILTER);
 258     WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_LEGACYBUMPMAP);
 259     WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING);
 260     WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_SRGBREAD);
 261     WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_SRGBWRITE);
 262     WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_VERTEXTEXTURE);
 263     WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_WRAPANDMIP);
 264 #undef WINED3DUSAGEQUERY_TO_STR
 265   case 0: return "none";
 266   default:
 267     FIXME("Unrecognized %u Usage Query!\n", usagequery);
 268     return "unrecognized";
 269   }
 270 }
 271
 272 const char* debug_d3ddeclmethod(WINED3DDECLMETHOD method) {
 273     switch (method) {
 274 #define WINED3DDECLMETHOD_TO_STR(u) case u: return #u
 275         WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_DEFAULT);
 276         WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_PARTIALU);
 277         WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_PARTIALV);
 278         WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_CROSSUV);
 279         WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_UV);
 280         WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_LOOKUP);
 281         WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_LOOKUPPRESAMPLED);
 282 #undef WINED3DDECLMETHOD_TO_STR
 283         default:
 284             FIXME("Unrecognized %u declaration method!\n", method);
 285             return "unrecognized";
 286     }
 287 }
 288
 289 const char* debug_d3ddecltype(WINED3DDECLTYPE type) {
 290     switch (type) {
 291 #define WINED3DDECLTYPE_TO_STR(u) case u: return #u
 292         WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT1);
 293         WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT2);
 294         WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT3);
 295         WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT4);
 296         WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_D3DCOLOR);
 297         WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_UBYTE4);
 298         WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_SHORT2);
 299         WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_SHORT4);
 300         WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_UBYTE4N);
 301         WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_SHORT2N);
 302         WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_SHORT4N);
 303         WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_USHORT2N);
 304         WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_USHORT4N);
 305         WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_UDEC3);
 306         WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_DEC3N);
 307         WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT16_2);
 308         WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT16_4);
 309         WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_UNUSED);
 310 #undef WINED3DDECLTYPE_TO_STR
 311         default:
 312             FIXME("Unrecognized %u declaration type!\n", type);
 313             return "unrecognized";
 314     }
 315 }
 316
 317 const char* debug_d3ddeclusage(BYTE usage) {
 318     switch (usage) {
 319 #define WINED3DDECLUSAGE_TO_STR(u) case u: return #u
 320         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_POSITION);
 321         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BLENDWEIGHT);
 322         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BLENDINDICES);
 323         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_NORMAL);
 324         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_PSIZE);
 325         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TEXCOORD);
 326         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TANGENT);
 327         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BINORMAL);
 328         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TESSFACTOR);
 329         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_POSITIONT);
 330         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_COLOR);
 331         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_FOG);
 332         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_DEPTH);
 333         WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_SAMPLE);
 334 #undef WINED3DDECLUSAGE_TO_STR
 335         default:
 336             FIXME("Unrecognized %u declaration usage!\n", usage);
 337             return "unrecognized";
 338     }
 339 }
 340
 341 const char* debug_d3dresourcetype(WINED3DRESOURCETYPE res) {
 342   switch (res) {
 343 #define RES_TO_STR(res) case res: return #res;
 344     RES_TO_STR(WINED3DRTYPE_SURFACE);
 345     RES_TO_STR(WINED3DRTYPE_VOLUME);
 346     RES_TO_STR(WINED3DRTYPE_TEXTURE);
 347     RES_TO_STR(WINED3DRTYPE_VOLUMETEXTURE);
 348     RES_TO_STR(WINED3DRTYPE_CUBETEXTURE);
 349     RES_TO_STR(WINED3DRTYPE_VERTEXBUFFER);
 350     RES_TO_STR(WINED3DRTYPE_INDEXBUFFER);
 351 #undef  RES_TO_STR
 352   default:
 353     FIXME("Unrecognized %u WINED3DRESOURCETYPE!\n", res);
 354     return "unrecognized";
 355   }
 356 }
 357
 358 const char* debug_d3dprimitivetype(WINED3DPRIMITIVETYPE PrimitiveType) {
 359   switch (PrimitiveType) {
 360 #define PRIM_TO_STR(prim) case prim: return #prim;
 361     PRIM_TO_STR(WINED3DPT_POINTLIST);
 362     PRIM_TO_STR(WINED3DPT_LINELIST);
 363     PRIM_TO_STR(WINED3DPT_LINESTRIP);
 364     PRIM_TO_STR(WINED3DPT_TRIANGLELIST);
 365     PRIM_TO_STR(WINED3DPT_TRIANGLESTRIP);
 366     PRIM_TO_STR(WINED3DPT_TRIANGLEFAN);
 367 #undef  PRIM_TO_STR
 368   default:
 369     FIXME("Unrecognized %u WINED3DPRIMITIVETYPE!\n", PrimitiveType);
 370     return "unrecognized";
 371   }
 372 }
 373
 374 const char* debug_d3drenderstate(DWORD state) {
 375   switch (state) {
 376 #define D3DSTATE_TO_STR(u) case u: return #u
 377     D3DSTATE_TO_STR(WINED3DRS_TEXTUREHANDLE             );
 378     D3DSTATE_TO_STR(WINED3DRS_ANTIALIAS                 );
 379     D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESS            );
 380     D3DSTATE_TO_STR(WINED3DRS_TEXTUREPERSPECTIVE        );
 381     D3DSTATE_TO_STR(WINED3DRS_WRAPU                     );
 382     D3DSTATE_TO_STR(WINED3DRS_WRAPV                     );
 383     D3DSTATE_TO_STR(WINED3DRS_ZENABLE                   );
 384     D3DSTATE_TO_STR(WINED3DRS_FILLMODE                  );
 385     D3DSTATE_TO_STR(WINED3DRS_SHADEMODE                 );
 386     D3DSTATE_TO_STR(WINED3DRS_LINEPATTERN               );
 387     D3DSTATE_TO_STR(WINED3DRS_MONOENABLE                );
 388     D3DSTATE_TO_STR(WINED3DRS_ROP2                      );
 389     D3DSTATE_TO_STR(WINED3DRS_PLANEMASK                 );
 390     D3DSTATE_TO_STR(WINED3DRS_ZWRITEENABLE              );
 391     D3DSTATE_TO_STR(WINED3DRS_ALPHATESTENABLE           );
 392     D3DSTATE_TO_STR(WINED3DRS_LASTPIXEL                 );
 393     D3DSTATE_TO_STR(WINED3DRS_TEXTUREMAG                );
 394     D3DSTATE_TO_STR(WINED3DRS_TEXTUREMIN                );
 395     D3DSTATE_TO_STR(WINED3DRS_SRCBLEND                  );
 396     D3DSTATE_TO_STR(WINED3DRS_DESTBLEND                 );
 397     D3DSTATE_TO_STR(WINED3DRS_TEXTUREMAPBLEND           );
 398     D3DSTATE_TO_STR(WINED3DRS_CULLMODE                  );
 399     D3DSTATE_TO_STR(WINED3DRS_ZFUNC                     );
 400     D3DSTATE_TO_STR(WINED3DRS_ALPHAREF                  );
 401     D3DSTATE_TO_STR(WINED3DRS_ALPHAFUNC                 );
 402     D3DSTATE_TO_STR(WINED3DRS_DITHERENABLE              );
 403     D3DSTATE_TO_STR(WINED3DRS_ALPHABLENDENABLE          );
 404     D3DSTATE_TO_STR(WINED3DRS_FOGENABLE                 );
 405     D3DSTATE_TO_STR(WINED3DRS_SPECULARENABLE            );
 406     D3DSTATE_TO_STR(WINED3DRS_ZVISIBLE                  );
 407     D3DSTATE_TO_STR(WINED3DRS_SUBPIXEL                  );
 408     D3DSTATE_TO_STR(WINED3DRS_SUBPIXELX                 );
 409     D3DSTATE_TO_STR(WINED3DRS_STIPPLEDALPHA             );
 410     D3DSTATE_TO_STR(WINED3DRS_FOGCOLOR                  );
 411     D3DSTATE_TO_STR(WINED3DRS_FOGTABLEMODE              );
 412     D3DSTATE_TO_STR(WINED3DRS_FOGSTART                  );
 413     D3DSTATE_TO_STR(WINED3DRS_FOGEND                    );
 414     D3DSTATE_TO_STR(WINED3DRS_FOGDENSITY                );
 415     D3DSTATE_TO_STR(WINED3DRS_STIPPLEENABLE             );
 416     D3DSTATE_TO_STR(WINED3DRS_EDGEANTIALIAS             );
 417     D3DSTATE_TO_STR(WINED3DRS_COLORKEYENABLE            );
 418     D3DSTATE_TO_STR(WINED3DRS_BORDERCOLOR               );
 419     D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESSU           );
 420     D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESSV           );
 421     D3DSTATE_TO_STR(WINED3DRS_MIPMAPLODBIAS             );
 422     D3DSTATE_TO_STR(WINED3DRS_ZBIAS                     );
 423     D3DSTATE_TO_STR(WINED3DRS_RANGEFOGENABLE            );
 424     D3DSTATE_TO_STR(WINED3DRS_ANISOTROPY                );
 425     D3DSTATE_TO_STR(WINED3DRS_FLUSHBATCH                );
 426     D3DSTATE_TO_STR(WINED3DRS_TRANSLUCENTSORTINDEPENDENT);
 427     D3DSTATE_TO_STR(WINED3DRS_STENCILENABLE             );
 428     D3DSTATE_TO_STR(WINED3DRS_STENCILFAIL               );
 429     D3DSTATE_TO_STR(WINED3DRS_STENCILZFAIL              );
 430     D3DSTATE_TO_STR(WINED3DRS_STENCILPASS               );
 431     D3DSTATE_TO_STR(WINED3DRS_STENCILFUNC               );
 432     D3DSTATE_TO_STR(WINED3DRS_STENCILREF                );
 433     D3DSTATE_TO_STR(WINED3DRS_STENCILMASK               );
 434     D3DSTATE_TO_STR(WINED3DRS_STENCILWRITEMASK          );
 435     D3DSTATE_TO_STR(WINED3DRS_TEXTUREFACTOR             );
 436     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN00          );
 437     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN01          );
 438     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN02          );
 439     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN03          );
 440     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN04          );
 441     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN05          );
 442     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN06          );
 443     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN07          );
 444     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN08          );
 445     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN09          );
 446     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN10          );
 447     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN11          );
 448     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN12          );
 449     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN13          );
 450     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN14          );
 451     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN15          );
 452     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN16          );
 453     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN17          );
 454     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN18          );
 455     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN19          );
 456     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN20          );
 457     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN21          );
 458     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN22          );
 459     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN23          );
 460     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN24          );
 461     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN25          );
 462     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN26          );
 463     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN27          );
 464     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN28          );
 465     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN29          );
 466     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN30          );
 467     D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN31          );
 468     D3DSTATE_TO_STR(WINED3DRS_WRAP0                     );
 469     D3DSTATE_TO_STR(WINED3DRS_WRAP1                     );
 470     D3DSTATE_TO_STR(WINED3DRS_WRAP2                     );
 471     D3DSTATE_TO_STR(WINED3DRS_WRAP3                     );
 472     D3DSTATE_TO_STR(WINED3DRS_WRAP4                     );
 473     D3DSTATE_TO_STR(WINED3DRS_WRAP5                     );
 474     D3DSTATE_TO_STR(WINED3DRS_WRAP6                     );
 475     D3DSTATE_TO_STR(WINED3DRS_WRAP7                     );
 476     D3DSTATE_TO_STR(WINED3DRS_CLIPPING                  );
 477     D3DSTATE_TO_STR(WINED3DRS_LIGHTING                  );
 478     D3DSTATE_TO_STR(WINED3DRS_EXTENTS                   );
 479     D3DSTATE_TO_STR(WINED3DRS_AMBIENT                   );
 480     D3DSTATE_TO_STR(WINED3DRS_FOGVERTEXMODE             );
 481     D3DSTATE_TO_STR(WINED3DRS_COLORVERTEX               );
 482     D3DSTATE_TO_STR(WINED3DRS_LOCALVIEWER               );
 483     D3DSTATE_TO_STR(WINED3DRS_NORMALIZENORMALS          );
 484     D3DSTATE_TO_STR(WINED3DRS_COLORKEYBLENDENABLE       );
 485     D3DSTATE_TO_STR(WINED3DRS_DIFFUSEMATERIALSOURCE     );
 486     D3DSTATE_TO_STR(WINED3DRS_SPECULARMATERIALSOURCE    );
 487     D3DSTATE_TO_STR(WINED3DRS_AMBIENTMATERIALSOURCE     );
 488     D3DSTATE_TO_STR(WINED3DRS_EMISSIVEMATERIALSOURCE    );
 489     D3DSTATE_TO_STR(WINED3DRS_VERTEXBLEND               );
 490     D3DSTATE_TO_STR(WINED3DRS_CLIPPLANEENABLE           );
 491     D3DSTATE_TO_STR(WINED3DRS_SOFTWAREVERTEXPROCESSING  );
 492     D3DSTATE_TO_STR(WINED3DRS_POINTSIZE                 );
 493     D3DSTATE_TO_STR(WINED3DRS_POINTSIZE_MIN             );
 494     D3DSTATE_TO_STR(WINED3DRS_POINTSPRITEENABLE         );
 495     D3DSTATE_TO_STR(WINED3DRS_POINTSCALEENABLE          );
 496     D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_A              );
 497     D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_B              );
 498     D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_C              );
 499     D3DSTATE_TO_STR(WINED3DRS_MULTISAMPLEANTIALIAS      );
 500     D3DSTATE_TO_STR(WINED3DRS_MULTISAMPLEMASK           );
 501     D3DSTATE_TO_STR(WINED3DRS_PATCHEDGESTYLE            );
 502     D3DSTATE_TO_STR(WINED3DRS_PATCHSEGMENTS             );
 503     D3DSTATE_TO_STR(WINED3DRS_DEBUGMONITORTOKEN         );
 504     D3DSTATE_TO_STR(WINED3DRS_POINTSIZE_MAX             );
 505     D3DSTATE_TO_STR(WINED3DRS_INDEXEDVERTEXBLENDENABLE  );
 506     D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE          );
 507     D3DSTATE_TO_STR(WINED3DRS_TWEENFACTOR               );
 508     D3DSTATE_TO_STR(WINED3DRS_BLENDOP                   );
 509     D3DSTATE_TO_STR(WINED3DRS_POSITIONDEGREE            );
 510     D3DSTATE_TO_STR(WINED3DRS_NORMALDEGREE              );
 511     D3DSTATE_TO_STR(WINED3DRS_SCISSORTESTENABLE         );
 512     D3DSTATE_TO_STR(WINED3DRS_SLOPESCALEDEPTHBIAS       );
 513     D3DSTATE_TO_STR(WINED3DRS_ANTIALIASEDLINEENABLE     );
 514     D3DSTATE_TO_STR(WINED3DRS_MINTESSELLATIONLEVEL      );
 515     D3DSTATE_TO_STR(WINED3DRS_MAXTESSELLATIONLEVEL      );
 516     D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_X            );
 517     D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_Y            );
 518     D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_Z            );
 519     D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_W            );
 520     D3DSTATE_TO_STR(WINED3DRS_ENABLEADAPTIVETESSELLATION);
 521     D3DSTATE_TO_STR(WINED3DRS_TWOSIDEDSTENCILMODE       );
 522     D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILFAIL           );
 523     D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILZFAIL          );
 524     D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILPASS           );
 525     D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILFUNC           );
 526     D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE1         );
 527     D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE2         );
 528     D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE3         );
 529     D3DSTATE_TO_STR(WINED3DRS_BLENDFACTOR               );
 530     D3DSTATE_TO_STR(WINED3DRS_SRGBWRITEENABLE           );
 531     D3DSTATE_TO_STR(WINED3DRS_DEPTHBIAS                 );
 532     D3DSTATE_TO_STR(WINED3DRS_WRAP8                     );
 533     D3DSTATE_TO_STR(WINED3DRS_WRAP9                     );
 534     D3DSTATE_TO_STR(WINED3DRS_WRAP10                    );
 535     D3DSTATE_TO_STR(WINED3DRS_WRAP11                    );
 536     D3DSTATE_TO_STR(WINED3DRS_WRAP12                    );
 537     D3DSTATE_TO_STR(WINED3DRS_WRAP13                    );
 538     D3DSTATE_TO_STR(WINED3DRS_WRAP14                    );
 539     D3DSTATE_TO_STR(WINED3DRS_WRAP15                    );
 540     D3DSTATE_TO_STR(WINED3DRS_SEPARATEALPHABLENDENABLE  );
 541     D3DSTATE_TO_STR(WINED3DRS_SRCBLENDALPHA             );
 542     D3DSTATE_TO_STR(WINED3DRS_DESTBLENDALPHA            );
 543     D3DSTATE_TO_STR(WINED3DRS_BLENDOPALPHA              );
 544 #undef D3DSTATE_TO_STR
 545   default:
 546     FIXME("Unrecognized %u render state!\n", state);
 547     return "unrecognized";
 548   }
 549 }
 550
 551 const char* debug_d3dsamplerstate(DWORD state) {
 552   switch (state) {
 553 #define D3DSTATE_TO_STR(u) case u: return #u
 554     D3DSTATE_TO_STR(WINED3DSAMP_BORDERCOLOR  );
 555     D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSU     );
 556     D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSV     );
 557     D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSW     );
 558     D3DSTATE_TO_STR(WINED3DSAMP_MAGFILTER    );
 559     D3DSTATE_TO_STR(WINED3DSAMP_MINFILTER    );
 560     D3DSTATE_TO_STR(WINED3DSAMP_MIPFILTER    );
 561     D3DSTATE_TO_STR(WINED3DSAMP_MIPMAPLODBIAS);
 562     D3DSTATE_TO_STR(WINED3DSAMP_MAXMIPLEVEL  );
 563     D3DSTATE_TO_STR(WINED3DSAMP_MAXANISOTROPY);
 564     D3DSTATE_TO_STR(WINED3DSAMP_SRGBTEXTURE  );
 565     D3DSTATE_TO_STR(WINED3DSAMP_ELEMENTINDEX );
 566     D3DSTATE_TO_STR(WINED3DSAMP_DMAPOFFSET   );
 567 #undef D3DSTATE_TO_STR
 568   default:
 569     FIXME("Unrecognized %u sampler state!\n", state);
 570     return "unrecognized";
 571   }
 572 }
 573
 574 const char* debug_d3dtexturestate(DWORD state) {
 575   switch (state) {
 576 #define D3DSTATE_TO_STR(u) case u: return #u
 577     D3DSTATE_TO_STR(WINED3DTSS_COLOROP               );
 578     D3DSTATE_TO_STR(WINED3DTSS_COLORARG1             );
 579     D3DSTATE_TO_STR(WINED3DTSS_COLORARG2             );
 580     D3DSTATE_TO_STR(WINED3DTSS_ALPHAOP               );
 581     D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG1             );
 582     D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG2             );
 583     D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT00          );
 584     D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT01          );
 585     D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT10          );
 586     D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT11          );
 587     D3DSTATE_TO_STR(WINED3DTSS_TEXCOORDINDEX         );
 588     D3DSTATE_TO_STR(WINED3DTSS_BUMPENVLSCALE         );
 589     D3DSTATE_TO_STR(WINED3DTSS_BUMPENVLOFFSET        );
 590     D3DSTATE_TO_STR(WINED3DTSS_TEXTURETRANSFORMFLAGS );
 591     D3DSTATE_TO_STR(WINED3DTSS_ADDRESSW              );
 592     D3DSTATE_TO_STR(WINED3DTSS_COLORARG0             );
 593     D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG0             );
 594     D3DSTATE_TO_STR(WINED3DTSS_RESULTARG             );
 595     D3DSTATE_TO_STR(WINED3DTSS_CONSTANT              );
 596 #undef D3DSTATE_TO_STR
 597   case 12:
 598     /* Note WINED3DTSS are not consecutive, so skip these */
 599     return "unused";
 600     break;
 601   default:
 602     FIXME("Unrecognized %u texture state!\n", state);
 603     return "unrecognized";
 604   }
 605 }
 606
 607 const char* debug_d3dtop(WINED3DTEXTUREOP d3dtop) {
 608     switch (d3dtop) {
 609 #define D3DTOP_TO_STR(u) case u: return #u
 610         D3DTOP_TO_STR(WINED3DTOP_DISABLE);
 611         D3DTOP_TO_STR(WINED3DTOP_SELECTARG1);
 612         D3DTOP_TO_STR(WINED3DTOP_SELECTARG2);
 613         D3DTOP_TO_STR(WINED3DTOP_MODULATE);
 614         D3DTOP_TO_STR(WINED3DTOP_MODULATE2X);
 615         D3DTOP_TO_STR(WINED3DTOP_MODULATE4X);
 616         D3DTOP_TO_STR(WINED3DTOP_ADD);
 617         D3DTOP_TO_STR(WINED3DTOP_ADDSIGNED);
 618         D3DTOP_TO_STR(WINED3DTOP_SUBTRACT);
 619         D3DTOP_TO_STR(WINED3DTOP_ADDSMOOTH);
 620         D3DTOP_TO_STR(WINED3DTOP_BLENDDIFFUSEALPHA);
 621         D3DTOP_TO_STR(WINED3DTOP_BLENDTEXTUREALPHA);
 622         D3DTOP_TO_STR(WINED3DTOP_BLENDFACTORALPHA);
 623         D3DTOP_TO_STR(WINED3DTOP_BLENDTEXTUREALPHAPM);
 624         D3DTOP_TO_STR(WINED3DTOP_BLENDCURRENTALPHA);
 625         D3DTOP_TO_STR(WINED3DTOP_PREMODULATE);
 626         D3DTOP_TO_STR(WINED3DTOP_MODULATEALPHA_ADDCOLOR);
 627         D3DTOP_TO_STR(WINED3DTOP_MODULATECOLOR_ADDALPHA);
 628         D3DTOP_TO_STR(WINED3DTOP_MODULATEINVALPHA_ADDCOLOR);
 629         D3DTOP_TO_STR(WINED3DTOP_MODULATEINVCOLOR_ADDALPHA);
 630         D3DTOP_TO_STR(WINED3DTOP_BUMPENVMAP);
 631         D3DTOP_TO_STR(WINED3DTOP_BUMPENVMAPLUMINANCE);
 632         D3DTOP_TO_STR(WINED3DTOP_DOTPRODUCT3);
 633         D3DTOP_TO_STR(WINED3DTOP_MULTIPLYADD);
 634         D3DTOP_TO_STR(WINED3DTOP_LERP);
 635 #undef D3DTOP_TO_STR
 636         default:
 637             FIXME("Unrecognized %u WINED3DTOP\n", d3dtop);
 638             return "unrecognized";
 639     }
 640 }
 641
 642 const char* debug_d3dtstype(WINED3DTRANSFORMSTATETYPE tstype) {
 643     switch (tstype) {
 644 #define TSTYPE_TO_STR(tstype) case tstype: return #tstype
 645     TSTYPE_TO_STR(WINED3DTS_VIEW);
 646     TSTYPE_TO_STR(WINED3DTS_PROJECTION);
 647     TSTYPE_TO_STR(WINED3DTS_TEXTURE0);
 648     TSTYPE_TO_STR(WINED3DTS_TEXTURE1);
 649     TSTYPE_TO_STR(WINED3DTS_TEXTURE2);
 650     TSTYPE_TO_STR(WINED3DTS_TEXTURE3);
 651     TSTYPE_TO_STR(WINED3DTS_TEXTURE4);
 652     TSTYPE_TO_STR(WINED3DTS_TEXTURE5);
 653     TSTYPE_TO_STR(WINED3DTS_TEXTURE6);
 654     TSTYPE_TO_STR(WINED3DTS_TEXTURE7);
 655     TSTYPE_TO_STR(WINED3DTS_WORLDMATRIX(0));
 656 #undef TSTYPE_TO_STR
 657     default:
 658         if (tstype > 256 && tstype < 512) {
 659             FIXME("WINED3DTS_WORLDMATRIX(%u). 1..255 not currently supported\n", tstype);
 660             return ("WINED3DTS_WORLDMATRIX > 0");
 661         }
 662         FIXME("Unrecognized %u WINED3DTS\n", tstype);
 663         return "unrecognized";
 664     }
 665 }
 666
 667 const char* debug_d3dpool(WINED3DPOOL Pool) {
 668   switch (Pool) {
 669 #define POOL_TO_STR(p) case p: return #p;
 670     POOL_TO_STR(WINED3DPOOL_DEFAULT);
 671     POOL_TO_STR(WINED3DPOOL_MANAGED);
 672     POOL_TO_STR(WINED3DPOOL_SYSTEMMEM);
 673     POOL_TO_STR(WINED3DPOOL_SCRATCH);
 674 #undef  POOL_TO_STR
 675   default:
 676     FIXME("Unrecognized %u WINED3DPOOL!\n", Pool);
 677     return "unrecognized";
 678   }
 679 }
 680
 681 /*****************************************************************************
 682  * Useful functions mapping GL <-> D3D values
 683  */
 684 GLenum StencilOp(DWORD op) {
 685     switch(op) {
 686     case WINED3DSTENCILOP_KEEP    : return GL_KEEP;
 687     case WINED3DSTENCILOP_ZERO    : return GL_ZERO;
 688     case WINED3DSTENCILOP_REPLACE : return GL_REPLACE;
 689     case WINED3DSTENCILOP_INCRSAT : return GL_INCR;
 690     case WINED3DSTENCILOP_DECRSAT : return GL_DECR;
 691     case WINED3DSTENCILOP_INVERT  : return GL_INVERT;
 692     case WINED3DSTENCILOP_INCR    : return GL_INCR_WRAP_EXT;
 693     case WINED3DSTENCILOP_DECR    : return GL_DECR_WRAP_EXT;
 694     default:
 695         FIXME("Unrecognized stencil op %d\n", op);
 696         return GL_KEEP;
 697     }
 698 }
 699
 700 GLenum CompareFunc(DWORD func) {
 701     switch ((WINED3DCMPFUNC)func) {
 702     case WINED3DCMP_NEVER        : return GL_NEVER;
 703     case WINED3DCMP_LESS         : return GL_LESS;
 704     case WINED3DCMP_EQUAL        : return GL_EQUAL;
 705     case WINED3DCMP_LESSEQUAL    : return GL_LEQUAL;
 706     case WINED3DCMP_GREATER      : return GL_GREATER;
 707     case WINED3DCMP_NOTEQUAL     : return GL_NOTEQUAL;
 708     case WINED3DCMP_GREATEREQUAL : return GL_GEQUAL;
 709     case WINED3DCMP_ALWAYS       : return GL_ALWAYS;
 710     default:
 711         FIXME("Unrecognized WINED3DCMPFUNC value %d\n", func);
 712         return 0;
 713     }
 714 }
 715
 716 static GLenum d3dta_to_combiner_input(DWORD d3dta, DWORD stage, INT texture_idx) {
 717     switch (d3dta) {
 718         case WINED3DTA_DIFFUSE:
 719             return GL_PRIMARY_COLOR_NV;
 720
 721         case WINED3DTA_CURRENT:
 722             if (stage) return GL_SPARE0_NV;
 723             else return GL_PRIMARY_COLOR_NV;
 724
 725         case WINED3DTA_TEXTURE:
 726             if (texture_idx > -1) return GL_TEXTURE0_ARB + texture_idx;
 727             else return GL_PRIMARY_COLOR_NV;
 728
 729         case WINED3DTA_TFACTOR:
 730             return GL_CONSTANT_COLOR0_NV;
 731
 732         case WINED3DTA_SPECULAR:
 733             return GL_SECONDARY_COLOR_NV;
 734
 735         case WINED3DTA_TEMP:
 736             /* TODO: Support WINED3DTSS_RESULTARG */
 737             FIXME("WINED3DTA_TEMP, not properly supported.\n");
 738             return GL_SPARE1_NV;
 739
 740         case WINED3DTA_CONSTANT:
 741             /* TODO: Support per stage constants (WINED3DTSS_CONSTANT, NV_register_combiners2) */
 742             FIXME("WINED3DTA_CONSTANT, not properly supported.\n");
 743             return GL_CONSTANT_COLOR1_NV;
 744
 745         default:
 746             FIXME("Unrecognized texture arg %#x\n", d3dta);
 747             return GL_TEXTURE;
 748     }
 749 }
 750
 751 static GLenum invert_mapping(GLenum mapping) {
 752     if (mapping == GL_UNSIGNED_INVERT_NV) return GL_SIGNED_IDENTITY_NV;
 753     else if (mapping == GL_SIGNED_IDENTITY_NV) return GL_UNSIGNED_INVERT_NV;
 754
 755     FIXME("Unhandled mapping %#x\n", mapping);
 756     return mapping;
 757 }
 758
 759 static void get_src_and_opr_nvrc(DWORD stage, DWORD arg, BOOL is_alpha, GLenum* input, GLenum* mapping, GLenum *component_usage, INT texture_idx) {
 760     /* The WINED3DTA_COMPLEMENT flag specifies the complement of the input should
 761      * be used. */
 762     if (arg & WINED3DTA_COMPLEMENT) *mapping = GL_UNSIGNED_INVERT_NV;
 763     else *mapping = GL_SIGNED_IDENTITY_NV;
 764
 765     /* The WINED3DTA_ALPHAREPLICATE flag specifies the alpha component of the input
 766      * should be used for all input components. */
 767     if (is_alpha || arg & WINED3DTA_ALPHAREPLICATE) *component_usage = GL_ALPHA;
 768     else *component_usage = GL_RGB;
 769
 770     *input = d3dta_to_combiner_input(arg & WINED3DTA_SELECTMASK, stage, texture_idx);
 771 }
 772
 773 typedef struct {
 774     GLenum input[3];
 775     GLenum mapping[3];
 776     GLenum component_usage[3];
 777 } tex_op_args;
 778
 779 static BOOL is_invalid_op(IWineD3DDeviceImpl *This, int stage, WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3) {
 780     if (op == WINED3DTOP_DISABLE) return FALSE;
 781     if (This->stateBlock->textures[stage]) return FALSE;
 782
 783     if (arg1 == WINED3DTA_TEXTURE && op != WINED3DTOP_SELECTARG2) return TRUE;
 784     if (arg2 == WINED3DTA_TEXTURE && op != WINED3DTOP_SELECTARG1) return TRUE;
 785     if (arg3 == WINED3DTA_TEXTURE && (op == WINED3DTOP_MULTIPLYADD || op == WINED3DTOP_LERP)) return TRUE;
 786
 787     return FALSE;
 788 }
 789
 790 void set_tex_op_nvrc(IWineD3DDevice *iface, BOOL is_alpha, int stage, WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3, INT texture_idx) {
 791     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl*)iface;
 792     tex_op_args tex_op_args = {{0}, {0}, {0}};
 793     GLenum portion = is_alpha ? GL_ALPHA : GL_RGB;
 794     GLenum target = GL_COMBINER0_NV + stage;
 795
 796     TRACE("stage %d, is_alpha %d, op %s, arg1 %#x, arg2 %#x, arg3 %#x, texture_idx %d\n",
 797             stage, is_alpha, debug_d3dtop(op), arg1, arg2, arg3, texture_idx);
 798
 799     /* If a texture stage references an invalid texture unit the stage just
 800      * passes through the result from the previous stage */
 801     if (is_invalid_op(This, stage, op, arg1, arg2, arg3)) {
 802         arg1 = WINED3DTA_CURRENT;
 803         op = WINED3DTOP_SELECTARG1;
 804     }
 805
 806     get_src_and_opr_nvrc(stage, arg1, is_alpha, &tex_op_args.input[0],
 807             &tex_op_args.mapping[0], &tex_op_args.component_usage[0], texture_idx);
 808     get_src_and_opr_nvrc(stage, arg2, is_alpha, &tex_op_args.input[1],
 809             &tex_op_args.mapping[1], &tex_op_args.component_usage[1], texture_idx);
 810     get_src_and_opr_nvrc(stage, arg3, is_alpha, &tex_op_args.input[2],
 811             &tex_op_args.mapping[2], &tex_op_args.component_usage[2], texture_idx);
 812
 813     ENTER_GL();
 814
 815     switch(op)
 816     {
 817         case WINED3DTOP_DISABLE:
 818             /* Only for alpha */
 819             if (!is_alpha) ERR("Shouldn't be called for WINED3DTSS_COLOROP (WINED3DTOP_DISABLE)\n");
 820             /* Input, prev_alpha*1 */
 821             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
 822                     GL_SPARE0_NV, GL_UNSIGNED_IDENTITY_NV, GL_ALPHA));
 823             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
 824                     GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_ALPHA));
 825
 826             /* Output */
 827             GL_EXTCALL(glCombinerOutputNV(target, portion, GL_SPARE0_NV, GL_DISCARD_NV,
 828                     GL_DISCARD_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
 829             break;
 830
 831         case WINED3DTOP_SELECTARG1:
 832         case WINED3DTOP_SELECTARG2:
 833             /* Input, arg*1 */
 834             if (op == WINED3DTOP_SELECTARG1) {
 835                 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
 836                         tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
 837             } else {
 838                 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
 839                         tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
 840             }
 841             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
 842                     GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
 843
 844             /* Output */
 845             GL_EXTCALL(glCombinerOutputNV(target, portion, GL_SPARE0_NV, GL_DISCARD_NV,
 846                     GL_DISCARD_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
 847             break;
 848
 849         case WINED3DTOP_MODULATE:
 850         case WINED3DTOP_MODULATE2X:
 851         case WINED3DTOP_MODULATE4X:
 852             /* Input, arg1*arg2 */
 853             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
 854                     tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
 855             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
 856                     tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
 857
 858             /* Output */
 859             if (op == WINED3DTOP_MODULATE) {
 860                 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_SPARE0_NV, GL_DISCARD_NV,
 861                         GL_DISCARD_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
 862             } else if (op == WINED3DTOP_MODULATE2X) {
 863                 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_SPARE0_NV, GL_DISCARD_NV,
 864                         GL_DISCARD_NV, GL_SCALE_BY_TWO_NV, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
 865             } else if (op == WINED3DTOP_MODULATE4X) {
 866                 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_SPARE0_NV, GL_DISCARD_NV,
 867                         GL_DISCARD_NV, GL_SCALE_BY_FOUR_NV, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
 868             }
 869             break;
 870
 871         case WINED3DTOP_ADD:
 872         case WINED3DTOP_ADDSIGNED:
 873         case WINED3DTOP_ADDSIGNED2X:
 874             /* Input, arg1*1+arg2*1 */
 875             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
 876                     tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
 877             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
 878                     GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
 879             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
 880                     tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
 881             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
 882                     GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
 883
 884             /* Output */
 885             if (op == WINED3DTOP_ADD) {
 886                 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
 887                         GL_SPARE0_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
 888             } else if (op == WINED3DTOP_ADDSIGNED) {
 889                 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
 890                         GL_SPARE0_NV, GL_NONE, GL_BIAS_BY_NEGATIVE_ONE_HALF_NV, GL_FALSE, GL_FALSE, GL_FALSE));
 891             } else if (op == WINED3DTOP_ADDSIGNED2X) {
 892                 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
 893                         GL_SPARE0_NV, GL_SCALE_BY_TWO_NV, GL_BIAS_BY_NEGATIVE_ONE_HALF_NV, GL_FALSE, GL_FALSE, GL_FALSE));
 894             }
 895             break;
 896
 897         case WINED3DTOP_SUBTRACT:
 898             /* Input, arg1*1+-arg2*1 */
 899             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
 900                     tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
 901             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
 902                     GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
 903             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
 904                     tex_op_args.input[1], GL_SIGNED_NEGATE_NV, tex_op_args.component_usage[1]));
 905             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
 906                     GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
 907
 908             /* Output */
 909             GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
 910                     GL_SPARE0_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
 911             break;
 912
 913         case WINED3DTOP_ADDSMOOTH:
 914             /* Input, arg1*1+(1-arg1)*arg2 */
 915             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
 916                     tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
 917             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
 918                     GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
 919             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
 920                     tex_op_args.input[0], invert_mapping(tex_op_args.mapping[0]), tex_op_args.component_usage[0]));
 921             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
 922                     tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
 923
 924             /* Output */
 925             GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
 926                     GL_SPARE0_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
 927             break;
 928
 929         case WINED3DTOP_BLENDDIFFUSEALPHA:
 930         case WINED3DTOP_BLENDTEXTUREALPHA:
 931         case WINED3DTOP_BLENDFACTORALPHA:
 932         case WINED3DTOP_BLENDTEXTUREALPHAPM:
 933         case WINED3DTOP_BLENDCURRENTALPHA:
 934         {
 935             GLenum alpha_src = GL_PRIMARY_COLOR_NV;
 936             if (op == WINED3DTOP_BLENDDIFFUSEALPHA) alpha_src = d3dta_to_combiner_input(WINED3DTA_DIFFUSE, stage, texture_idx);
 937             else if (op == WINED3DTOP_BLENDTEXTUREALPHA) alpha_src = d3dta_to_combiner_input(WINED3DTA_TEXTURE, stage, texture_idx);
 938             else if (op == WINED3DTOP_BLENDFACTORALPHA) alpha_src = d3dta_to_combiner_input(WINED3DTA_TFACTOR, stage, texture_idx);
 939             else if (op == WINED3DTOP_BLENDTEXTUREALPHAPM) alpha_src = d3dta_to_combiner_input(WINED3DTA_TEXTURE, stage, texture_idx);
 940             else if (op == WINED3DTOP_BLENDCURRENTALPHA) alpha_src = d3dta_to_combiner_input(WINED3DTA_CURRENT, stage, texture_idx);
 941             else FIXME("Unhandled WINED3DTOP %s, shouldn't happen\n", debug_d3dtop(op));
 942
 943             /* Input, arg1*alpha_src+arg2*(1-alpha_src) */
 944             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
 945                     tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
 946             if (op == WINED3DTOP_BLENDTEXTUREALPHAPM)
 947             {
 948                 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
 949                         GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
 950             } else {
 951                 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
 952                         alpha_src, GL_UNSIGNED_IDENTITY_NV, GL_ALPHA));
 953             }
 954             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
 955                     tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
 956             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
 957                     alpha_src, GL_UNSIGNED_INVERT_NV, GL_ALPHA));
 958
 959             /* Output */
 960             GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
 961                     GL_SPARE0_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
 962             break;
 963         }
 964
 965         case WINED3DTOP_MODULATEALPHA_ADDCOLOR:
 966             /* Input, arg1_alpha*arg2_rgb+arg1_rgb*1 */
 967             if (is_alpha) ERR("Only supported for WINED3DTSS_COLOROP (WINED3DTOP_MODULATEALPHA_ADDCOLOR)\n");
 968             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
 969                     tex_op_args.input[0], tex_op_args.mapping[0], GL_ALPHA));
 970             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
 971                     tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
 972             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
 973                     tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
 974             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
 975                     GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
 976
 977             /* Output */
 978             GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
 979                     GL_SPARE0_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
 980             break;
 981
 982         case WINED3DTOP_MODULATECOLOR_ADDALPHA:
 983             /* Input, arg1_rgb*arg2_rgb+arg1_alpha*1 */
 984             if (is_alpha) ERR("Only supported for WINED3DTSS_COLOROP (WINED3DTOP_MODULATECOLOR_ADDALPHA)\n");
 985             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
 986                     tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
 987             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
 988                     tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
 989             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
 990                     tex_op_args.input[0], tex_op_args.mapping[0], GL_ALPHA));
 991             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
 992                     GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
 993
 994             /* Output */
 995             GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
 996                     GL_SPARE0_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
 997             break;
 998
 999         case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR:
1000             /* Input, (1-arg1_alpha)*arg2_rgb+arg1_rgb*1 */
1001             if (is_alpha) ERR("Only supported for WINED3DTSS_COLOROP (WINED3DTOP_MODULATEINVALPHA_ADDCOLOR)\n");
1002             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
1003                     tex_op_args.input[0], invert_mapping(tex_op_args.mapping[0]), GL_ALPHA));
1004             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
1005                     tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
1006             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
1007                     tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
1008             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
1009                     GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
1010
1011             /* Output */
1012             GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
1013                     GL_SPARE0_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
1014             break;
1015
1016         case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA:
1017             /* Input, (1-arg1_rgb)*arg2_rgb+arg1_alpha*1 */
1018             if (is_alpha) ERR("Only supported for WINED3DTSS_COLOROP (WINED3DTOP_MODULATEINVCOLOR_ADDALPHA)\n");
1019             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
1020                     tex_op_args.input[0], invert_mapping(tex_op_args.mapping[0]), tex_op_args.component_usage[0]));
1021             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
1022                     tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
1023             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
1024                     tex_op_args.input[0], tex_op_args.mapping[0], GL_ALPHA));
1025             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
1026                     GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
1027
1028             /* Output */
1029             GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
1030                     GL_SPARE0_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
1031             break;
1032
1033         case WINED3DTOP_DOTPRODUCT3:
1034             /* Input, arg1 . arg2 */
1035             /* FIXME: DX7 uses a different calculation? */
1036             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
1037                     tex_op_args.input[0], GL_EXPAND_NORMAL_NV, tex_op_args.component_usage[0]));
1038             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
1039                     tex_op_args.input[1], GL_EXPAND_NORMAL_NV, tex_op_args.component_usage[1]));
1040
1041             /* Output */
1042             GL_EXTCALL(glCombinerOutputNV(target, portion, GL_SPARE0_NV, GL_DISCARD_NV,
1043                     GL_DISCARD_NV, GL_NONE, GL_NONE, GL_TRUE, GL_FALSE, GL_FALSE));
1044             break;
1045
1046         case WINED3DTOP_MULTIPLYADD:
1047             /* Input, arg1*1+arg2*arg3 */
1048             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
1049                     tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
1050             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
1051                     GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
1052             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
1053                     tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
1054             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
1055                     tex_op_args.input[2], tex_op_args.mapping[2], tex_op_args.component_usage[2]));
1056
1057             /* Output */
1058             GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
1059                     GL_SPARE0_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
1060             break;
1061
1062         case WINED3DTOP_LERP:
1063             /* Input, arg1*arg2+(1-arg1)*arg3 */
1064             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
1065                     tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
1066             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
1067                     tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
1068             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
1069                     tex_op_args.input[0], invert_mapping(tex_op_args.mapping[0]), tex_op_args.component_usage[0]));
1070             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
1071                     tex_op_args.input[2], tex_op_args.mapping[2], tex_op_args.component_usage[2]));
1072
1073             /* Output */
1074             GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
1075                     GL_SPARE0_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
1076             break;
1077
1078         default:
1079             FIXME("Unhandled WINED3DTOP: stage %d, is_alpha %d, op %s (%#x), arg1 %#x, arg2 %#x, arg3 %#x, texture_idx %d\n",
1080                     stage, is_alpha, debug_d3dtop(op), op, arg1, arg2, arg3, texture_idx);
1081     }
1082
1083     checkGLcall("set_tex_op_nvrc()\n");
1084
1085     LEAVE_GL();
1086 }
1087
1088 static void get_src_and_opr(DWORD arg, BOOL is_alpha, GLenum* source, GLenum* operand) {
1089     /* The WINED3DTA_ALPHAREPLICATE flag specifies the alpha component of the
1090      * input should be used for all input components. The WINED3DTA_COMPLEMENT
1091      * flag specifies the complement of the input should be used. */
1092     BOOL from_alpha = is_alpha || arg & WINED3DTA_ALPHAREPLICATE;
1093     BOOL complement = arg & WINED3DTA_COMPLEMENT;
1094
1095     /* Calculate the operand */
1096     if (complement) {
1097         if (from_alpha) *operand = GL_ONE_MINUS_SRC_ALPHA;
1098         else *operand = GL_ONE_MINUS_SRC_COLOR;
1099     } else {
1100         if (from_alpha) *operand = GL_SRC_ALPHA;
1101         else *operand = GL_SRC_COLOR;
1102     }
1103
1104     /* Calculate the source */
1105     switch (arg & WINED3DTA_SELECTMASK) {
1106         case WINED3DTA_CURRENT: *source = GL_PREVIOUS_EXT; break;
1107         case WINED3DTA_DIFFUSE: *source = GL_PRIMARY_COLOR_EXT; break;
1108         case WINED3DTA_TEXTURE: *source = GL_TEXTURE; break;
1109         case WINED3DTA_TFACTOR: *source = GL_CONSTANT_EXT; break;
1110         case WINED3DTA_SPECULAR:
1111             /*
1112              * According to the GL_ARB_texture_env_combine specs, SPECULAR is
1113              * 'Secondary color' and isn't supported until base GL supports it
1114              * There is no concept of temp registers as far as I can tell
1115              */
1116             FIXME("Unhandled texture arg WINED3DTA_SPECULAR\n");
1117             *source = GL_TEXTURE;
1118             break;
1119         default:
1120             FIXME("Unrecognized texture arg %#x\n", arg);
1121             *source = GL_TEXTURE;
1122             break;
1123     }
1124 }
1125
1126 /* Set texture operations up - The following avoids lots of ifdefs in this routine!*/
1127 #if defined (GL_VERSION_1_3)
1128 # define useext(A) A
1129 # define combine_ext 1
1130 #elif defined (GL_EXT_texture_env_combine)
1131 # define useext(A) A##_EXT
1132 # define combine_ext 1
1133 #elif defined (GL_ARB_texture_env_combine)
1134 # define useext(A) A##_ARB
1135 # define combine_ext 1
1136 #else
1137 # undef combine_ext
1138 #endif
1139
1140 #if !defined(combine_ext)
1141 void set_tex_op(IWineD3DDevice *iface, BOOL isAlpha, int Stage, WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3)
1142 {
1143         FIXME("Requires opengl combine extensions to work\n");
1144         return;
1145 }
1146 #else
1147 /* Setup the texture operations texture stage states */
1148 void set_tex_op(IWineD3DDevice *iface, BOOL isAlpha, int Stage, WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3)
1149 {
1150 #define GLINFO_LOCATION ((IWineD3DImpl *)(This->wineD3D))->gl_info
1151         GLenum src1, src2, src3;
1152         GLenum opr1, opr2, opr3;
1153         GLenum comb_target;
1154         GLenum src0_target, src1_target, src2_target;
1155         GLenum opr0_target, opr1_target, opr2_target;
1156         GLenum scal_target;
1157         GLenum opr=0, invopr, src3_target, opr3_target;
1158         BOOL Handled = FALSE;
1159         IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1160
1161         TRACE("Alpha?(%d), Stage:%d Op(%s), a1(%d), a2(%d), a3(%d)\n", isAlpha, Stage, debug_d3dtop(op), arg1, arg2, arg3);
1162
1163         ENTER_GL();
1164
1165         /* Note: Operations usually involve two ars, src0 and src1 and are operations of
1166            the form (a1 <operation> a2). However, some of the more complex operations
1167            take 3 parameters. Instead of the (sensible) addition of a3, Microsoft added
1168            in a third parameter called a0. Therefore these are operations of the form
1169            a0 <operation> a1 <operation> a2, ie the new parameter goes to the front.
1170
1171            However, below we treat the new (a0) parameter as src2/opr2, so in the actual
1172            functions below, expect their syntax to differ slightly to those listed in the
1173            manuals, ie replace arg1 with arg3, arg2 with arg1 and arg3 with arg2
1174            This affects WINED3DTOP_MULTIPLYADD and WINED3DTOP_LERP                     */
1175
1176         if (isAlpha) {
1177                 comb_target = useext(GL_COMBINE_ALPHA);
1178                 src0_target = useext(GL_SOURCE0_ALPHA);
1179                 src1_target = useext(GL_SOURCE1_ALPHA);
1180                 src2_target = useext(GL_SOURCE2_ALPHA);
1181                 opr0_target = useext(GL_OPERAND0_ALPHA);
1182                 opr1_target = useext(GL_OPERAND1_ALPHA);
1183                 opr2_target = useext(GL_OPERAND2_ALPHA);
1184                 scal_target = GL_ALPHA_SCALE;
1185         }
1186         else {
1187                 comb_target = useext(GL_COMBINE_RGB);
1188                 src0_target = useext(GL_SOURCE0_RGB);
1189                 src1_target = useext(GL_SOURCE1_RGB);
1190                 src2_target = useext(GL_SOURCE2_RGB);
1191                 opr0_target = useext(GL_OPERAND0_RGB);
1192                 opr1_target = useext(GL_OPERAND1_RGB);
1193                 opr2_target = useext(GL_OPERAND2_RGB);
1194                 scal_target = useext(GL_RGB_SCALE);
1195         }
1196
1197         /* If a texture stage references an invalid texture unit the stage just
1198          * passes through the result from the previous stage */
1199         if (is_invalid_op(This, Stage, op, arg1, arg2, arg3)) {
1200             arg1 = WINED3DTA_CURRENT;
1201             op = WINED3DTOP_SELECTARG1;
1202         }
1203
1204         /* From MSDN (WINED3DTSS_ALPHAARG1) :
1205            The default argument is WINED3DTA_TEXTURE. If no texture is set for this stage,
1206                    then the default argument is WINED3DTA_DIFFUSE.
1207                    FIXME? If texture added/removed, may need to reset back as well?    */
1208         if (isAlpha && This->stateBlock->textures[Stage] == NULL && arg1 == WINED3DTA_TEXTURE) {
1209             get_src_and_opr(WINED3DTA_DIFFUSE, isAlpha, &src1, &opr1);
1210         } else {
1211             get_src_and_opr(arg1, isAlpha, &src1, &opr1);
1212         }
1213         get_src_and_opr(arg2, isAlpha, &src2, &opr2);
1214         get_src_and_opr(arg3, isAlpha, &src3, &opr3);
1215
1216         TRACE("ct(%x), 1:(%x,%x), 2:(%x,%x), 3:(%x,%x)\n", comb_target, src1, opr1, src2, opr2, src3, opr3);
1217
1218         Handled = TRUE; /* Assume will be handled */
1219
1220         /* Other texture operations require special extensions: */
1221         if (GL_SUPPORT(NV_TEXTURE_ENV_COMBINE4)) {
1222           if (isAlpha) {
1223             opr = GL_SRC_ALPHA;
1224             invopr = GL_ONE_MINUS_SRC_ALPHA;
1225             src3_target = GL_SOURCE3_ALPHA_NV;
1226             opr3_target = GL_OPERAND3_ALPHA_NV;
1227           } else {
1228             opr = GL_SRC_COLOR;
1229             invopr = GL_ONE_MINUS_SRC_COLOR;
1230             src3_target = GL_SOURCE3_RGB_NV;
1231             opr3_target = GL_OPERAND3_RGB_NV;
1232           }
1233           switch (op) {
1234           case WINED3DTOP_DISABLE: /* Only for alpha */
1235             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1236             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
1237             glTexEnvi(GL_TEXTURE_ENV, src0_target, GL_PREVIOUS_EXT);
1238             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1239             glTexEnvi(GL_TEXTURE_ENV, opr0_target, GL_SRC_ALPHA);
1240             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1241             glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
1242             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1243             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1244             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1245             glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
1246             checkGLcall("GL_TEXTURE_ENV, src2_target, GL_ZERO");
1247             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
1248             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
1249             glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1250             checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1251             glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
1252             checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
1253             break;
1254           case WINED3DTOP_SELECTARG1:                                          /* = a1 * 1 + 0 * 0 */
1255           case WINED3DTOP_SELECTARG2:                                          /* = a2 * 1 + 0 * 0 */
1256             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1257             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1258             if (op == WINED3DTOP_SELECTARG1) {
1259               glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1260               checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1261               glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1262               checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1263             } else {
1264               glTexEnvi(GL_TEXTURE_ENV, src0_target, src2);
1265               checkGLcall("GL_TEXTURE_ENV, src0_target, src2");
1266               glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr2);
1267               checkGLcall("GL_TEXTURE_ENV, opr0_target, opr2");
1268             }
1269             glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
1270             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1271             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1272             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1273             glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
1274             checkGLcall("GL_TEXTURE_ENV, src2_target, GL_ZERO");
1275             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
1276             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
1277             glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1278             checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1279             glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
1280             checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
1281             break;
1282
1283           case WINED3DTOP_MODULATE:
1284             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1285             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
1286             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1287             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1288             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1289             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1290             glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1291             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1292             glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1293             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1294             glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
1295             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1296             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
1297             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1298             glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1299             checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1300             glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
1301             checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
1302             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1303             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1304             break;
1305           case WINED3DTOP_MODULATE2X:
1306             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1307             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
1308             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1309             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1310             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1311             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1312             glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1313             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1314             glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1315             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1316             glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
1317             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1318             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
1319             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1320             glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1321             checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1322             glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
1323             checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
1324             glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
1325             checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
1326             break;
1327           case WINED3DTOP_MODULATE4X:
1328             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1329             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
1330             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1331             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1332             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1333             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1334             glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1335             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1336             glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1337             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1338             glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
1339             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1340             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
1341             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1342             glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1343             checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1344             glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
1345             checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
1346             glTexEnvi(GL_TEXTURE_ENV, scal_target, 4);
1347             checkGLcall("GL_TEXTURE_ENV, scal_target, 4");
1348             break;
1349
1350           case WINED3DTOP_ADD:
1351             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1352             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1353             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1354             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1355             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1356             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1357             glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
1358             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1359             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1360             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1361             glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1362             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1363             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1364             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1365             glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1366             checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1367             glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
1368             checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
1369             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1370             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1371             break;
1372
1373           case WINED3DTOP_ADDSIGNED:
1374             glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED));
1375             checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED)");
1376             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1377             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1378             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1379             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1380             glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
1381             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1382             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1383             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1384             glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1385             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1386             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1387             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1388             glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1389             checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1390             glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
1391             checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
1392             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1393             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1394             break;
1395
1396           case WINED3DTOP_ADDSIGNED2X:
1397             glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED));
1398             checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED)");
1399             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1400             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1401             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1402             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1403             glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
1404             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1405             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1406             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1407             glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1408             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1409             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1410             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1411             glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1412             checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1413             glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
1414             checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
1415             glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
1416             checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
1417             break;
1418
1419           case WINED3DTOP_ADDSMOOTH:
1420             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1421             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1422             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1423             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1424             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1425             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1426             glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
1427             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1428             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1429             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1430             glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1431             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1432             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1433             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1434             glTexEnvi(GL_TEXTURE_ENV, src3_target, src1);
1435             checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
1436             switch (opr1) {
1437             case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_COLOR; break;
1438             case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_COLOR; break;
1439             case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1440             case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
1441             }
1442             glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
1443             checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
1444             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1445             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1446             break;
1447
1448           case WINED3DTOP_BLENDDIFFUSEALPHA:
1449             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1450             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1451             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1452             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1453             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1454             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1455             glTexEnvi(GL_TEXTURE_ENV, src1_target, useext(GL_PRIMARY_COLOR));
1456             checkGLcall("GL_TEXTURE_ENV, src1_target, useext(GL_PRIMARY_COLOR)");
1457             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1458             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1459             glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1460             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1461             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1462             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1463             glTexEnvi(GL_TEXTURE_ENV, src3_target, useext(GL_PRIMARY_COLOR));
1464             checkGLcall("GL_TEXTURE_ENV, src3_target, useext(GL_PRIMARY_COLOR)");
1465             glTexEnvi(GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA);
1466             checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
1467             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1468             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1469             break;
1470           case WINED3DTOP_BLENDTEXTUREALPHA:
1471             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1472             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1473             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1474             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1475             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1476             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1477             glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_TEXTURE);
1478             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_TEXTURE");
1479             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1480             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1481             glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1482             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1483             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1484             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1485             glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_TEXTURE);
1486             checkGLcall("GL_TEXTURE_ENV, src3_target, GL_TEXTURE");
1487             glTexEnvi(GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA);
1488             checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
1489             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1490             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1491             break;
1492           case WINED3DTOP_BLENDFACTORALPHA:
1493             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1494             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1495             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1496             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1497             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1498             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1499             glTexEnvi(GL_TEXTURE_ENV, src1_target, useext(GL_CONSTANT));
1500             checkGLcall("GL_TEXTURE_ENV, src1_target, useext(GL_CONSTANT)");
1501             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1502             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1503             glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1504             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1505             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1506             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1507             glTexEnvi(GL_TEXTURE_ENV, src3_target, useext(GL_CONSTANT));
1508             checkGLcall("GL_TEXTURE_ENV, src3_target, useext(GL_CONSTANT)");
1509             glTexEnvi(GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA);
1510             checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
1511             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1512             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1513             break;
1514           case WINED3DTOP_BLENDTEXTUREALPHAPM:
1515             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1516             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1517             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1518             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1519             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1520             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1521             glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
1522             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1523             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1524             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1525             glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1526             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1527             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1528             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1529             glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_TEXTURE);
1530             checkGLcall("GL_TEXTURE_ENV, src3_target, GL_TEXTURE");
1531             glTexEnvi(GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA);
1532             checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
1533             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1534             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1535             break;
1536           case WINED3DTOP_MODULATEALPHA_ADDCOLOR:
1537             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1538             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");  /* Add = a0*a1 + a2*a3 */
1539             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);        /*   a0 = src1/opr1    */
1540             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1541             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1542             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");    /*   a1 = 1 (see docs) */
1543             glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
1544             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1545             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1546             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1547             glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);        /*   a2 = arg2         */
1548             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1549             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1550             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");     /*  a3 = src1 alpha   */
1551             glTexEnvi(GL_TEXTURE_ENV, src3_target, src1);
1552             checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
1553             switch (opr) {
1554             case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
1555             case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1556             }
1557             glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
1558             checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
1559             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1560             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1561             break;
1562           case WINED3DTOP_MODULATECOLOR_ADDALPHA:
1563             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1564             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1565             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1566             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1567             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1568             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1569             glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1570             checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1571             glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1572             checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1573             glTexEnvi(GL_TEXTURE_ENV, src2_target, src1);
1574             checkGLcall("GL_TEXTURE_ENV, src2_target, src1");
1575             switch (opr1) {
1576             case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
1577             case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1578             }
1579             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
1580             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
1581             glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1582             checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1583             glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
1584             checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
1585             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1586             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1587             break;
1588           case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR:
1589             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1590             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1591             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1592             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1593             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1594             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1595             glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
1596             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1597             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1598             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1599             glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1600             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1601             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1602             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1603             glTexEnvi(GL_TEXTURE_ENV, src3_target, src1);
1604             checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
1605             switch (opr1) {
1606             case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1607             case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_ALPHA; break;
1608             case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1609             case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
1610             }
1611             glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
1612             checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
1613             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1614             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1615             break;
1616           case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA:
1617             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1618             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1619             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1620             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1621             switch (opr1) {
1622             case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_COLOR; break;
1623             case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_COLOR; break;
1624             case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1625             case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
1626             }
1627             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
1628             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
1629             glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1630             checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1631             glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1632             checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1633             glTexEnvi(GL_TEXTURE_ENV, src2_target, src1);
1634             checkGLcall("GL_TEXTURE_ENV, src2_target, src1");
1635             switch (opr1) {
1636             case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
1637             case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1638             }
1639             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
1640             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
1641             glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1642             checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1643             glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
1644             checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
1645             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1646             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1647             break;
1648           case WINED3DTOP_MULTIPLYADD:
1649             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1650             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1651             glTexEnvi(GL_TEXTURE_ENV, src0_target, src3);
1652             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1653             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr3);
1654             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1655             glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
1656             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1657             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1658             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1659             glTexEnvi(GL_TEXTURE_ENV, src2_target, src1);
1660             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1661             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr1);
1662             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1663             glTexEnvi(GL_TEXTURE_ENV, src3_target, src2);
1664             checkGLcall("GL_TEXTURE_ENV, src3_target, src3");
1665             glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr2);
1666             checkGLcall("GL_TEXTURE_ENV, opr3_target, opr3");
1667             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1668             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1669             break;
1670
1671           case WINED3DTOP_BUMPENVMAP:
1672             {
1673             }
1674
1675           case WINED3DTOP_BUMPENVMAPLUMINANCE:
1676
1677           default:
1678             Handled = FALSE;
1679           }
1680           if (Handled) {
1681             glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE4_NV);
1682             checkGLcall("GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE4_NV");
1683
1684             LEAVE_GL();
1685             return;
1686           }
1687         } /* GL_NV_texture_env_combine4 */
1688
1689         Handled = TRUE; /* Again, assume handled */
1690         switch (op) {
1691         case WINED3DTOP_DISABLE: /* Only for alpha */
1692                 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_REPLACE);
1693                 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
1694                 glTexEnvi(GL_TEXTURE_ENV, src0_target, GL_PREVIOUS_EXT);
1695                 checkGLcall("GL_TEXTURE_ENV, src0_target, GL_PREVIOUS_EXT");
1696                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, GL_SRC_ALPHA);
1697                 checkGLcall("GL_TEXTURE_ENV, opr0_target, GL_SRC_ALPHA");
1698                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1699                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1700                 break;
1701         case WINED3DTOP_SELECTARG1:
1702                 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_REPLACE);
1703                 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
1704                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1705                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1706                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1707                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1708                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1709                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1710                 break;
1711         case WINED3DTOP_SELECTARG2:
1712                 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_REPLACE);
1713                 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
1714                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src2);
1715                 checkGLcall("GL_TEXTURE_ENV, src0_target, src2");
1716                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr2);
1717                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr2");
1718                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1719                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1720                 break;
1721         case WINED3DTOP_MODULATE:
1722                 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE);
1723                 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
1724                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1725                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1726                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1727                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1728                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1729                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1730                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1731                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1732                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1733                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1734                 break;
1735         case WINED3DTOP_MODULATE2X:
1736                 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE);
1737                 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
1738                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1739                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1740                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1741                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1742                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1743                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1744                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1745                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1746                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
1747                 checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
1748                 break;
1749         case WINED3DTOP_MODULATE4X:
1750                 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE);
1751                 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
1752                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1753                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1754                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1755                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1756                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1757                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1758                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1759                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1760                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 4);
1761                 checkGLcall("GL_TEXTURE_ENV, scal_target, 4");
1762                 break;
1763         case WINED3DTOP_ADD:
1764                 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1765                 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1766                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1767                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1768                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1769                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1770                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1771                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1772                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1773                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1774                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1775                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1776                 break;
1777         case WINED3DTOP_ADDSIGNED:
1778                 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED));
1779                 checkGLcall("GL_TEXTURE_ENV, comb_target, useext((GL_ADD_SIGNED)");
1780                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1781                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1782                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1783                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1784                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1785                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1786                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1787                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1788                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1789                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1790                 break;
1791         case WINED3DTOP_ADDSIGNED2X:
1792                 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED));
1793                 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED)");
1794                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1795                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1796                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1797                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1798                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1799                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1800                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1801                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1802                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
1803                 checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
1804                 break;
1805         case WINED3DTOP_SUBTRACT:
1806           if (GL_SUPPORT(ARB_TEXTURE_ENV_COMBINE)) {
1807                 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_SUBTRACT);
1808                 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_SUBTRACT)");
1809                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1810                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1811                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1812                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1813                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1814                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1815                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1816                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1817                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1818                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1819           } else {
1820                 FIXME("This version of opengl does not support GL_SUBTRACT\n");
1821           }
1822           break;
1823
1824         case WINED3DTOP_BLENDDIFFUSEALPHA:
1825                 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
1826                 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
1827                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1828                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1829                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1830                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1831                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1832                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1833                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1834                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1835                 glTexEnvi(GL_TEXTURE_ENV, src2_target, useext(GL_PRIMARY_COLOR));
1836                 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_PRIMARY_COLOR");
1837                 glTexEnvi(GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA);
1838                 checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
1839                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1840                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1841                 break;
1842         case WINED3DTOP_BLENDTEXTUREALPHA:
1843                 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
1844                 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
1845                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1846                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1847                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1848                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1849                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1850                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1851                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1852                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1853                 glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_TEXTURE);
1854                 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_TEXTURE");
1855                 glTexEnvi(GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA);
1856                 checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
1857                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1858                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1859                 break;
1860         case WINED3DTOP_BLENDFACTORALPHA:
1861                 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
1862                 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
1863                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1864                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1865                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1866                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1867                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1868                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1869                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1870                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1871                 glTexEnvi(GL_TEXTURE_ENV, src2_target, useext(GL_CONSTANT));
1872                 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_CONSTANT");
1873                 glTexEnvi(GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA);
1874                 checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
1875                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1876                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1877                 break;
1878         case WINED3DTOP_BLENDCURRENTALPHA:
1879                 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
1880                 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
1881                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1882                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1883                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1884                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1885                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1886                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1887                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1888                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1889                 glTexEnvi(GL_TEXTURE_ENV, src2_target, useext(GL_PREVIOUS));
1890                 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_PREVIOUS");
1891                 glTexEnvi(GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA);
1892                 checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
1893                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1894                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1895                 break;
1896         case WINED3DTOP_DOTPRODUCT3:
1897                 if (GL_SUPPORT(ARB_TEXTURE_ENV_DOT3)) {
1898                   glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_ARB);
1899                   checkGLcall("GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_ARB");
1900                 } else if (GL_SUPPORT(EXT_TEXTURE_ENV_DOT3)) {
1901                   glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_EXT);
1902                   checkGLcall("GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_EXT");
1903                 } else {
1904                   FIXME("This version of opengl does not support GL_DOT3\n");
1905                 }
1906                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1907                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1908                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1909                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1910                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1911                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1912                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1913                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1914                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1915                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1916                 break;
1917         case WINED3DTOP_LERP:
1918                 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
1919                 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
1920                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1921                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1922                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1923                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1924                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1925                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1926                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1927                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1928                 glTexEnvi(GL_TEXTURE_ENV, src2_target, src3);
1929                 checkGLcall("GL_TEXTURE_ENV, src2_target, src3");
1930                 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr3);
1931                 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr3");
1932                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1933                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1934                 break;
1935         case WINED3DTOP_ADDSMOOTH:
1936                 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
1937                   glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
1938                   checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
1939                   glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1940                   checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1941                   switch (opr1) {
1942                   case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_COLOR; break;
1943                   case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_COLOR; break;
1944                   case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1945                   case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
1946                   }
1947                   glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
1948                   checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
1949                   glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
1950                   checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
1951                   glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
1952                   checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
1953                   glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1954                   checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1955                   glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1956                   checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1957                   glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1958                   checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1959                 } else
1960                   Handled = FALSE;
1961                 break;
1962         case WINED3DTOP_BLENDTEXTUREALPHAPM:
1963                 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
1964                   glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
1965                   checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
1966                   glTexEnvi(GL_TEXTURE_ENV, src0_target, GL_TEXTURE);
1967                   checkGLcall("GL_TEXTURE_ENV, src0_target, GL_TEXTURE");
1968                   glTexEnvi(GL_TEXTURE_ENV, opr0_target, GL_ONE_MINUS_SRC_ALPHA);
1969                   checkGLcall("GL_TEXTURE_ENV, opr0_target, GL_ONE_MINUS_SRC_APHA");
1970                   glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
1971                   checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
1972                   glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
1973                   checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
1974                   glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1975                   checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1976                   glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1977                   checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1978                   glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1979                   checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1980                 } else
1981                   Handled = FALSE;
1982                 break;
1983         case WINED3DTOP_MODULATEALPHA_ADDCOLOR:
1984                 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
1985                   glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
1986                   checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
1987                   glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1988                   checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1989                   switch (opr1) {
1990                   case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
1991                   case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1992                   case GL_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
1993                   case GL_ONE_MINUS_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1994                   }
1995                   glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
1996                   checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
1997                   glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
1998                   checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
1999                   glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
2000                   checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
2001                   glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
2002                   checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2003                   glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
2004                   checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2005                   glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2006                   checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2007                 } else
2008                   Handled = FALSE;
2009                 break;
2010         case WINED3DTOP_MODULATECOLOR_ADDALPHA:
2011                 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
2012                   glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
2013                   checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2014                   glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2015                   checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2016                   glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
2017                   checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2018                   glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
2019                   checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2020                   switch (opr1) {
2021                   case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
2022                   case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2023                   case GL_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
2024                   case GL_ONE_MINUS_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2025                   }
2026                   glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr);
2027                   checkGLcall("GL_TEXTURE_ENV, opr1_target, opr");
2028                   glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
2029                   checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2030                   glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
2031                   checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2032                   glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2033                   checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2034                 } else
2035                   Handled = FALSE;
2036                 break;
2037         case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR:
2038                 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
2039                   glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
2040                   checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2041                   glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2042                   checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2043                   switch (opr1) {
2044                   case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2045                   case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_ALPHA; break;
2046                   case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2047                   case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
2048                   }
2049                   glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
2050                   checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
2051                   glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
2052                   checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2053                   glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
2054                   checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
2055                   glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
2056                   checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2057                   glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
2058                   checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2059                   glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2060                   checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2061                 } else
2062                   Handled = FALSE;
2063                 break;
2064         case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA:
2065                 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
2066                   glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
2067                   checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2068                   glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2069                   checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2070                   switch (opr1) {
2071                   case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_COLOR; break;
2072                   case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_COLOR; break;
2073                   case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2074                   case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
2075                   }
2076                   glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
2077                   checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
2078                   glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
2079                   checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2080                   switch (opr1) {
2081                   case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
2082                   case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2083                   case GL_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
2084                   case GL_ONE_MINUS_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2085                   }
2086                   glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr);
2087                   checkGLcall("GL_TEXTURE_ENV, opr1_target, opr");
2088                   glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
2089                   checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2090                   glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
2091                   checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2092                   glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2093                   checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2094                 } else
2095                   Handled = FALSE;
2096                 break;
2097         case WINED3DTOP_MULTIPLYADD:
2098                 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
2099                   glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
2100                   checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2101                   glTexEnvi(GL_TEXTURE_ENV, src0_target, src3);
2102                   checkGLcall("GL_TEXTURE_ENV, src0_target, src3");
2103                   glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr3);
2104                   checkGLcall("GL_TEXTURE_ENV, opr0_target, opr3");
2105                   glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
2106                   checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2107                   glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
2108                   checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
2109                   glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
2110                   checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2111                   glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
2112                   checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2113                   glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2114                   checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2115                 } else
2116                   Handled = FALSE;
2117                 break;
2118         default:
2119                 Handled = FALSE;
2120         }
2121
2122         if (Handled) {
2123           BOOL  combineOK = TRUE;
2124           if (GL_SUPPORT(NV_TEXTURE_ENV_COMBINE4)) {
2125             DWORD op2;
2126
2127             if (isAlpha) {
2128               op2 = This->stateBlock->textureState[Stage][WINED3DTSS_COLOROP];
2129             } else {
2130               op2 = This->stateBlock->textureState[Stage][WINED3DTSS_ALPHAOP];
2131             }
2132
2133             /* Note: If COMBINE4 in effect can't go back to combine! */
2134             switch (op2) {
2135             case WINED3DTOP_ADDSMOOTH:
2136             case WINED3DTOP_BLENDTEXTUREALPHAPM:
2137             case WINED3DTOP_MODULATEALPHA_ADDCOLOR:
2138             case WINED3DTOP_MODULATECOLOR_ADDALPHA:
2139             case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR:
2140             case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA:
2141             case WINED3DTOP_MULTIPLYADD:
2142               /* Ignore those implemented in both cases */
2143               switch (op) {
2144               case WINED3DTOP_SELECTARG1:
2145               case WINED3DTOP_SELECTARG2:
2146                 combineOK = FALSE;
2147                 Handled   = FALSE;
2148                 break;
2149               default:
2150                 FIXME("Can't use COMBINE4 and COMBINE together, thisop=%s, otherop=%s, isAlpha(%d)\n", debug_d3dtop(op), debug_d3dtop(op2), isAlpha);
2151                 LEAVE_GL();
2152                 return;
2153               }
2154             }
2155           }
2156
2157           if (combineOK) {
2158             glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, useext(GL_COMBINE));
2159             checkGLcall("GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, useext(GL_COMBINE)");
2160
2161             LEAVE_GL();
2162             return;
2163           }
2164         }
2165
2166         LEAVE_GL();
2167
2168         /* After all the extensions, if still unhandled, report fixme */
2169         FIXME("Unhandled texture operation %s\n", debug_d3dtop(op));
2170         #undef GLINFO_LOCATION
2171 }
2172 #endif
2173
2174 /* Setup this textures matrix according to the texture flags*/
2175 void set_texture_matrix(const float *smat, DWORD flags, BOOL calculatedCoords)
2176 {
2177     float mat[16];
2178
2179     glMatrixMode(GL_TEXTURE);
2180     checkGLcall("glMatrixMode(GL_TEXTURE)");
2181
2182     if (flags == WINED3DTTFF_DISABLE) {
2183         glLoadIdentity();
2184         checkGLcall("glLoadIdentity()");
2185         return;
2186     }
2187
2188     if (flags == (WINED3DTTFF_COUNT1|WINED3DTTFF_PROJECTED)) {
2189         ERR("Invalid texture transform flags: WINED3DTTFF_COUNT1|WINED3DTTFF_PROJECTED\n");
2190         return;
2191     }
2192
2193     memcpy(mat, smat, 16 * sizeof(float));
2194
2195     switch (flags & ~WINED3DTTFF_PROJECTED) {
2196     case WINED3DTTFF_COUNT1: mat[1] = mat[5] = mat[13] = 0;
2197     case WINED3DTTFF_COUNT2: mat[2] = mat[6] = mat[10] = mat[14] = 0;
2198     default: mat[3] = mat[7] = mat[11] = 0, mat[15] = 1;
2199     }
2200
2201     if (flags & WINED3DTTFF_PROJECTED) {
2202         switch (flags & ~WINED3DTTFF_PROJECTED) {
2203         case WINED3DTTFF_COUNT2:
2204             mat[3] = mat[1], mat[7] = mat[5], mat[11] = mat[9], mat[15] = mat[13];
2205             mat[1] = mat[5] = mat[9] = mat[13] = 0;
2206             break;
2207         case WINED3DTTFF_COUNT3:
2208             mat[3] = mat[2], mat[7] = mat[6], mat[11] = mat[10], mat[15] = mat[14];
2209             mat[2] = mat[6] = mat[10] = mat[14] = 0;
2210             break;
2211         }
2212     } else if(!calculatedCoords) { /* under directx the R/Z coord can be used for translation, under opengl we use the Q coord instead */
2213         mat[12] = mat[8];
2214         mat[13] = mat[9];
2215     }
2216
2217     glLoadMatrixf(mat);
2218     checkGLcall("glLoadMatrixf(mat)");
2219 }
2220
2221 #define GLINFO_LOCATION ((IWineD3DImpl *)(This->wineD3D))->gl_info
2222
2223 /* Convertes a D3D format into a OpenGL configuration format */
2224 int D3DFmtMakeGlCfg(WINED3DFORMAT BackBufferFormat, WINED3DFORMAT StencilBufferFormat, int *attribs, int* nAttribs, BOOL alternate){
2225 #define PUSH1(att)        attribs[(*nAttribs)++] = (att);
2226 #define PUSH2(att,value)  attribs[(*nAttribs)++] = (att); attribs[(*nAttribs)++] = (value);
2227     /*We need to do some Card specific stuff in here at some point,
2228     D3D now supports floating point format buffers, and there are a number of different OpelGl ways of managing these e.g.
2229     GLX_ATI_pixel_format_float
2230     */
2231     switch (BackBufferFormat) {
2232         /* color buffer */
2233     case WINED3DFMT_P8:
2234         PUSH2(GLX_RENDER_TYPE,  GLX_COLOR_INDEX_BIT);
2235         PUSH2(GLX_BUFFER_SIZE,  8);
2236         PUSH2(GLX_DOUBLEBUFFER, TRUE);
2237         break;
2238
2239     case WINED3DFMT_R3G3B2:
2240         PUSH2(GLX_RENDER_TYPE,  GLX_RGBA_BIT);
2241         PUSH2(GLX_RED_SIZE,     3);
2242         PUSH2(GLX_GREEN_SIZE,   3);
2243         PUSH2(GLX_BLUE_SIZE,    2);
2244         break;
2245
2246     case WINED3DFMT_A1R5G5B5:
2247         PUSH2(GLX_ALPHA_SIZE,   1);
2248     case WINED3DFMT_X1R5G5B5:
2249         PUSH2(GLX_RED_SIZE,     5);
2250         PUSH2(GLX_GREEN_SIZE,   5);
2251         PUSH2(GLX_BLUE_SIZE,    5);
2252         break;
2253
2254     case WINED3DFMT_R5G6B5:
2255         PUSH2(GLX_RED_SIZE,     5);
2256         PUSH2(GLX_GREEN_SIZE,   6);
2257         PUSH2(GLX_BLUE_SIZE,    5);
2258         break;
2259
2260     case WINED3DFMT_A4R4G4B4:
2261         PUSH2(GLX_ALPHA_SIZE,   4);
2262     case WINED3DFMT_X4R4G4B4:
2263         PUSH2(GLX_RED_SIZE,     4);
2264         PUSH2(GLX_GREEN_SIZE,   4);
2265         PUSH2(GLX_BLUE_SIZE,    4);
2266         break;
2267
2268     case WINED3DFMT_A8R8G8B8:
2269         PUSH2(GLX_ALPHA_SIZE,   8);
2270     case WINED3DFMT_R8G8B8:
2271     case WINED3DFMT_X8R8G8B8:
2272         PUSH2(GLX_RED_SIZE,     8);
2273         PUSH2(GLX_GREEN_SIZE,   8);
2274         PUSH2(GLX_BLUE_SIZE,    8);
2275         break;
2276
2277     case WINED3DFMT_A2R10G10B10:
2278         PUSH2(GLX_ALPHA_SIZE,   2);
2279         PUSH2(GLX_RED_SIZE,    10);
2280         PUSH2(GLX_GREEN_SIZE,  10);
2281         PUSH2(GLX_BLUE_SIZE,   10);
2282         break;
2283
2284     case WINED3DFMT_A16B16G16R16:
2285         PUSH2(GLX_ALPHA_SIZE,  16);
2286         PUSH2(GLX_RED_SIZE,    16);
2287         PUSH2(GLX_GREEN_SIZE,  16);
2288         PUSH2(GLX_BLUE_SIZE,   16);
2289         break;
2290
2291     default:
2292         FIXME("Unsupported color format: %s\n", debug_d3dformat(BackBufferFormat));
2293         break;
2294     }
2295     if(!alternate){
2296         switch (StencilBufferFormat) {
2297     case 0:
2298         break;
2299
2300     case WINED3DFMT_D16_LOCKABLE:
2301     case WINED3DFMT_D16:
2302         PUSH2(GLX_DEPTH_SIZE,   16);
2303         break;
2304
2305     case WINED3DFMT_D15S1:
2306         PUSH2(GLX_DEPTH_SIZE,   15);
2307         PUSH2(GLX_STENCIL_SIZE, 1);
2308         /*Does openGl support a 1bit stencil?, I've seen it used elsewhere
2309         e.g. http://www.ks.uiuc.edu/Research/vmd/doxygen/OpenGLDisplayDevice_8C-source.html*/
2310         break;
2311
2312     case WINED3DFMT_D24X8:
2313         PUSH2(GLX_DEPTH_SIZE,   24);
2314         break;
2315
2316     case WINED3DFMT_D24X4S4:
2317         PUSH2(GLX_DEPTH_SIZE,   24);
2318         PUSH2(GLX_STENCIL_SIZE, 4);
2319         break;
2320
2321     case WINED3DFMT_D24S8:
2322         PUSH2(GLX_DEPTH_SIZE,   24);
2323         PUSH2(GLX_STENCIL_SIZE, 8);
2324         break;
2325
2326     case WINED3DFMT_D24FS8:
2327         PUSH2(GLX_DEPTH_SIZE,   24);
2328         PUSH2(GLX_STENCIL_SIZE, 8);
2329         break;
2330
2331     case WINED3DFMT_D32:
2332         PUSH2(GLX_DEPTH_SIZE,   32);
2333         break;
2334
2335     default:
2336         FIXME("Unsupported stencil format: %s\n", debug_d3dformat(StencilBufferFormat));
2337         break;
2338     }
2339
2340     } else { /* it the device doesn't support the 'exact' format, try to find something close */
2341         switch (StencilBufferFormat) {
2342         case 0:
2343             break;
2344
2345         case WINED3DFMT_D16_LOCKABLE:
2346         case WINED3DFMT_D16:
2347             PUSH2(GLX_DEPTH_SIZE,   1);
2348             break;
2349
2350         case WINED3DFMT_D15S1:
2351             PUSH2(GLX_DEPTH_SIZE,   1);
2352             PUSH2(GLX_STENCIL_SIZE, 1);
2353             /*Does openGl support a 1bit stencil?, I've seen it used elsewhere
2354             e.g. http://www.ks.uiuc.edu/Research/vmd/doxygen/OpenGLDisplayDevice_8C-source.html*/
2355             break;
2356
2357         case WINED3DFMT_D24X8:
2358             PUSH2(GLX_DEPTH_SIZE,   1);
2359             break;
2360
2361         case WINED3DFMT_D24X4S4:
2362             PUSH2(GLX_DEPTH_SIZE,   1);
2363             PUSH2(GLX_STENCIL_SIZE, 1);
2364             break;
2365
2366         case WINED3DFMT_D24S8:
2367             PUSH2(GLX_DEPTH_SIZE,   1);
2368             PUSH2(GLX_STENCIL_SIZE, 1);
2369             break;
2370
2371         case WINED3DFMT_D24FS8:
2372             PUSH2(GLX_DEPTH_SIZE,   1);
2373             PUSH2(GLX_STENCIL_SIZE, 1);
2374             break;
2375
2376         case WINED3DFMT_D32:
2377             PUSH2(GLX_DEPTH_SIZE,   1);
2378             break;
2379
2380         default:
2381             FIXME("Unsupported stencil format: %s\n", debug_d3dformat(StencilBufferFormat));
2382             break;
2383         }
2384     }
2385
2386     return *nAttribs;
2387 }
2388
2389 #undef GLINFO_LOCATION
2390
2391 /* DirectDraw stuff */
2392 WINED3DFORMAT pixelformat_for_depth(DWORD depth) {
2393     switch(depth) {
2394         case 8:  return WINED3DFMT_P8; break;
2395         case 15: return WINED3DFMT_X1R5G5B5; break;
2396         case 16: return WINED3DFMT_R5G6B5; break;
2397         case 24: return WINED3DFMT_R8G8B8; break;
2398         case 32: return WINED3DFMT_X8R8G8B8; break;
2399         default: return WINED3DFMT_UNKNOWN;
2400     }
2401 }
2402
2403 void multiply_matrix(WINED3DMATRIX *dest, const WINED3DMATRIX *src1, const WINED3DMATRIX *src2) {
2404     WINED3DMATRIX temp;
2405
2406     /* Now do the multiplication 'by hand'.
2407        I know that all this could be optimised, but this will be done later :-) */
2408     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);
2409     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);
2410     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);
2411     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);
2412
2413     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);
2414     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);
2415     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);
2416     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);
2417
2418     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);
2419     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);
2420     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);
2421     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);
2422
2423     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);
2424     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);
2425     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);
2426     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);
2427
2428     /* And copy the new matrix in the good storage.. */
2429     memcpy(dest, &temp, 16 * sizeof(float));
2430 }
2431
2432 DWORD get_flexible_vertex_size(DWORD d3dvtVertexType) {
2433     DWORD size = 0;
2434     int i;
2435     int numTextures = (d3dvtVertexType & WINED3DFVF_TEXCOUNT_MASK) >> WINED3DFVF_TEXCOUNT_SHIFT;
2436
2437     if (d3dvtVertexType & WINED3DFVF_NORMAL) size += 3 * sizeof(float);
2438     if (d3dvtVertexType & WINED3DFVF_DIFFUSE) size += sizeof(DWORD);
2439     if (d3dvtVertexType & WINED3DFVF_SPECULAR) size += sizeof(DWORD);
2440     if (d3dvtVertexType & WINED3DFVF_PSIZE) size += sizeof(DWORD);
2441     switch (d3dvtVertexType & WINED3DFVF_POSITION_MASK) {
2442         case WINED3DFVF_XYZ: size += 3 * sizeof(float); break;
2443         case WINED3DFVF_XYZRHW: size += 4 * sizeof(float); break;
2444         default: TRACE(" matrix weighting not handled yet...\n");
2445     }
2446     for (i = 0; i < numTextures; i++) {
2447         size += GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType, i) * sizeof(float);
2448     }
2449
2450     return size;
2451 }
2452
2453 /***********************************************************************
2454  * CalculateTexRect
2455  *
2456  * Calculates the dimensions of the opengl texture used for blits.
2457  * Handled oversized opengl textures and updates the source rectangle
2458  * accordingly
2459  *
2460  * Params:
2461  *  This: Surface to operate on
2462  *  Rect: Requested rectangle
2463  *
2464  * Returns:
2465  *  TRUE if the texture part can be loaded,
2466  *  FALSE otherwise
2467  *
2468  *********************************************************************/
2469 #define GLINFO_LOCATION ((IWineD3DImpl *)(This->resource.wineD3DDevice->wineD3D))->gl_info
2470
2471 BOOL CalculateTexRect(IWineD3DSurfaceImpl *This, RECT *Rect, float glTexCoord[4]) {
2472     int x1 = Rect->left, x2 = Rect->right;
2473     int y1 = Rect->top, y2 = Rect->bottom;
2474     GLint maxSize = GL_LIMITS(texture_size);
2475
2476     TRACE("(%p)->(%d,%d)-(%d,%d)\n", This,
2477           Rect->left, Rect->top, Rect->right, Rect->bottom);
2478
2479     /* The sizes might be reversed */
2480     if(Rect->left > Rect->right) {
2481         x1 = Rect->right;
2482         x2 = Rect->left;
2483     }
2484     if(Rect->top > Rect->bottom) {
2485         y1 = Rect->bottom;
2486         y2 = Rect->top;
2487     }
2488
2489     /* No oversized texture? This is easy */
2490     if(!(This->Flags & SFLAG_OVERSIZE)) {
2491         /* Which rect from the texture do I need? */
2492         glTexCoord[0] = (float) Rect->left / (float) This->pow2Width;
2493         glTexCoord[2] = (float) Rect->top / (float) This->pow2Height;
2494         glTexCoord[1] = (float) Rect->right / (float) This->pow2Width;
2495         glTexCoord[3] = (float) Rect->bottom / (float) This->pow2Height;
2496
2497         return TRUE;
2498     } else {
2499         /* Check if we can succeed at all */
2500         if( (x2 - x1) > maxSize ||
2501             (y2 - y1) > maxSize ) {
2502             TRACE("Requested rectangle is too large for gl\n");
2503             return FALSE;
2504         }
2505
2506         /* A part of the texture has to be picked. First, check if
2507          * some texture part is loaded already, if yes try to re-use it.
2508          * If the texture is dirty, or the part can't be used,
2509          * re-position the part to load
2510          */
2511         if(!(This->Flags & SFLAG_DIRTY)) {
2512             if(This->glRect.left <= x1 && This->glRect.right >= x2 &&
2513                This->glRect.top <= y1 && This->glRect.bottom >= x2 ) {
2514                 /* Ok, the rectangle is ok, re-use it */
2515                 TRACE("Using existing gl Texture\n");
2516             } else {
2517                 /* Rectangle is not ok, dirtify the texture to reload it */
2518                 TRACE("Dirtifying texture to force reload\n");
2519                 This->Flags |= SFLAG_DIRTY;
2520             }
2521         }
2522
2523         /* Now if we are dirty(no else if!) */
2524         if(This->Flags & SFLAG_DIRTY) {
2525             /* Set the new rectangle. Use the following strategy:
2526              * 1) Use as big textures as possible.
2527              * 2) Place the texture part in the way that the requested
2528              *    part is in the middle of the texture(well, almost)
2529              * 3) If the texture is moved over the edges of the
2530              *    surface, replace it nicely
2531              * 4) If the coord is not limiting the texture size,
2532              *    use the whole size
2533              */
2534             if((This->pow2Width) > maxSize) {
2535                 This->glRect.left = x1 - maxSize / 2;
2536                 if(This->glRect.left < 0) {
2537                     This->glRect.left = 0;
2538                 }
2539                 This->glRect.right = This->glRect.left + maxSize;
2540                 if(This->glRect.right > This->currentDesc.Width) {
2541                     This->glRect.right = This->currentDesc.Width;
2542                     This->glRect.left = This->glRect.right - maxSize;
2543                 }
2544             } else {
2545                 This->glRect.left = 0;
2546                 This->glRect.right = This->pow2Width;
2547             }
2548
2549             if(This->pow2Height > maxSize) {
2550                 This->glRect.top = x1 - GL_LIMITS(texture_size) / 2;
2551                 if(This->glRect.top < 0) This->glRect.top = 0;
2552                 This->glRect.bottom = This->glRect.left + maxSize;
2553                 if(This->glRect.bottom > This->currentDesc.Height) {
2554                     This->glRect.bottom = This->currentDesc.Height;
2555                     This->glRect.top = This->glRect.bottom - maxSize;
2556                 }
2557             } else {
2558                 This->glRect.top = 0;
2559                 This->glRect.bottom = This->pow2Height;
2560             }
2561             TRACE("(%p): Using rect (%d,%d)-(%d,%d)\n", This,
2562                    This->glRect.left, This->glRect.top, This->glRect.right, This->glRect.bottom);
2563         }
2564
2565         /* Re-calculate the rect to draw */
2566         Rect->left -= This->glRect.left;
2567         Rect->right -= This->glRect.left;
2568         Rect->top -= This->glRect.top;
2569         Rect->bottom -= This->glRect.top;
2570
2571         /* Get the gl coordinates. The gl rectangle is a power of 2, eigher the max size,
2572          * or the pow2Width / pow2Height of the surface
2573          */
2574         glTexCoord[0] = (float) Rect->left / (float) (This->glRect.right - This->glRect.left);
2575         glTexCoord[2] = (float) Rect->top / (float) (This->glRect.bottom - This->glRect.top);
2576         glTexCoord[1] = (float) Rect->right / (float) (This->glRect.right - This->glRect.left);
2577         glTexCoord[3] = (float) Rect->bottom / (float) (This->glRect.bottom - This->glRect.top);
2578     }
2579     return TRUE;
2580 }
2581 #undef GLINFO_LOCATION
2582
2583 /* Hash table functions */
2584
2585 hash_table_t *hash_table_create(hash_function_t *hash_function, compare_function_t *compare_function)
2586 {
2587     hash_table_t *table;
2588     unsigned int initial_size = 8;
2589
2590     table = HeapAlloc(GetProcessHeap(), 0, sizeof(hash_table_t) + (initial_size * sizeof(struct list)));
2591     if (!table)
2592     {
2593         ERR("Failed to allocate table, returning NULL.\n");
2594         return NULL;
2595     }
2596
2597     table->hash_function = hash_function;
2598     table->compare_function = compare_function;
2599
2600     table->grow_size = initial_size - (initial_size >> 2);
2601     table->shrink_size = 0;
2602
2603     table->buckets = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, initial_size * sizeof(struct list));
2604     if (!table->buckets)
2605     {
2606         ERR("Failed to allocate table buckets, returning NULL.\n");
2607         HeapFree(GetProcessHeap(), 0, table);
2608         return NULL;
2609     }
2610     table->bucket_count = initial_size;
2611
2612     table->entries = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, table->grow_size * sizeof(hash_table_entry_t));
2613     if (!table->entries)
2614     {
2615         ERR("Failed to allocate table entries, returning NULL.\n");
2616         HeapFree(GetProcessHeap(), 0, table->buckets);
2617         HeapFree(GetProcessHeap(), 0, table);
2618         return NULL;
2619     }
2620     table->entry_count = 0;
2621
2622     list_init(&table->free_entries);
2623     table->count = 0;
2624
2625     return table;
2626 }
2627
2628 void hash_table_destroy(hash_table_t *table)
2629 {
2630     unsigned int i = 0;
2631
2632     for (i = 0; i < table->entry_count; ++i)
2633     {
2634         HeapFree(GetProcessHeap(), 0, table->entries[i].key);
2635     }
2636
2637     HeapFree(GetProcessHeap(), 0, table->entries);
2638     HeapFree(GetProcessHeap(), 0, table->buckets);
2639     HeapFree(GetProcessHeap(), 0, table);
2640 }
2641
2642 static inline hash_table_entry_t *hash_table_get_by_idx(hash_table_t *table, void *key, unsigned int idx)
2643 {
2644     hash_table_entry_t *entry;
2645
2646     if (table->buckets[idx].next)
2647         LIST_FOR_EACH_ENTRY(entry, &(table->buckets[idx]), hash_table_entry_t, entry)
2648             if (table->compare_function(entry->key, key)) return entry;
2649
2650     return NULL;
2651 }
2652
2653 static BOOL hash_table_resize(hash_table_t *table, unsigned int new_bucket_count)
2654 {
2655     unsigned int new_entry_count = 0;
2656     hash_table_entry_t *new_entries;
2657     struct list *new_buckets;
2658     unsigned int grow_size = new_bucket_count - (new_bucket_count >> 2);
2659     unsigned int i;
2660
2661     new_buckets = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, new_bucket_count * sizeof(struct list));
2662     if (!new_buckets)
2663     {
2664         ERR("Failed to allocate new buckets, returning FALSE.\n");
2665         return FALSE;
2666     }
2667
2668     new_entries = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, grow_size * sizeof(hash_table_entry_t));
2669     if (!new_entries)
2670     {
2671         ERR("Failed to allocate new entries, returning FALSE.\n");
2672         HeapFree(GetProcessHeap(), 0, new_buckets);
2673         return FALSE;
2674     }
2675
2676     for (i = 0; i < table->bucket_count; ++i)
2677     {
2678         if (table->buckets[i].next)
2679         {
2680             hash_table_entry_t *entry, *entry2;
2681
2682             LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &table->buckets[i], hash_table_entry_t, entry)
2683             {
2684                 int j;
2685                 hash_table_entry_t *new_entry = new_entries + (new_entry_count++);
2686                 *new_entry = *entry;
2687
2688                 j = new_entry->hash & (new_bucket_count - 1);
2689
2690                 if (!new_buckets[j].next) list_init(&new_buckets[j]);
2691                 list_add_head(&new_buckets[j], &new_entry->entry);
2692             }
2693         }
2694     }
2695
2696     HeapFree(GetProcessHeap(), 0, table->buckets);
2697     table->buckets = new_buckets;
2698
2699     HeapFree(GetProcessHeap(), 0, table->entries);
2700     table->entries = new_entries;
2701
2702     table->entry_count = new_entry_count;
2703     list_init(&table->free_entries);
2704
2705     table->bucket_count = new_bucket_count;
2706     table->grow_size = grow_size;
2707     table->shrink_size = new_bucket_count > 8 ? new_bucket_count >> 2 : 0;
2708
2709     return TRUE;
2710 }
2711
2712 void hash_table_put(hash_table_t *table, void *key, void *value)
2713 {
2714     unsigned int idx;
2715     unsigned int hash;
2716     hash_table_entry_t *entry;
2717
2718     hash = table->hash_function(key);
2719     idx = hash & (table->bucket_count - 1);
2720     entry = hash_table_get_by_idx(table, key, idx);
2721
2722     if (entry)
2723     {
2724         HeapFree(GetProcessHeap(), 0, key);
2725         entry->value = value;
2726
2727         if (!value)
2728         {
2729             HeapFree(GetProcessHeap(), 0, entry->key);
2730             entry->key = NULL;
2731
2732             /* Remove the entry */
2733             list_remove(&entry->entry);
2734             list_add_head(&table->free_entries, &entry->entry);
2735
2736             --table->count;
2737
2738             /* Shrink if necessary */
2739             if (table->count < table->shrink_size) {
2740                 if (!hash_table_resize(table, table->bucket_count >> 1))
2741                 {
2742                     ERR("Failed to shrink the table...\n");
2743                 }
2744             }
2745         }
2746
2747         return;
2748     }
2749
2750     if (!value) return;
2751
2752     /* Grow if necessary */
2753     if (table->count >= table->grow_size)
2754     {
2755         if (!hash_table_resize(table, table->bucket_count << 1))
2756         {
2757             ERR("Failed to grow the table, returning.\n");
2758             return;
2759         }
2760
2761         idx = hash & (table->bucket_count - 1);
2762     }
2763
2764     /* Find an entry to insert */
2765     if (!list_empty(&table->free_entries))
2766     {
2767         struct list *elem = list_head(&table->free_entries);
2768
2769         list_remove(elem);
2770         entry = LIST_ENTRY(elem, hash_table_entry_t, entry);
2771     } else {
2772         entry = table->entries + (table->entry_count++);
2773     }
2774
2775     /* Insert the entry */
2776     entry->key = key;
2777     entry->value = value;
2778     entry->hash = hash;
2779     if (!table->buckets[idx].next) list_init(&table->buckets[idx]);
2780     list_add_head(&table->buckets[idx], &entry->entry);
2781
2782     ++table->count;
2783 }
2784
2785 void hash_table_remove(hash_table_t *table, void *key)
2786 {
2787     hash_table_put(table, key, NULL);
2788 }
2789
2790 void *hash_table_get(hash_table_t *table, void *key)
2791 {
2792     unsigned int idx;
2793     hash_table_entry_t *entry;
2794
2795     idx = table->hash_function(key) & (table->bucket_count - 1);
2796     entry = hash_table_get_by_idx(table, key, idx);
2797
2798     return entry ? entry->value : NULL;
2799 }