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 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_COMPRESSED_RGBA_S3TC_DXT1_EXT,0        },
  42     {WINED3DFMT_DXT2        ,0x0        ,0x0        ,0x0        ,0x0        ,1      ,TRUE       ,GL_COMPRESSED_RGBA_S3TC_DXT3_EXT,GL_COMPRESSED_RGBA_S3TC_DXT3_EXT,0        },
  43     {WINED3DFMT_DXT3        ,0x0        ,0x0        ,0x0        ,0x0        ,1      ,TRUE       ,GL_COMPRESSED_RGBA_S3TC_DXT3_EXT,GL_COMPRESSED_RGBA_S3TC_DXT3_EXT,0        },
  44     {WINED3DFMT_DXT4        ,0x0        ,0x0        ,0x0        ,0x0        ,1      ,TRUE       ,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,0        },
  45     {WINED3DFMT_DXT5        ,0x0        ,0x0        ,0x0        ,0x0        ,1      ,TRUE       ,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,0        },
  46     {WINED3DFMT_MULTI2_ARGB ,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      ,0                      ,0                  ,0                              },
  51     {WINED3DFMT_G32R32F     ,0x0        ,0x0        ,0x0        ,0x0        ,8      ,FALSE      ,0                      ,0                  ,0                              },
  52     {WINED3DFMT_A32B32G32R32F,0x0       ,0x0        ,0x0        ,0x0        ,16     ,FALSE      ,0                      ,0                  ,0                              },
  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      ,0                      ,0                  ,0                              },
  57     {WINED3DFMT_G16R16F     ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,FALSE      ,0                      ,0                  ,0                              },
  58     {WINED3DFMT_A16B16G16R16F,0x0       ,0x0        ,0x0        ,0x0        ,8      ,FALSE      ,0                      ,0                  ,0                              },
  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_COLOR_INDEX8_EXT    ,GL_COLOR_INDEX     ,GL_UNSIGNED_BYTE               },
  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_COLOR_INDEX         ,GL_COLOR_INDEX     ,GL_UNSIGNED_SHORT              },
  94     {WINED3DFMT_D32         ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,FALSE      ,GL_COLOR_INDEX         ,GL_COLOR_INDEX     ,GL_UNSIGNED_INT                },
  95     {WINED3DFMT_D15S1       ,0x0        ,0x0        ,0x0        ,0x0        ,2      ,FALSE      ,GL_COLOR_INDEX         ,GL_COLOR_INDEX     ,GL_UNSIGNED_SHORT              },
  96     {WINED3DFMT_D24S8       ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,FALSE      ,GL_COLOR_INDEX         ,GL_COLOR_INDEX     ,GL_UNSIGNED_INT                },
  97     {WINED3DFMT_D24X8       ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,FALSE      ,GL_COLOR_INDEX         ,GL_COLOR_INDEX     ,GL_UNSIGNED_INT                },
  98     {WINED3DFMT_D24X4S4     ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,FALSE      ,GL_COLOR_INDEX         ,GL_COLOR_INDEX     ,GL_UNSIGNED_INT                },
  99     {WINED3DFMT_D16         ,0x0        ,0x0        ,0x0        ,0x0        ,2      ,FALSE      ,GL_COLOR_INDEX         ,GL_COLOR_INDEX     ,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      ,0                      ,0                  ,0                              },
 102     {WINED3DFMT_D24FS8      ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,FALSE      ,0                      ,0                  ,0                              },
 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_ARGB);
 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) D3DFORMAT!\n", fmt, fourcc);
 212       else
 213         FIXME("Unrecognized %u D3DFORMAT!\n", fmt);
 214     }
 215     return "unrecognized";
 216   }
 217 }
 218
 219 const char* debug_d3ddevicetype(D3DDEVTYPE devtype) {
 220   switch (devtype) {
 221 #define DEVTYPE_TO_STR(dev) case dev: return #dev
 222     DEVTYPE_TO_STR(D3DDEVTYPE_HAL);
 223     DEVTYPE_TO_STR(D3DDEVTYPE_REF);
 224     DEVTYPE_TO_STR(D3DDEVTYPE_SW);
 225 #undef DEVTYPE_TO_STR
 226   default:
 227     FIXME("Unrecognized %u D3DDEVTYPE!\n", devtype);
 228     return "unrecognized";
 229   }
 230 }
 231
 232 const char* debug_d3dusage(DWORD usage) {
 233   switch (usage) {
 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 #undef WINED3DUSAGE_TO_STR
 245   case 0: return "none";
 246   default:
 247     FIXME("Unrecognized %lu Usage!\n", usage);
 248     return "unrecognized";
 249   }
 250 }
 251
 252 const char* debug_d3ddeclusage(BYTE usage) {
 253     switch (usage) {
 254 #define WINED3DDECLUSAGE_TO_STR(u) case u: return #u
 255         WINED3DDECLUSAGE_TO_STR(D3DDECLUSAGE_POSITION);
 256         WINED3DDECLUSAGE_TO_STR(D3DDECLUSAGE_BLENDWEIGHT);
 257         WINED3DDECLUSAGE_TO_STR(D3DDECLUSAGE_BLENDINDICES);
 258         WINED3DDECLUSAGE_TO_STR(D3DDECLUSAGE_NORMAL);
 259         WINED3DDECLUSAGE_TO_STR(D3DDECLUSAGE_PSIZE);
 260         WINED3DDECLUSAGE_TO_STR(D3DDECLUSAGE_TEXCOORD);
 261         WINED3DDECLUSAGE_TO_STR(D3DDECLUSAGE_TANGENT);
 262         WINED3DDECLUSAGE_TO_STR(D3DDECLUSAGE_BINORMAL);
 263         WINED3DDECLUSAGE_TO_STR(D3DDECLUSAGE_TESSFACTOR);
 264         WINED3DDECLUSAGE_TO_STR(D3DDECLUSAGE_POSITIONT);
 265         WINED3DDECLUSAGE_TO_STR(D3DDECLUSAGE_COLOR);
 266         WINED3DDECLUSAGE_TO_STR(D3DDECLUSAGE_FOG);
 267         WINED3DDECLUSAGE_TO_STR(D3DDECLUSAGE_DEPTH);
 268         WINED3DDECLUSAGE_TO_STR(D3DDECLUSAGE_SAMPLE);
 269 #undef WINED3DDECLUSAGE_TO_STR
 270         default:
 271             FIXME("Unrecognized %u declaration usage!\n", usage);
 272             return "unrecognized";
 273     }
 274 }
 275
 276 const char* debug_d3dresourcetype(WINED3DRESOURCETYPE res) {
 277   switch (res) {
 278 #define RES_TO_STR(res) case res: return #res;
 279     RES_TO_STR(WINED3DRTYPE_SURFACE);
 280     RES_TO_STR(WINED3DRTYPE_VOLUME);
 281     RES_TO_STR(WINED3DRTYPE_TEXTURE);
 282     RES_TO_STR(WINED3DRTYPE_VOLUMETEXTURE);
 283     RES_TO_STR(WINED3DRTYPE_CUBETEXTURE);
 284     RES_TO_STR(WINED3DRTYPE_VERTEXBUFFER);
 285     RES_TO_STR(WINED3DRTYPE_INDEXBUFFER);
 286 #undef  RES_TO_STR
 287   default:
 288     FIXME("Unrecognized %u WINED3DRESOURCETYPE!\n", res);
 289     return "unrecognized";
 290   }
 291 }
 292
 293 const char* debug_d3dprimitivetype(D3DPRIMITIVETYPE PrimitiveType) {
 294   switch (PrimitiveType) {
 295 #define PRIM_TO_STR(prim) case prim: return #prim;
 296     PRIM_TO_STR(D3DPT_POINTLIST);
 297     PRIM_TO_STR(D3DPT_LINELIST);
 298     PRIM_TO_STR(D3DPT_LINESTRIP);
 299     PRIM_TO_STR(D3DPT_TRIANGLELIST);
 300     PRIM_TO_STR(D3DPT_TRIANGLESTRIP);
 301     PRIM_TO_STR(D3DPT_TRIANGLEFAN);
 302 #undef  PRIM_TO_STR
 303   default:
 304     FIXME("Unrecognized %u D3DPRIMITIVETYPE!\n", PrimitiveType);
 305     return "unrecognized";
 306   }
 307 }
 308
 309 const char* debug_d3drenderstate(DWORD state) {
 310   switch (state) {
 311 #define D3DSTATE_TO_STR(u) case u: return #u
 312     D3DSTATE_TO_STR(WINED3DRS_TEXTUREHANDLE             );
 313     D3DSTATE_TO_STR(WINED3DRS_ANTIALIAS                 );
 314     D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESS            );
 315     D3DSTATE_TO_STR(WINED3DRS_TEXTUREPERSPECTIVE        );
 316     D3DSTATE_TO_STR(WINED3DRS_WRAPU                     );
 317     D3DSTATE_TO_STR(WINED3DRS_WRAPV                     );
 318     D3DSTATE_TO_STR(WINED3DRS_ZENABLE                   );
 319     D3DSTATE_TO_STR(WINED3DRS_FILLMODE                  );
 320     D3DSTATE_TO_STR(WINED3DRS_SHADEMODE                 );
 321     D3DSTATE_TO_STR(WINED3DRS_LINEPATTERN               );
 322     D3DSTATE_TO_STR(WINED3DRS_MONOENABLE                );
 323     D3DSTATE_TO_STR(WINED3DRS_ROP2                      );
 324     D3DSTATE_TO_STR(WINED3DRS_PLANEMASK                 );
 325     D3DSTATE_TO_STR(WINED3DRS_ZWRITEENABLE              );
 326     D3DSTATE_TO_STR(WINED3DRS_ALPHATESTENABLE           );
 327     D3DSTATE_TO_STR(WINED3DRS_LASTPIXEL                 );
 328     D3DSTATE_TO_STR(WINED3DRS_TEXTUREMAG                );
 329     D3DSTATE_TO_STR(WINED3DRS_TEXTUREMIN                );
 330     D3DSTATE_TO_STR(WINED3DRS_SRCBLEND                  );
 331     D3DSTATE_TO_STR(WINED3DRS_DESTBLEND                 );
 332     D3DSTATE_TO_STR(WINED3DRS_TEXTUREMAPBLEND           );
 333     D3DSTATE_TO_STR(WINED3DRS_CULLMODE                  );
 334     D3DSTATE_TO_STR(WINED3DRS_ZFUNC                     );
 335     D3DSTATE_TO_STR(WINED3DRS_ALPHAREF                  );
 336     D3DSTATE_TO_STR(WINED3DRS_ALPHAFUNC                 );
 337     D3DSTATE_TO_STR(WINED3DRS_DITHERENABLE              );
 338     D3DSTATE_TO_STR(WINED3DRS_ALPHABLENDENABLE          );
 339     D3DSTATE_TO_STR(WINED3DRS_FOGENABLE                 );
 340     D3DSTATE_TO_STR(WINED3DRS_SPECULARENABLE            );
 341     D3DSTATE_TO_STR(WINED3DRS_ZVISIBLE                  );
 342     D3DSTATE_TO_STR(WINED3DRS_SUBPIXEL                  );
 343     D3DSTATE_TO_STR(WINED3DRS_SUBPIXELX                 );
 344     D3DSTATE_TO_STR(WINED3DRS_STIPPLEDALPHA             );
 345     D3DSTATE_TO_STR(WINED3DRS_FOGCOLOR                  );
 346     D3DSTATE_TO_STR(WINED3DRS_FOGTABLEMODE              );
 347     D3DSTATE_TO_STR(WINED3DRS_FOGSTART                  );
 348     D3DSTATE_TO_STR(WINED3DRS_FOGEND                    );
 349     D3DSTATE_TO_STR(WINED3DRS_FOGDENSITY                );
 350     D3DSTATE_TO_STR(WINED3DRS_STIPPLEENABLE             );
 351     D3DSTATE_TO_STR(WINED3DRS_EDGEANTIALIAS             );
 352     D3DSTATE_TO_STR(WINED3DRS_COLORKEYENABLE            );
 353     D3DSTATE_TO_STR(WINED3DRS_BORDERCOLOR               );
 354     D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESSU           );
 355     D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESSV           );
 356     D3DSTATE_TO_STR(WINED3DRS_MIPMAPLODBIAS             );
 357     D3DSTATE_TO_STR(WINED3DRS_ZBIAS                     );
 358     D3DSTATE_TO_STR(WINED3DRS_RANGEFOGENABLE            );
 359     D3DSTATE_TO_STR(WINED3DRS_ANISOTROPY                );
 360     D3DSTATE_TO_STR(WINED3DRS_FLUSHBATCH                );
 361     D3DSTATE_TO_STR(WINED3DRS_TRANSLUCENTSORTINDEPENDENT);
 362     D3DSTATE_TO_STR(WINED3DRS_STENCILENABLE             );
 363     D3DSTATE_TO_STR(WINED3DRS_STENCILFAIL               );
 364     D3DSTATE_TO_STR(WINED3DRS_STENCILZFAIL              );
 365     D3DSTATE_TO_STR(WINED3DRS_STENCILPASS               );
 366     D3DSTATE_TO_STR(WINED3DRS_STENCILFUNC               );
 367     D3DSTATE_TO_STR(WINED3DRS_STENCILREF                );
 368     D3DSTATE_TO_STR(WINED3DRS_STENCILMASK               );
 369     D3DSTATE_TO_STR(WINED3DRS_STENCILWRITEMASK          );
 370     D3DSTATE_TO_STR(WINED3DRS_TEXTUREFACTOR             );
 371     D3DSTATE_TO_STR(WINED3DRS_WRAP0                     );
 372     D3DSTATE_TO_STR(WINED3DRS_WRAP1                     );
 373     D3DSTATE_TO_STR(WINED3DRS_WRAP2                     );
 374     D3DSTATE_TO_STR(WINED3DRS_WRAP3                     );
 375     D3DSTATE_TO_STR(WINED3DRS_WRAP4                     );
 376     D3DSTATE_TO_STR(WINED3DRS_WRAP5                     );
 377     D3DSTATE_TO_STR(WINED3DRS_WRAP6                     );
 378     D3DSTATE_TO_STR(WINED3DRS_WRAP7                     );
 379     D3DSTATE_TO_STR(WINED3DRS_CLIPPING                  );
 380     D3DSTATE_TO_STR(WINED3DRS_LIGHTING                  );
 381     D3DSTATE_TO_STR(WINED3DRS_EXTENTS                   );
 382     D3DSTATE_TO_STR(WINED3DRS_AMBIENT                   );
 383     D3DSTATE_TO_STR(WINED3DRS_FOGVERTEXMODE             );
 384     D3DSTATE_TO_STR(WINED3DRS_COLORVERTEX               );
 385     D3DSTATE_TO_STR(WINED3DRS_LOCALVIEWER               );
 386     D3DSTATE_TO_STR(WINED3DRS_NORMALIZENORMALS          );
 387     D3DSTATE_TO_STR(WINED3DRS_COLORKEYBLENDENABLE       );
 388     D3DSTATE_TO_STR(WINED3DRS_DIFFUSEMATERIALSOURCE     );
 389     D3DSTATE_TO_STR(WINED3DRS_SPECULARMATERIALSOURCE    );
 390     D3DSTATE_TO_STR(WINED3DRS_AMBIENTMATERIALSOURCE     );
 391     D3DSTATE_TO_STR(WINED3DRS_EMISSIVEMATERIALSOURCE    );
 392     D3DSTATE_TO_STR(WINED3DRS_VERTEXBLEND               );
 393     D3DSTATE_TO_STR(WINED3DRS_CLIPPLANEENABLE           );
 394     D3DSTATE_TO_STR(WINED3DRS_SOFTWAREVERTEXPROCESSING  );
 395     D3DSTATE_TO_STR(WINED3DRS_POINTSIZE                 );
 396     D3DSTATE_TO_STR(WINED3DRS_POINTSIZE_MIN             );
 397     D3DSTATE_TO_STR(WINED3DRS_POINTSPRITEENABLE         );
 398     D3DSTATE_TO_STR(WINED3DRS_POINTSCALEENABLE          );
 399     D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_A              );
 400     D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_B              );
 401     D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_C              );
 402     D3DSTATE_TO_STR(WINED3DRS_MULTISAMPLEANTIALIAS      );
 403     D3DSTATE_TO_STR(WINED3DRS_MULTISAMPLEMASK           );
 404     D3DSTATE_TO_STR(WINED3DRS_PATCHEDGESTYLE            );
 405     D3DSTATE_TO_STR(WINED3DRS_PATCHSEGMENTS             );
 406     D3DSTATE_TO_STR(WINED3DRS_DEBUGMONITORTOKEN         );
 407     D3DSTATE_TO_STR(WINED3DRS_POINTSIZE_MAX             );
 408     D3DSTATE_TO_STR(WINED3DRS_INDEXEDVERTEXBLENDENABLE  );
 409     D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE          );
 410     D3DSTATE_TO_STR(WINED3DRS_TWEENFACTOR               );
 411     D3DSTATE_TO_STR(WINED3DRS_BLENDOP                   );
 412     D3DSTATE_TO_STR(WINED3DRS_POSITIONDEGREE            );
 413     D3DSTATE_TO_STR(WINED3DRS_NORMALDEGREE              );
 414     D3DSTATE_TO_STR(WINED3DRS_SCISSORTESTENABLE         );
 415     D3DSTATE_TO_STR(WINED3DRS_SLOPESCALEDEPTHBIAS       );
 416     D3DSTATE_TO_STR(WINED3DRS_ANTIALIASEDLINEENABLE     );
 417     D3DSTATE_TO_STR(WINED3DRS_MINTESSELLATIONLEVEL      );
 418     D3DSTATE_TO_STR(WINED3DRS_MAXTESSELLATIONLEVEL      );
 419     D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_X            );
 420     D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_Y            );
 421     D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_Z            );
 422     D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_W            );
 423     D3DSTATE_TO_STR(WINED3DRS_ENABLEADAPTIVETESSELLATION);
 424     D3DSTATE_TO_STR(WINED3DRS_TWOSIDEDSTENCILMODE       );
 425     D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILFAIL           );
 426     D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILZFAIL          );
 427     D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILPASS           );
 428     D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILFUNC           );
 429     D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE1         );
 430     D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE2         );
 431     D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE3         );
 432     D3DSTATE_TO_STR(WINED3DRS_BLENDFACTOR               );
 433     D3DSTATE_TO_STR(WINED3DRS_SRGBWRITEENABLE           );
 434     D3DSTATE_TO_STR(WINED3DRS_DEPTHBIAS                 );
 435     D3DSTATE_TO_STR(WINED3DRS_WRAP8                     );
 436     D3DSTATE_TO_STR(WINED3DRS_WRAP9                     );
 437     D3DSTATE_TO_STR(WINED3DRS_WRAP10                    );
 438     D3DSTATE_TO_STR(WINED3DRS_WRAP11                    );
 439     D3DSTATE_TO_STR(WINED3DRS_WRAP12                    );
 440     D3DSTATE_TO_STR(WINED3DRS_WRAP13                    );
 441     D3DSTATE_TO_STR(WINED3DRS_WRAP14                    );
 442     D3DSTATE_TO_STR(WINED3DRS_WRAP15                    );
 443     D3DSTATE_TO_STR(WINED3DRS_SEPARATEALPHABLENDENABLE  );
 444     D3DSTATE_TO_STR(WINED3DRS_SRCBLENDALPHA             );
 445     D3DSTATE_TO_STR(WINED3DRS_DESTBLENDALPHA            );
 446     D3DSTATE_TO_STR(WINED3DRS_BLENDOPALPHA              );
 447 #undef D3DSTATE_TO_STR
 448   default:
 449     FIXME("Unrecognized %lu render state!\n", state);
 450     return "unrecognized";
 451   }
 452 }
 453
 454 const char* debug_d3dsamplerstate(DWORD state) {
 455   switch (state) {
 456 #define D3DSTATE_TO_STR(u) case u: return #u
 457     D3DSTATE_TO_STR(WINED3DSAMP_BORDERCOLOR  );
 458     D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSU     );
 459     D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSV     );
 460     D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSW     );
 461     D3DSTATE_TO_STR(WINED3DSAMP_MAGFILTER    );
 462     D3DSTATE_TO_STR(WINED3DSAMP_MINFILTER    );
 463     D3DSTATE_TO_STR(WINED3DSAMP_MIPFILTER    );
 464     D3DSTATE_TO_STR(WINED3DSAMP_MIPMAPLODBIAS);
 465     D3DSTATE_TO_STR(WINED3DSAMP_MAXMIPLEVEL  );
 466     D3DSTATE_TO_STR(WINED3DSAMP_MAXANISOTROPY);
 467     D3DSTATE_TO_STR(WINED3DSAMP_SRGBTEXTURE  );
 468     D3DSTATE_TO_STR(WINED3DSAMP_ELEMENTINDEX );
 469     D3DSTATE_TO_STR(WINED3DSAMP_DMAPOFFSET   );
 470 #undef D3DSTATE_TO_STR
 471   default:
 472     FIXME("Unrecognized %lu sampler state!\n", state);
 473     return "unrecognized";
 474   }
 475 }
 476
 477 const char* debug_d3dtexturestate(DWORD state) {
 478   switch (state) {
 479 #define D3DSTATE_TO_STR(u) case u: return #u
 480     D3DSTATE_TO_STR(WINED3DTSS_COLOROP               );
 481     D3DSTATE_TO_STR(WINED3DTSS_COLORARG1             );
 482     D3DSTATE_TO_STR(WINED3DTSS_COLORARG2             );
 483     D3DSTATE_TO_STR(WINED3DTSS_ALPHAOP               );
 484     D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG1             );
 485     D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG2             );
 486     D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT00          );
 487     D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT01          );
 488     D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT10          );
 489     D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT11          );
 490     D3DSTATE_TO_STR(WINED3DTSS_TEXCOORDINDEX         );
 491     D3DSTATE_TO_STR(WINED3DTSS_BUMPENVLSCALE         );
 492     D3DSTATE_TO_STR(WINED3DTSS_BUMPENVLOFFSET        );
 493     D3DSTATE_TO_STR(WINED3DTSS_TEXTURETRANSFORMFLAGS );
 494     D3DSTATE_TO_STR(WINED3DTSS_ADDRESSW              );
 495     D3DSTATE_TO_STR(WINED3DTSS_COLORARG0             );
 496     D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG0             );
 497     D3DSTATE_TO_STR(WINED3DTSS_RESULTARG             );
 498     D3DSTATE_TO_STR(WINED3DTSS_CONSTANT              );
 499 #undef D3DSTATE_TO_STR
 500   case 12:
 501     /* Note D3DTSS are not consecutive, so skip these */
 502     return "unused";
 503     break;
 504   default:
 505     FIXME("Unrecognized %lu texture state!\n", state);
 506     return "unrecognized";
 507   }
 508 }
 509
 510 const char* debug_d3dtop(D3DTEXTUREOP d3dtop) {
 511     switch (d3dtop) {
 512 #define D3DTOP_TO_STR(u) case u: return #u
 513         D3DTOP_TO_STR(D3DTOP_DISABLE);
 514         D3DTOP_TO_STR(D3DTOP_SELECTARG1);
 515         D3DTOP_TO_STR(D3DTOP_SELECTARG2);
 516         D3DTOP_TO_STR(D3DTOP_MODULATE);
 517         D3DTOP_TO_STR(D3DTOP_MODULATE2X);
 518         D3DTOP_TO_STR(D3DTOP_MODULATE4X);
 519         D3DTOP_TO_STR(D3DTOP_ADD);
 520         D3DTOP_TO_STR(D3DTOP_ADDSIGNED);
 521         D3DTOP_TO_STR(D3DTOP_SUBTRACT);
 522         D3DTOP_TO_STR(D3DTOP_ADDSMOOTH);
 523         D3DTOP_TO_STR(D3DTOP_BLENDDIFFUSEALPHA);
 524         D3DTOP_TO_STR(D3DTOP_BLENDTEXTUREALPHA);
 525         D3DTOP_TO_STR(D3DTOP_BLENDFACTORALPHA);
 526         D3DTOP_TO_STR(D3DTOP_BLENDTEXTUREALPHAPM);
 527         D3DTOP_TO_STR(D3DTOP_BLENDCURRENTALPHA);
 528         D3DTOP_TO_STR(D3DTOP_PREMODULATE);
 529         D3DTOP_TO_STR(D3DTOP_MODULATEALPHA_ADDCOLOR);
 530         D3DTOP_TO_STR(D3DTOP_MODULATECOLOR_ADDALPHA);
 531         D3DTOP_TO_STR(D3DTOP_MODULATEINVALPHA_ADDCOLOR);
 532         D3DTOP_TO_STR(D3DTOP_MODULATEINVCOLOR_ADDALPHA);
 533         D3DTOP_TO_STR(D3DTOP_BUMPENVMAP);
 534         D3DTOP_TO_STR(D3DTOP_BUMPENVMAPLUMINANCE);
 535         D3DTOP_TO_STR(D3DTOP_DOTPRODUCT3);
 536         D3DTOP_TO_STR(D3DTOP_MULTIPLYADD);
 537         D3DTOP_TO_STR(D3DTOP_LERP);
 538 #undef D3DTOP_TO_STR
 539         default:
 540             FIXME("Unrecognized %u D3DTOP\n", d3dtop);
 541             return "unrecognized";
 542     }
 543 }
 544
 545 const char* debug_d3dtstype(WINED3DTRANSFORMSTATETYPE tstype) {
 546     switch (tstype) {
 547 #define TSTYPE_TO_STR(tstype) case tstype: return #tstype
 548     TSTYPE_TO_STR(WINED3DTS_VIEW);
 549     TSTYPE_TO_STR(WINED3DTS_PROJECTION);
 550     TSTYPE_TO_STR(WINED3DTS_TEXTURE0);
 551     TSTYPE_TO_STR(WINED3DTS_TEXTURE1);
 552     TSTYPE_TO_STR(WINED3DTS_TEXTURE2);
 553     TSTYPE_TO_STR(WINED3DTS_TEXTURE3);
 554     TSTYPE_TO_STR(WINED3DTS_TEXTURE4);
 555     TSTYPE_TO_STR(WINED3DTS_TEXTURE5);
 556     TSTYPE_TO_STR(WINED3DTS_TEXTURE6);
 557     TSTYPE_TO_STR(WINED3DTS_TEXTURE7);
 558     TSTYPE_TO_STR(WINED3DTS_WORLDMATRIX(0));
 559 #undef TSTYPE_TO_STR
 560     default:
 561         if (tstype > 256 && tstype < 512) {
 562             FIXME("WINED3DTS_WORLDMATRIX(%u). 1..255 not currently supported\n", tstype);
 563             return ("WINED3DTS_WORLDMATRIX > 0");
 564         }
 565         FIXME("Unrecognized %u WINED3DTS\n", tstype);
 566         return "unrecognized";
 567     }
 568 }
 569
 570 const char* debug_d3dpool(WINED3DPOOL Pool) {
 571   switch (Pool) {
 572 #define POOL_TO_STR(p) case p: return #p;
 573     POOL_TO_STR(WINED3DPOOL_DEFAULT);
 574     POOL_TO_STR(WINED3DPOOL_MANAGED);
 575     POOL_TO_STR(WINED3DPOOL_SYSTEMMEM);
 576     POOL_TO_STR(WINED3DPOOL_SCRATCH);
 577 #undef  POOL_TO_STR
 578   default:
 579     FIXME("Unrecognized %u WINED3DPOOL!\n", Pool);
 580     return "unrecognized";
 581   }
 582 }
 583 /*****************************************************************************
 584  * Useful functions mapping GL <-> D3D values
 585  */
 586 GLenum StencilOp(DWORD op) {
 587     switch(op) {
 588     case D3DSTENCILOP_KEEP    : return GL_KEEP;
 589     case D3DSTENCILOP_ZERO    : return GL_ZERO;
 590     case D3DSTENCILOP_REPLACE : return GL_REPLACE;
 591     case D3DSTENCILOP_INCRSAT : return GL_INCR;
 592     case D3DSTENCILOP_DECRSAT : return GL_DECR;
 593     case D3DSTENCILOP_INVERT  : return GL_INVERT;
 594     case D3DSTENCILOP_INCR    : return GL_INCR_WRAP_EXT;
 595     case D3DSTENCILOP_DECR    : return GL_DECR_WRAP_EXT;
 596     default:
 597         FIXME("Unrecognized stencil op %ld\n", op);
 598         return GL_KEEP;
 599     }
 600 }
 601
 602 GLenum StencilFunc(DWORD func) {
 603     switch ((D3DCMPFUNC)func) {
 604     case D3DCMP_NEVER        : return GL_NEVER;
 605     case D3DCMP_LESS         : return GL_LESS;
 606     case D3DCMP_EQUAL        : return GL_EQUAL;
 607     case D3DCMP_LESSEQUAL    : return GL_LEQUAL;
 608     case D3DCMP_GREATER      : return GL_GREATER;
 609     case D3DCMP_NOTEQUAL     : return GL_NOTEQUAL;
 610     case D3DCMP_GREATEREQUAL : return GL_GEQUAL;
 611     case D3DCMP_ALWAYS       : return GL_ALWAYS;
 612     default:
 613         FIXME("Unrecognized D3DCMPFUNC value %ld\n", func);
 614         return GL_ALWAYS;
 615     }
 616 }
 617
 618 static GLenum d3dta_to_combiner_input(DWORD d3dta, DWORD stage, INT texture_idx) {
 619     switch (d3dta) {
 620         case D3DTA_DIFFUSE:
 621             return GL_PRIMARY_COLOR_NV;
 622
 623         case D3DTA_CURRENT:
 624             if (stage) return GL_SPARE0_NV;
 625             else return GL_PRIMARY_COLOR_NV;
 626
 627         case D3DTA_TEXTURE:
 628             if (texture_idx > -1) return GL_TEXTURE0_ARB + texture_idx;
 629             else return GL_PRIMARY_COLOR_NV;
 630
 631         case D3DTA_TFACTOR:
 632             return GL_CONSTANT_COLOR0_NV;
 633
 634         case D3DTA_SPECULAR:
 635             return GL_SECONDARY_COLOR_NV;
 636
 637         case D3DTA_TEMP:
 638             /* TODO: Support D3DTSS_RESULTARG */
 639             FIXME("D3DTA_TEMP, not properly supported.");
 640             return GL_SPARE1_NV;
 641
 642         case D3DTA_CONSTANT:
 643             /* TODO: Support per stage constants (D3DTSS_CONSTANT, NV_register_combiners2) */
 644             FIXME("D3DTA_CONSTANT, not properly supported.");
 645             return GL_CONSTANT_COLOR1_NV;
 646
 647         default:
 648             FIXME("Unrecognized texture arg %#lx\n", d3dta);
 649             return GL_TEXTURE;
 650     }
 651 }
 652
 653 static GLenum invert_mapping(GLenum mapping) {
 654     if (mapping == GL_UNSIGNED_INVERT_NV) return GL_SIGNED_IDENTITY_NV;
 655     else if (mapping == GL_SIGNED_IDENTITY_NV) return GL_UNSIGNED_INVERT_NV;
 656
 657     FIXME("Unhandled mapping %#x\n", mapping);
 658     return mapping;
 659 }
 660
 661 static void get_src_and_opr_nvrc(DWORD stage, DWORD arg, BOOL is_alpha, GLenum* input, GLenum* mapping, GLenum *component_usage, INT texture_idx) {
 662     /* The D3DTA_COMPLEMENT flag specifies the complement of the input should
 663      * be used. */
 664     if (arg & D3DTA_COMPLEMENT) *mapping = GL_UNSIGNED_INVERT_NV;
 665     else *mapping = GL_SIGNED_IDENTITY_NV;
 666
 667     /* The D3DTA_ALPHAREPLICATE flag specifies the alpha component of the input
 668      * should be used for all input components. */
 669     if (is_alpha || arg & D3DTA_ALPHAREPLICATE) *component_usage = GL_ALPHA;
 670     else *component_usage = GL_RGB;
 671
 672     *input = d3dta_to_combiner_input(arg & D3DTA_SELECTMASK, stage, texture_idx);
 673 }
 674
 675 typedef struct {
 676     GLenum input[3];
 677     GLenum mapping[3];
 678     GLenum component_usage[3];
 679 } tex_op_args;
 680
 681 static BOOL is_invalid_op(IWineD3DDeviceImpl *This, int stage, D3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3) {
 682     if (op == D3DTOP_DISABLE) return FALSE;
 683     if (This->stateBlock->textures[stage]) return FALSE;
 684
 685     if (arg1 == D3DTA_TEXTURE && op != D3DTOP_SELECTARG2) return TRUE;
 686     if (arg2 == D3DTA_TEXTURE && op != D3DTOP_SELECTARG1) return TRUE;
 687     if (arg3 == D3DTA_TEXTURE && (op == D3DTOP_MULTIPLYADD || op == D3DTOP_LERP)) return TRUE;
 688
 689     return FALSE;
 690 }
 691
 692 void set_tex_op_nvrc(IWineD3DDevice *iface, BOOL is_alpha, int stage, D3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3, INT texture_idx) {
 693     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl*)iface;
 694     tex_op_args tex_op_args = {{0}, {0}, {0}};
 695     GLenum portion = is_alpha ? GL_ALPHA : GL_RGB;
 696     GLenum target = GL_COMBINER0_NV + stage;
 697
 698     TRACE("stage %d, is_alpha %d, op %s, arg1 %#lx, arg2 %#lx, arg3 %#lx, texture_idx %d\n",
 699             stage, is_alpha, debug_d3dtop(op), arg1, arg2, arg3, texture_idx);
 700
 701     /* If a texture stage references an invalid texture unit the stage just
 702      * passes through the result from the previous stage */
 703     if (is_invalid_op(This, stage, op, arg1, arg2, arg3)) {
 704         arg1 = D3DTA_CURRENT;
 705         op = D3DTOP_SELECTARG1;
 706     }
 707
 708     get_src_and_opr_nvrc(stage, arg1, is_alpha, &tex_op_args.input[0],
 709             &tex_op_args.mapping[0], &tex_op_args.component_usage[0], texture_idx);
 710     get_src_and_opr_nvrc(stage, arg2, is_alpha, &tex_op_args.input[1],
 711             &tex_op_args.mapping[1], &tex_op_args.component_usage[1], texture_idx);
 712     get_src_and_opr_nvrc(stage, arg3, is_alpha, &tex_op_args.input[2],
 713             &tex_op_args.mapping[2], &tex_op_args.component_usage[2], texture_idx);
 714
 715     ENTER_GL();
 716
 717     switch(op)
 718     {
 719         case D3DTOP_DISABLE:
 720             /* Only for alpha */
 721             if (!is_alpha) ERR("Shouldn't be called for D3DTSS_COLOROP (D3DTOP_DISABLE)\n");
 722             /* Input, prev_alpha*1 */
 723             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
 724                     GL_SPARE0_NV, GL_UNSIGNED_IDENTITY_NV, GL_ALPHA));
 725             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
 726                     GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_ALPHA));
 727
 728             /* Output */
 729             GL_EXTCALL(glCombinerOutputNV(target, portion, GL_SPARE0_NV, GL_DISCARD_NV,
 730                     GL_DISCARD_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
 731             break;
 732
 733         case D3DTOP_SELECTARG1:
 734         case D3DTOP_SELECTARG2:
 735             /* Input, arg*1 */
 736             if (op == D3DTOP_SELECTARG1) {
 737                 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
 738                         tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
 739             } else {
 740                 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
 741                         tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
 742             }
 743             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
 744                     GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
 745
 746             /* Output */
 747             GL_EXTCALL(glCombinerOutputNV(target, portion, GL_SPARE0_NV, GL_DISCARD_NV,
 748                     GL_DISCARD_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
 749             break;
 750
 751         case D3DTOP_MODULATE:
 752         case D3DTOP_MODULATE2X:
 753         case D3DTOP_MODULATE4X:
 754             /* Input, arg1*arg2 */
 755             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
 756                     tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
 757             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
 758                     tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
 759
 760             /* Output */
 761             if (op == D3DTOP_MODULATE) {
 762                 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_SPARE0_NV, GL_DISCARD_NV,
 763                         GL_DISCARD_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
 764             } else if (op == D3DTOP_MODULATE2X) {
 765                 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_SPARE0_NV, GL_DISCARD_NV,
 766                         GL_DISCARD_NV, GL_SCALE_BY_TWO_NV, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
 767             } else if (op == D3DTOP_MODULATE4X) {
 768                 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_SPARE0_NV, GL_DISCARD_NV,
 769                         GL_DISCARD_NV, GL_SCALE_BY_FOUR_NV, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
 770             }
 771             break;
 772
 773         case D3DTOP_ADD:
 774         case D3DTOP_ADDSIGNED:
 775         case D3DTOP_ADDSIGNED2X:
 776             /* Input, arg1*1+arg2*1 */
 777             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
 778                     tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
 779             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
 780                     GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
 781             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
 782                     tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
 783             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
 784                     GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
 785
 786             /* Output */
 787             if (op == D3DTOP_ADD) {
 788                 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
 789                         GL_SPARE0_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
 790             } else if (op == D3DTOP_ADDSIGNED) {
 791                 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
 792                         GL_SPARE0_NV, GL_NONE, GL_BIAS_BY_NEGATIVE_ONE_HALF_NV, GL_FALSE, GL_FALSE, GL_FALSE));
 793             } else if (op == D3DTOP_ADDSIGNED2X) {
 794                 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
 795                         GL_SPARE0_NV, GL_SCALE_BY_TWO_NV, GL_BIAS_BY_NEGATIVE_ONE_HALF_NV, GL_FALSE, GL_FALSE, GL_FALSE));
 796             }
 797             break;
 798
 799         case D3DTOP_SUBTRACT:
 800             /* Input, arg1*1+-arg2*1 */
 801             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
 802                     tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
 803             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
 804                     GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
 805             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
 806                     tex_op_args.input[1], GL_SIGNED_NEGATE_NV, tex_op_args.component_usage[1]));
 807             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
 808                     GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
 809
 810             /* Output */
 811             GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
 812                     GL_SPARE0_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
 813             break;
 814
 815         case D3DTOP_ADDSMOOTH:
 816             /* Input, arg1*1+(1-arg1)*arg2 */
 817             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
 818                     tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
 819             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
 820                     GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
 821             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
 822                     tex_op_args.input[0], invert_mapping(tex_op_args.mapping[0]), tex_op_args.component_usage[0]));
 823             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
 824                     tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
 825
 826             /* Output */
 827             GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
 828                     GL_SPARE0_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
 829             break;
 830
 831         case D3DTOP_BLENDDIFFUSEALPHA:
 832         case D3DTOP_BLENDTEXTUREALPHA:
 833         case D3DTOP_BLENDFACTORALPHA:
 834         case D3DTOP_BLENDTEXTUREALPHAPM:
 835         case D3DTOP_BLENDCURRENTALPHA:
 836         {
 837             GLenum alpha_src = GL_PRIMARY_COLOR_NV;
 838             if (op == D3DTOP_BLENDDIFFUSEALPHA) alpha_src = d3dta_to_combiner_input(D3DTA_DIFFUSE, stage, texture_idx);
 839             else if (op == D3DTOP_BLENDTEXTUREALPHA) alpha_src = d3dta_to_combiner_input(D3DTA_TEXTURE, stage, texture_idx);
 840             else if (op == D3DTOP_BLENDFACTORALPHA) alpha_src = d3dta_to_combiner_input(D3DTA_TFACTOR, stage, texture_idx);
 841             else if (op == D3DTOP_BLENDTEXTUREALPHAPM) alpha_src = d3dta_to_combiner_input(D3DTA_TEXTURE, stage, texture_idx);
 842             else if (op == D3DTOP_BLENDCURRENTALPHA) alpha_src = d3dta_to_combiner_input(D3DTA_CURRENT, stage, texture_idx);
 843             else FIXME("Unhandled D3DTOP %s, shouldn't happen\n", debug_d3dtop(op));
 844
 845             /* Input, arg1*alpha_src+arg2*(1-alpha_src) */
 846             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
 847                     tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
 848             if (op == D3DTOP_BLENDTEXTUREALPHAPM)
 849             {
 850                 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
 851                         GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
 852             } else {
 853                 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
 854                         alpha_src, GL_UNSIGNED_IDENTITY_NV, GL_ALPHA));
 855             }
 856             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
 857                     tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
 858             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
 859                     alpha_src, GL_UNSIGNED_INVERT_NV, GL_ALPHA));
 860
 861             /* Output */
 862             GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
 863                     GL_SPARE0_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
 864             break;
 865         }
 866
 867         case D3DTOP_MODULATEALPHA_ADDCOLOR:
 868             /* Input, arg1_alpha*arg2_rgb+arg1_rgb*1 */
 869             if (is_alpha) ERR("Only supported for D3DTSS_COLOROP (D3DTOP_MODULATEALPHA_ADDCOLOR)\n");
 870             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
 871                     tex_op_args.input[0], tex_op_args.mapping[0], GL_ALPHA));
 872             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
 873                     tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
 874             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
 875                     tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
 876             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
 877                     GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
 878
 879             /* Output */
 880             GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
 881                     GL_SPARE0_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
 882             break;
 883
 884         case D3DTOP_MODULATECOLOR_ADDALPHA:
 885             /* Input, arg1_rgb*arg2_rgb+arg1_alpha*1 */
 886             if (is_alpha) ERR("Only supported for D3DTSS_COLOROP (D3DTOP_MODULATECOLOR_ADDALPHA)\n");
 887             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
 888                     tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
 889             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
 890                     tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
 891             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
 892                     tex_op_args.input[0], tex_op_args.mapping[0], GL_ALPHA));
 893             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
 894                     GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
 895
 896             /* Output */
 897             GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
 898                     GL_SPARE0_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
 899             break;
 900
 901         case D3DTOP_MODULATEINVALPHA_ADDCOLOR:
 902             /* Input, (1-arg1_alpha)*arg2_rgb+arg1_rgb*1 */
 903             if (is_alpha) ERR("Only supported for D3DTSS_COLOROP (D3DTOP_MODULATEINVALPHA_ADDCOLOR)\n");
 904             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
 905                     tex_op_args.input[0], invert_mapping(tex_op_args.mapping[0]), GL_ALPHA));
 906             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
 907                     tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
 908             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
 909                     tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
 910             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
 911                     GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
 912
 913             /* Output */
 914             GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
 915                     GL_SPARE0_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
 916             break;
 917
 918         case D3DTOP_MODULATEINVCOLOR_ADDALPHA:
 919             /* Input, (1-arg1_rgb)*arg2_rgb+arg1_alpha*1 */
 920             if (is_alpha) ERR("Only supported for D3DTSS_COLOROP (D3DTOP_MODULATEINVCOLOR_ADDALPHA)\n");
 921             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
 922                     tex_op_args.input[0], invert_mapping(tex_op_args.mapping[0]), tex_op_args.component_usage[0]));
 923             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
 924                     tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
 925             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
 926                     tex_op_args.input[0], tex_op_args.mapping[0], GL_ALPHA));
 927             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
 928                     GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
 929
 930             /* Output */
 931             GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
 932                     GL_SPARE0_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
 933             break;
 934
 935         case D3DTOP_DOTPRODUCT3:
 936             /* Input, arg1 . arg2 */
 937             /* FIXME: DX7 uses a different calculation? */
 938             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
 939                     tex_op_args.input[0], GL_EXPAND_NORMAL_NV, tex_op_args.component_usage[0]));
 940             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
 941                     tex_op_args.input[1], GL_EXPAND_NORMAL_NV, tex_op_args.component_usage[1]));
 942
 943             /* Output */
 944             GL_EXTCALL(glCombinerOutputNV(target, portion, GL_SPARE0_NV, GL_DISCARD_NV,
 945                     GL_DISCARD_NV, GL_NONE, GL_NONE, GL_TRUE, GL_FALSE, GL_FALSE));
 946             break;
 947
 948         case D3DTOP_MULTIPLYADD:
 949             /* Input, arg1*1+arg2*arg3 */
 950             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
 951                     tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
 952             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
 953                     GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
 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                     tex_op_args.input[2], tex_op_args.mapping[2], tex_op_args.component_usage[2]));
 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         case D3DTOP_LERP:
 965             /* Input, arg1*arg2+(1-arg1)*arg3 */
 966             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
 967                     tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
 968             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
 969                     tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
 970             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
 971                     tex_op_args.input[0], invert_mapping(tex_op_args.mapping[0]), tex_op_args.component_usage[0]));
 972             GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
 973                     tex_op_args.input[2], tex_op_args.mapping[2], tex_op_args.component_usage[2]));
 974
 975             /* Output */
 976             GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
 977                     GL_SPARE0_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
 978             break;
 979
 980         default:
 981             FIXME("Unhandled D3DTOP: stage %d, is_alpha %d, op %s (%#x), arg1 %#lx, arg2 %#lx, arg3 %#lx, texture_idx %d\n",
 982                     stage, is_alpha, debug_d3dtop(op), op, arg1, arg2, arg3, texture_idx);
 983     }
 984
 985     checkGLcall("set_tex_op_nvrc()\n");
 986
 987     LEAVE_GL();
 988 }
 989
 990 static void get_src_and_opr(DWORD arg, BOOL is_alpha, GLenum* source, GLenum* operand) {
 991     /* The D3DTA_ALPHAREPLICATE flag specifies the alpha component of the
 992      * input should be used for all input components. The D3DTA_COMPLEMENT
 993      * flag specifies the complement of the input should be used. */
 994     BOOL from_alpha = is_alpha || arg & D3DTA_ALPHAREPLICATE;
 995     BOOL complement = arg & D3DTA_COMPLEMENT;
 996
 997     /* Calculate the operand */
 998     if (complement) {
 999         if (from_alpha) *operand = GL_ONE_MINUS_SRC_ALPHA;
1000         else *operand = GL_ONE_MINUS_SRC_COLOR;
1001     } else {
1002         if (from_alpha) *operand = GL_SRC_ALPHA;
1003         else *operand = GL_SRC_COLOR;
1004     }
1005
1006     /* Calculate the source */
1007     switch (arg & D3DTA_SELECTMASK) {
1008         case D3DTA_CURRENT: *source = GL_PREVIOUS_EXT; break;
1009         case D3DTA_DIFFUSE: *source = GL_PRIMARY_COLOR_EXT; break;
1010         case D3DTA_TEXTURE: *source = GL_TEXTURE; break;
1011         case D3DTA_TFACTOR: *source = GL_CONSTANT_EXT; break;
1012         case D3DTA_SPECULAR:
1013             /*
1014              * According to the GL_ARB_texture_env_combine specs, SPECULAR is
1015              * 'Secondary color' and isn't supported until base GL supports it
1016              * There is no concept of temp registers as far as I can tell
1017              */
1018             FIXME("Unhandled texture arg D3DTA_SPECULAR\n");
1019             *source = GL_TEXTURE;
1020             break;
1021         default:
1022             FIXME("Unrecognized texture arg %#lx\n", arg);
1023             *source = GL_TEXTURE;
1024             break;
1025     }
1026 }
1027
1028 /* Set texture operations up - The following avoids lots of ifdefs in this routine!*/
1029 #if defined (GL_VERSION_1_3)
1030 # define useext(A) A
1031 # define combine_ext 1
1032 #elif defined (GL_EXT_texture_env_combine)
1033 # define useext(A) A##_EXT
1034 # define combine_ext 1
1035 #elif defined (GL_ARB_texture_env_combine)
1036 # define useext(A) A##_ARB
1037 # define combine_ext 1
1038 #else
1039 # undef combine_ext
1040 #endif
1041
1042 #if !defined(combine_ext)
1043 void set_tex_op(IWineD3DDevice *iface, BOOL isAlpha, int Stage, D3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3)
1044 {
1045         FIXME("Requires opengl combine extensions to work\n");
1046         return;
1047 }
1048 #else
1049 /* Setup the texture operations texture stage states */
1050 void set_tex_op(IWineD3DDevice *iface, BOOL isAlpha, int Stage, D3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3)
1051 {
1052 #define GLINFO_LOCATION ((IWineD3DImpl *)(This->wineD3D))->gl_info
1053         GLenum src1, src2, src3;
1054         GLenum opr1, opr2, opr3;
1055         GLenum comb_target;
1056         GLenum src0_target, src1_target, src2_target;
1057         GLenum opr0_target, opr1_target, opr2_target;
1058         GLenum scal_target;
1059         GLenum opr=0, invopr, src3_target, opr3_target;
1060         BOOL Handled = FALSE;
1061         IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1062
1063         TRACE("Alpha?(%d), Stage:%d Op(%s), a1(%ld), a2(%ld), a3(%ld)\n", isAlpha, Stage, debug_d3dtop(op), arg1, arg2, arg3);
1064
1065         ENTER_GL();
1066
1067         /* Note: Operations usually involve two ars, src0 and src1 and are operations of
1068            the form (a1 <operation> a2). However, some of the more complex operations
1069            take 3 parameters. Instead of the (sensible) addition of a3, Microsoft added
1070            in a third parameter called a0. Therefore these are operations of the form
1071            a0 <operation> a1 <operation> a2, ie the new parameter goes to the front.
1072
1073            However, below we treat the new (a0) parameter as src2/opr2, so in the actual
1074            functions below, expect their syntax to differ slightly to those listed in the
1075            manuals, ie replace arg1 with arg3, arg2 with arg1 and arg3 with arg2
1076            This affects D3DTOP_MULTIPLYADD and D3DTOP_LERP                               */
1077
1078         if (isAlpha) {
1079                 comb_target = useext(GL_COMBINE_ALPHA);
1080                 src0_target = useext(GL_SOURCE0_ALPHA);
1081                 src1_target = useext(GL_SOURCE1_ALPHA);
1082                 src2_target = useext(GL_SOURCE2_ALPHA);
1083                 opr0_target = useext(GL_OPERAND0_ALPHA);
1084                 opr1_target = useext(GL_OPERAND1_ALPHA);
1085                 opr2_target = useext(GL_OPERAND2_ALPHA);
1086                 scal_target = GL_ALPHA_SCALE;
1087         }
1088         else {
1089                 comb_target = useext(GL_COMBINE_RGB);
1090                 src0_target = useext(GL_SOURCE0_RGB);
1091                 src1_target = useext(GL_SOURCE1_RGB);
1092                 src2_target = useext(GL_SOURCE2_RGB);
1093                 opr0_target = useext(GL_OPERAND0_RGB);
1094                 opr1_target = useext(GL_OPERAND1_RGB);
1095                 opr2_target = useext(GL_OPERAND2_RGB);
1096                 scal_target = useext(GL_RGB_SCALE);
1097         }
1098
1099         /* If a texture stage references an invalid texture unit the stage just
1100          * passes through the result from the previous stage */
1101         if (is_invalid_op(This, Stage, op, arg1, arg2, arg3)) {
1102             arg1 = D3DTA_CURRENT;
1103             op = D3DTOP_SELECTARG1;
1104         }
1105
1106         /* From MSDN (WINED3DTSS_ALPHAARG1) :
1107            The default argument is D3DTA_TEXTURE. If no texture is set for this stage,
1108                    then the default argument is D3DTA_DIFFUSE.
1109                    FIXME? If texture added/removed, may need to reset back as well?    */
1110         if (isAlpha && This->stateBlock->textures[Stage] == NULL && arg1 == D3DTA_TEXTURE) {
1111             get_src_and_opr(D3DTA_DIFFUSE, isAlpha, &src1, &opr1);
1112         } else {
1113             get_src_and_opr(arg1, isAlpha, &src1, &opr1);
1114         }
1115         get_src_and_opr(arg2, isAlpha, &src2, &opr2);
1116         get_src_and_opr(arg3, isAlpha, &src3, &opr3);
1117
1118         TRACE("ct(%x), 1:(%x,%x), 2:(%x,%x), 3:(%x,%x)\n", comb_target, src1, opr1, src2, opr2, src3, opr3);
1119
1120         Handled = TRUE; /* Assume will be handled */
1121
1122         /* Other texture operations require special extensions: */
1123         if (GL_SUPPORT(NV_TEXTURE_ENV_COMBINE4)) {
1124           if (isAlpha) {
1125             opr = GL_SRC_ALPHA;
1126             invopr = GL_ONE_MINUS_SRC_ALPHA;
1127             src3_target = GL_SOURCE3_ALPHA_NV;
1128             opr3_target = GL_OPERAND3_ALPHA_NV;
1129           } else {
1130             opr = GL_SRC_COLOR;
1131             invopr = GL_ONE_MINUS_SRC_COLOR;
1132             src3_target = GL_SOURCE3_RGB_NV;
1133             opr3_target = GL_OPERAND3_RGB_NV;
1134           }
1135           switch (op) {
1136           case D3DTOP_DISABLE: /* Only for alpha */
1137             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1138             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
1139             glTexEnvi(GL_TEXTURE_ENV, src0_target, GL_PREVIOUS_EXT);
1140             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1141             glTexEnvi(GL_TEXTURE_ENV, opr0_target, GL_SRC_ALPHA);
1142             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1143             glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
1144             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1145             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1146             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1147             glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
1148             checkGLcall("GL_TEXTURE_ENV, src2_target, GL_ZERO");
1149             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
1150             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
1151             glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1152             checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1153             glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
1154             checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
1155             break;
1156           case D3DTOP_SELECTARG1:                                          /* = a1 * 1 + 0 * 0 */
1157           case D3DTOP_SELECTARG2:                                          /* = a2 * 1 + 0 * 0 */
1158             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1159             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1160             if (op == D3DTOP_SELECTARG1) {
1161               glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1162               checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1163               glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1164               checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1165             } else {
1166               glTexEnvi(GL_TEXTURE_ENV, src0_target, src2);
1167               checkGLcall("GL_TEXTURE_ENV, src0_target, src2");
1168               glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr2);
1169               checkGLcall("GL_TEXTURE_ENV, opr0_target, opr2");
1170             }
1171             glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
1172             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1173             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1174             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1175             glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
1176             checkGLcall("GL_TEXTURE_ENV, src2_target, GL_ZERO");
1177             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
1178             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
1179             glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1180             checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1181             glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
1182             checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
1183             break;
1184
1185           case D3DTOP_MODULATE:
1186             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1187             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
1188             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1189             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1190             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1191             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1192             glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1193             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1194             glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1195             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1196             glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
1197             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1198             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
1199             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1200             glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1201             checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1202             glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
1203             checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
1204             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1205             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1206             break;
1207           case D3DTOP_MODULATE2X:
1208             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1209             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
1210             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1211             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1212             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1213             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1214             glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1215             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1216             glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1217             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1218             glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
1219             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1220             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
1221             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1222             glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1223             checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1224             glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
1225             checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
1226             glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
1227             checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
1228             break;
1229           case D3DTOP_MODULATE4X:
1230             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1231             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
1232             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1233             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1234             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1235             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1236             glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1237             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1238             glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1239             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1240             glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
1241             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1242             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
1243             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1244             glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1245             checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1246             glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
1247             checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
1248             glTexEnvi(GL_TEXTURE_ENV, scal_target, 4);
1249             checkGLcall("GL_TEXTURE_ENV, scal_target, 4");
1250             break;
1251
1252           case D3DTOP_ADD:
1253             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1254             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1255             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1256             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1257             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1258             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1259             glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
1260             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1261             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1262             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1263             glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1264             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1265             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1266             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1267             glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1268             checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1269             glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
1270             checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
1271             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1272             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1273             break;
1274
1275           case D3DTOP_ADDSIGNED:
1276             glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED));
1277             checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED)");
1278             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1279             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1280             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1281             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1282             glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
1283             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1284             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1285             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1286             glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1287             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1288             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1289             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1290             glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1291             checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1292             glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
1293             checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
1294             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1295             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1296             break;
1297
1298           case D3DTOP_ADDSIGNED2X:
1299             glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED));
1300             checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED)");
1301             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1302             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1303             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1304             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1305             glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
1306             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1307             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1308             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1309             glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1310             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1311             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1312             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1313             glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1314             checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1315             glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
1316             checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
1317             glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
1318             checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
1319             break;
1320
1321           case D3DTOP_ADDSMOOTH:
1322             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1323             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1324             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1325             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1326             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1327             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1328             glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
1329             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1330             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1331             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1332             glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1333             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1334             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1335             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1336             glTexEnvi(GL_TEXTURE_ENV, src3_target, src1);
1337             checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
1338             switch (opr1) {
1339             case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_COLOR; break;
1340             case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_COLOR; break;
1341             case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1342             case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
1343             }
1344             glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
1345             checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
1346             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1347             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1348             break;
1349
1350           case D3DTOP_BLENDDIFFUSEALPHA:
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, useext(GL_PRIMARY_COLOR));
1358             checkGLcall("GL_TEXTURE_ENV, src1_target, useext(GL_PRIMARY_COLOR)");
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, useext(GL_PRIMARY_COLOR));
1366             checkGLcall("GL_TEXTURE_ENV, src3_target, useext(GL_PRIMARY_COLOR)");
1367             glTexEnvi(GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA);
1368             checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
1369             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1370             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1371             break;
1372           case D3DTOP_BLENDTEXTUREALPHA:
1373             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1374             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1375             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1376             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1377             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1378             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1379             glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_TEXTURE);
1380             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_TEXTURE");
1381             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1382             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1383             glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1384             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1385             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1386             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1387             glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_TEXTURE);
1388             checkGLcall("GL_TEXTURE_ENV, src3_target, GL_TEXTURE");
1389             glTexEnvi(GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA);
1390             checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
1391             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1392             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1393             break;
1394           case D3DTOP_BLENDFACTORALPHA:
1395             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1396             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1397             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1398             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1399             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1400             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1401             glTexEnvi(GL_TEXTURE_ENV, src1_target, useext(GL_CONSTANT));
1402             checkGLcall("GL_TEXTURE_ENV, src1_target, useext(GL_CONSTANT)");
1403             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1404             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1405             glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1406             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1407             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1408             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1409             glTexEnvi(GL_TEXTURE_ENV, src3_target, useext(GL_CONSTANT));
1410             checkGLcall("GL_TEXTURE_ENV, src3_target, useext(GL_CONSTANT)");
1411             glTexEnvi(GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA);
1412             checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
1413             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1414             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1415             break;
1416           case D3DTOP_BLENDTEXTUREALPHAPM:
1417             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1418             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1419             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1420             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1421             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1422             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1423             glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
1424             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1425             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1426             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1427             glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1428             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1429             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1430             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1431             glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_TEXTURE);
1432             checkGLcall("GL_TEXTURE_ENV, src3_target, GL_TEXTURE");
1433             glTexEnvi(GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA);
1434             checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
1435             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1436             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1437             break;
1438           case D3DTOP_MODULATEALPHA_ADDCOLOR:
1439             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1440             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");  /* Add = a0*a1 + a2*a3 */
1441             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);        /*   a0 = src1/opr1    */
1442             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1443             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1444             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");    /*   a1 = 1 (see docs) */
1445             glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
1446             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1447             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1448             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1449             glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);        /*   a2 = arg2         */
1450             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1451             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1452             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");     /*  a3 = src1 alpha   */
1453             glTexEnvi(GL_TEXTURE_ENV, src3_target, src1);
1454             checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
1455             switch (opr) {
1456             case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
1457             case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1458             }
1459             glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
1460             checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
1461             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1462             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1463             break;
1464           case D3DTOP_MODULATECOLOR_ADDALPHA:
1465             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1466             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1467             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1468             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1469             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1470             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1471             glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1472             checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1473             glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1474             checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1475             glTexEnvi(GL_TEXTURE_ENV, src2_target, src1);
1476             checkGLcall("GL_TEXTURE_ENV, src2_target, src1");
1477             switch (opr1) {
1478             case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
1479             case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1480             }
1481             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
1482             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
1483             glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1484             checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1485             glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
1486             checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
1487             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1488             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1489             break;
1490           case D3DTOP_MODULATEINVALPHA_ADDCOLOR:
1491             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1492             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1493             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1494             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1495             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1496             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1497             glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
1498             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1499             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1500             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1501             glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1502             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1503             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1504             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1505             glTexEnvi(GL_TEXTURE_ENV, src3_target, src1);
1506             checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
1507             switch (opr1) {
1508             case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1509             case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_ALPHA; break;
1510             case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1511             case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
1512             }
1513             glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
1514             checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
1515             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1516             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1517             break;
1518           case D3DTOP_MODULATEINVCOLOR_ADDALPHA:
1519             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1520             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1521             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1522             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1523             switch (opr1) {
1524             case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_COLOR; break;
1525             case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_COLOR; break;
1526             case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1527             case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
1528             }
1529             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
1530             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
1531             glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1532             checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1533             glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1534             checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1535             glTexEnvi(GL_TEXTURE_ENV, src2_target, src1);
1536             checkGLcall("GL_TEXTURE_ENV, src2_target, src1");
1537             switch (opr1) {
1538             case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
1539             case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1540             }
1541             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
1542             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
1543             glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1544             checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1545             glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
1546             checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
1547             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1548             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1549             break;
1550           case D3DTOP_MULTIPLYADD:
1551             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1552             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1553             glTexEnvi(GL_TEXTURE_ENV, src0_target, src3);
1554             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1555             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr3);
1556             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1557             glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
1558             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1559             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1560             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1561             glTexEnvi(GL_TEXTURE_ENV, src2_target, src1);
1562             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1563             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr1);
1564             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1565             glTexEnvi(GL_TEXTURE_ENV, src3_target, src2);
1566             checkGLcall("GL_TEXTURE_ENV, src3_target, src3");
1567             glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr2);
1568             checkGLcall("GL_TEXTURE_ENV, opr3_target, opr3");
1569             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1570             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1571             break;
1572
1573           case D3DTOP_BUMPENVMAP:
1574             {
1575               if (GL_SUPPORT(NV_TEXTURE_SHADER)) {
1576                 /*
1577                   texture unit 0: GL_TEXTURE_2D
1578                   texture unit 1: GL_DOT_PRODUCT_NV
1579                   texture unit 2: GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV
1580                   texture unit 3: GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV
1581                 */
1582                 float m[2][2];
1583
1584                 union {
1585                   float f;
1586                   DWORD d;
1587                 } tmpvalue;
1588
1589                 tmpvalue.d = This->stateBlock->textureState[Stage][WINED3DTSS_BUMPENVMAT00];
1590                 m[0][0] = tmpvalue.f;
1591                 tmpvalue.d = This->stateBlock->textureState[Stage][WINED3DTSS_BUMPENVMAT01];
1592                 m[0][1] = tmpvalue.f;
1593                 tmpvalue.d = This->stateBlock->textureState[Stage][WINED3DTSS_BUMPENVMAT10];
1594                 m[1][0] = tmpvalue.f;
1595                 tmpvalue.d = This->stateBlock->textureState[Stage][WINED3DTSS_BUMPENVMAT11];
1596                 m[1][1] = tmpvalue.f;
1597
1598                 /*FIXME("Stage %d matrix is (%.2f,%.2f),(%.2f,%.2f)\n", Stage, m[0][0], m[0][1], m[1][0], m[1][0]);*/
1599
1600                 if (FALSE == This->texture_shader_active) {
1601                   This->texture_shader_active = TRUE;
1602                   glEnable(GL_TEXTURE_SHADER_NV);
1603                 }
1604
1605                 /*
1606                 glEnable(GL_REGISTER_COMBINERS_NV);
1607                 glCombinerParameteriNV (GL_NUM_GENERAL_COMBINERS_NV, 1);
1608                 glCombinerInputNV (GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_A_NV, GL_TEXTURE0_ARB, GL_SIGNED_IDENTITY_NV, GL_RGB);
1609                 glCombinerInputNV (GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_B_NV, GL_NONE, GL_UNSIGNED_INVERT_NV, GL_RGB);
1610                 glCombinerInputNV (GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_C_NV, GL_TEXTURE2_ARB, GL_SIGNED_IDENTITY_NV, GL_RGB);
1611                 glCombinerInputNV (GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_D_NV, GL_NONE, GL_UNSIGNED_INVERT_NV, GL_RGB);
1612                 glCombinerOutputNV (GL_COMBINER0_NV, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV, GL_PRIMARY_COLOR_NV, 0, 0, 0, 0, 0);
1613                 glCombinerInputNV (GL_COMBINER0_NV, GL_ALPHA, GL_VARIABLE_A_NV, GL_TEXTURE0_ARB, GL_SIGNED_IDENTITY_NV, GL_ALPHA);
1614                 glCombinerInputNV (GL_COMBINER0_NV, GL_ALPHA, GL_VARIABLE_B_NV, GL_NONE, GL_UNSIGNED_INVERT_NV, GL_ALPHA);
1615                 glCombinerInputNV (GL_COMBINER0_NV, GL_ALPHA, GL_VARIABLE_C_NV, GL_TEXTURE2_ARB, GL_SIGNED_IDENTITY_NV, GL_ALPHA);
1616                 glCombinerInputNV (GL_COMBINER0_NV, GL_ALPHA, GL_VARIABLE_D_NV, GL_NONE, GL_UNSIGNED_INVERT_NV, GL_ALPHA);
1617                 glCombinerOutputNV (GL_COMBINER0_NV, GL_ALPHA, GL_DISCARD_NV, GL_DISCARD_NV, GL_PRIMARY_COLOR_NV, 0, 0, 0, 0, 0);
1618                 glDisable (GL_PER_STAGE_CONSTANTS_NV);
1619                 glCombinerParameteriNV (GL_COLOR_SUM_CLAMP_NV, 0);
1620                 glFinalCombinerInputNV (GL_VARIABLE_A_NV, 0, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
1621                 glFinalCombinerInputNV (GL_VARIABLE_B_NV, 0, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
1622                 glFinalCombinerInputNV (GL_VARIABLE_C_NV, 0, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
1623                 glFinalCombinerInputNV (GL_VARIABLE_D_NV, GL_PRIMARY_COLOR_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
1624                 glFinalCombinerInputNV (GL_VARIABLE_E_NV, 0, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
1625                 glFinalCombinerInputNV (GL_VARIABLE_F_NV, 0, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
1626                 glFinalCombinerInputNV (GL_VARIABLE_G_NV, GL_PRIMARY_COLOR_NV, GL_UNSIGNED_IDENTITY_NV, GL_ALPHA);
1627                 */
1628                 /*
1629                 int i;
1630                 for (i = 0; i < Stage; i++) {
1631                   if (GL_SUPPORT(ARB_MULTITEXTURE)) {
1632                     GL_ACTIVETEXTURE(i);
1633                     glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_2D);
1634                     checkGLcall("Activate texture..");
1635                   } else if (i>0) {
1636                     FIXME("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1637                   }
1638                 }
1639                 */
1640                 /*
1641                   GL_ACTIVETEXTURE(Stage - 1);
1642                   glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_2D);
1643                 */
1644                 /*
1645                 GL_ACTIVETEXTURE(Stage);
1646                 checkGLcall("Activate texture.. to update const color");
1647                 glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_OFFSET_TEXTURE_2D_NV);
1648                 checkGLcall("glTexEnv");
1649                 glTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, GL_TEXTURE0_ARB + Stage - 1);
1650                 checkGLcall("glTexEnv");
1651                 glTexEnvfv(GL_TEXTURE_SHADER_NV, GL_OFFSET_TEXTURE_MATRIX_NV, (float*)&m[0]);
1652                 checkGLcall("glTexEnv");
1653                 */
1654                 LEAVE_GL();
1655                 return;
1656               }
1657             }
1658
1659           case D3DTOP_BUMPENVMAPLUMINANCE:
1660
1661           default:
1662             Handled = FALSE;
1663           }
1664           if (Handled) {
1665             glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE4_NV);
1666             checkGLcall("GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE4_NV");
1667
1668             LEAVE_GL();
1669             return;
1670           }
1671         } /* GL_NV_texture_env_combine4 */
1672
1673         Handled = TRUE; /* Again, assume handled */
1674         switch (op) {
1675         case D3DTOP_DISABLE: /* Only for alpha */
1676                 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_REPLACE);
1677                 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
1678                 glTexEnvi(GL_TEXTURE_ENV, src0_target, GL_PREVIOUS_EXT);
1679                 checkGLcall("GL_TEXTURE_ENV, src0_target, GL_PREVIOUS_EXT");
1680                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, GL_SRC_ALPHA);
1681                 checkGLcall("GL_TEXTURE_ENV, opr0_target, GL_SRC_ALPHA");
1682                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1683                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1684                 break;
1685         case D3DTOP_SELECTARG1:
1686                 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_REPLACE);
1687                 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
1688                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1689                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1690                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1691                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1692                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1693                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1694                 break;
1695         case D3DTOP_SELECTARG2:
1696                 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_REPLACE);
1697                 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
1698                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src2);
1699                 checkGLcall("GL_TEXTURE_ENV, src0_target, src2");
1700                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr2);
1701                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr2");
1702                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1703                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1704                 break;
1705         case D3DTOP_MODULATE:
1706                 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE);
1707                 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
1708                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1709                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1710                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1711                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1712                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1713                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1714                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1715                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1716                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1717                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1718                 break;
1719         case D3DTOP_MODULATE2X:
1720                 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE);
1721                 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
1722                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1723                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1724                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1725                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1726                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1727                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1728                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1729                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1730                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
1731                 checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
1732                 break;
1733         case D3DTOP_MODULATE4X:
1734                 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE);
1735                 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
1736                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1737                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1738                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1739                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1740                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1741                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1742                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1743                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1744                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 4);
1745                 checkGLcall("GL_TEXTURE_ENV, scal_target, 4");
1746                 break;
1747         case D3DTOP_ADD:
1748                 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1749                 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1750                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1751                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1752                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1753                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1754                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1755                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1756                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1757                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1758                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1759                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1760                 break;
1761         case D3DTOP_ADDSIGNED:
1762                 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED));
1763                 checkGLcall("GL_TEXTURE_ENV, comb_target, useext((GL_ADD_SIGNED)");
1764                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1765                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1766                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1767                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1768                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1769                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1770                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1771                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1772                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1773                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1774                 break;
1775         case D3DTOP_ADDSIGNED2X:
1776                 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED));
1777                 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED)");
1778                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1779                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1780                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1781                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1782                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1783                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1784                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1785                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1786                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
1787                 checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
1788                 break;
1789         case D3DTOP_SUBTRACT:
1790           if (GL_SUPPORT(ARB_TEXTURE_ENV_COMBINE)) {
1791                 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_SUBTRACT);
1792                 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_SUBTRACT)");
1793                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1794                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1795                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1796                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1797                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1798                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1799                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1800                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1801                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1802                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1803           } else {
1804                 FIXME("This version of opengl does not support GL_SUBTRACT\n");
1805           }
1806           break;
1807
1808         case D3DTOP_BLENDDIFFUSEALPHA:
1809                 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
1810                 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
1811                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1812                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1813                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1814                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1815                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1816                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1817                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1818                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1819                 glTexEnvi(GL_TEXTURE_ENV, src2_target, useext(GL_PRIMARY_COLOR));
1820                 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_PRIMARY_COLOR");
1821                 glTexEnvi(GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA);
1822                 checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
1823                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1824                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1825                 break;
1826         case D3DTOP_BLENDTEXTUREALPHA:
1827                 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
1828                 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
1829                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1830                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1831                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1832                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1833                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1834                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1835                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1836                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1837                 glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_TEXTURE);
1838                 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_TEXTURE");
1839                 glTexEnvi(GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA);
1840                 checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
1841                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1842                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1843                 break;
1844         case D3DTOP_BLENDFACTORALPHA:
1845                 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
1846                 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
1847                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1848                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1849                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1850                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1851                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1852                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1853                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1854                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1855                 glTexEnvi(GL_TEXTURE_ENV, src2_target, useext(GL_CONSTANT));
1856                 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_CONSTANT");
1857                 glTexEnvi(GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA);
1858                 checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
1859                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1860                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1861                 break;
1862         case D3DTOP_BLENDCURRENTALPHA:
1863                 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
1864                 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
1865                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1866                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1867                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1868                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1869                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1870                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1871                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1872                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1873                 glTexEnvi(GL_TEXTURE_ENV, src2_target, useext(GL_PREVIOUS));
1874                 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_PREVIOUS");
1875                 glTexEnvi(GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA);
1876                 checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
1877                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1878                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1879                 break;
1880         case D3DTOP_DOTPRODUCT3:
1881                 if (GL_SUPPORT(ARB_TEXTURE_ENV_DOT3)) {
1882                   glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_ARB);
1883                   checkGLcall("GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_ARB");
1884                 } else if (GL_SUPPORT(EXT_TEXTURE_ENV_DOT3)) {
1885                   glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_EXT);
1886                   checkGLcall("GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_EXT");
1887                 } else {
1888                   FIXME("This version of opengl does not support GL_DOT3\n");
1889                 }
1890                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1891                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1892                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1893                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1894                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1895                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1896                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1897                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1898                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1899                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1900                 break;
1901         case D3DTOP_LERP:
1902                 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
1903                 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
1904                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1905                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1906                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1907                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1908                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1909                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1910                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1911                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1912                 glTexEnvi(GL_TEXTURE_ENV, src2_target, src3);
1913                 checkGLcall("GL_TEXTURE_ENV, src2_target, src3");
1914                 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr3);
1915                 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr3");
1916                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1917                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1918                 break;
1919         case D3DTOP_ADDSMOOTH:
1920                 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
1921                   glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
1922                   checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
1923                   glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1924                   checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1925                   switch (opr1) {
1926                   case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_COLOR; break;
1927                   case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_COLOR; break;
1928                   case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1929                   case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
1930                   }
1931                   glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
1932                   checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
1933                   glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
1934                   checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
1935                   glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
1936                   checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
1937                   glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1938                   checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1939                   glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1940                   checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1941                   glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1942                   checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1943                 } else
1944                   Handled = FALSE;
1945                 break;
1946         case D3DTOP_BLENDTEXTUREALPHAPM:
1947                 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
1948                   glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
1949                   checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
1950                   glTexEnvi(GL_TEXTURE_ENV, src0_target, GL_TEXTURE);
1951                   checkGLcall("GL_TEXTURE_ENV, src0_target, GL_TEXTURE");
1952                   glTexEnvi(GL_TEXTURE_ENV, opr0_target, GL_ONE_MINUS_SRC_ALPHA);
1953                   checkGLcall("GL_TEXTURE_ENV, opr0_target, GL_ONE_MINUS_SRC_APHA");
1954                   glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
1955                   checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
1956                   glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
1957                   checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
1958                   glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1959                   checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1960                   glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1961                   checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1962                   glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1963                   checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1964                 } else
1965                   Handled = FALSE;
1966                 break;
1967         case D3DTOP_MODULATEALPHA_ADDCOLOR:
1968                 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
1969                   glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
1970                   checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
1971                   glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1972                   checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1973                   switch (opr1) {
1974                   case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
1975                   case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1976                   case GL_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
1977                   case GL_ONE_MINUS_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1978                   }
1979                   glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
1980                   checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
1981                   glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
1982                   checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
1983                   glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
1984                   checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
1985                   glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1986                   checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1987                   glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1988                   checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1989                   glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1990                   checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1991                 } else
1992                   Handled = FALSE;
1993                 break;
1994         case D3DTOP_MODULATECOLOR_ADDALPHA:
1995                 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
1996                   glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
1997                   checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
1998                   glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1999                   checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2000                   glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
2001                   checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2002                   glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
2003                   checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2004                   switch (opr1) {
2005                   case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
2006                   case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2007                   case GL_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
2008                   case GL_ONE_MINUS_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2009                   }
2010                   glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr);
2011                   checkGLcall("GL_TEXTURE_ENV, opr1_target, opr");
2012                   glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
2013                   checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2014                   glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
2015                   checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2016                   glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2017                   checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2018                 } else
2019                   Handled = FALSE;
2020                 break;
2021         case D3DTOP_MODULATEINVALPHA_ADDCOLOR:
2022                 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
2023                   glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
2024                   checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2025                   glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2026                   checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2027                   switch (opr1) {
2028                   case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2029                   case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_ALPHA; break;
2030                   case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2031                   case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
2032                   }
2033                   glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
2034                   checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
2035                   glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
2036                   checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2037                   glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
2038                   checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
2039                   glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
2040                   checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2041                   glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
2042                   checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2043                   glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2044                   checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2045                 } else
2046                   Handled = FALSE;
2047                 break;
2048         case D3DTOP_MODULATEINVCOLOR_ADDALPHA:
2049                 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
2050                   glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
2051                   checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2052                   glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2053                   checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2054                   switch (opr1) {
2055                   case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_COLOR; break;
2056                   case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_COLOR; break;
2057                   case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2058                   case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
2059                   }
2060                   glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
2061                   checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
2062                   glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
2063                   checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2064                   switch (opr1) {
2065                   case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
2066                   case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2067                   case GL_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
2068                   case GL_ONE_MINUS_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2069                   }
2070                   glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr);
2071                   checkGLcall("GL_TEXTURE_ENV, opr1_target, opr");
2072                   glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
2073                   checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2074                   glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
2075                   checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2076                   glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2077                   checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2078                 } else
2079                   Handled = FALSE;
2080                 break;
2081         case D3DTOP_MULTIPLYADD:
2082                 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
2083                   glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
2084                   checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2085                   glTexEnvi(GL_TEXTURE_ENV, src0_target, src3);
2086                   checkGLcall("GL_TEXTURE_ENV, src0_target, src3");
2087                   glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr3);
2088                   checkGLcall("GL_TEXTURE_ENV, opr0_target, opr3");
2089                   glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
2090                   checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2091                   glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
2092                   checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
2093                   glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
2094                   checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2095                   glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
2096                   checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2097                   glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2098                   checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2099                 } else
2100                   Handled = FALSE;
2101                 break;
2102         default:
2103                 Handled = FALSE;
2104         }
2105
2106         if (Handled) {
2107           BOOL  combineOK = TRUE;
2108           if (GL_SUPPORT(NV_TEXTURE_ENV_COMBINE4)) {
2109             DWORD op2;
2110
2111             if (isAlpha) {
2112               op2 = This->stateBlock->textureState[Stage][WINED3DTSS_COLOROP];
2113             } else {
2114               op2 = This->stateBlock->textureState[Stage][WINED3DTSS_ALPHAOP];
2115             }
2116
2117             /* Note: If COMBINE4 in effect can't go back to combine! */
2118             switch (op2) {
2119             case D3DTOP_ADDSMOOTH:
2120             case D3DTOP_BLENDTEXTUREALPHAPM:
2121             case D3DTOP_MODULATEALPHA_ADDCOLOR:
2122             case D3DTOP_MODULATECOLOR_ADDALPHA:
2123             case D3DTOP_MODULATEINVALPHA_ADDCOLOR:
2124             case D3DTOP_MODULATEINVCOLOR_ADDALPHA:
2125             case D3DTOP_MULTIPLYADD:
2126               /* Ignore those implemented in both cases */
2127               switch (op) {
2128               case D3DTOP_SELECTARG1:
2129               case D3DTOP_SELECTARG2:
2130                 combineOK = FALSE;
2131                 Handled   = FALSE;
2132                 break;
2133               default:
2134                 FIXME("Can't use COMBINE4 and COMBINE together, thisop=%s, otherop=%s, isAlpha(%d)\n", debug_d3dtop(op), debug_d3dtop(op2), isAlpha);
2135                 LEAVE_GL();
2136                 return;
2137               }
2138             }
2139           }
2140
2141           if (combineOK) {
2142             glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, useext(GL_COMBINE));
2143             checkGLcall("GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, useext(GL_COMBINE)");
2144
2145             LEAVE_GL();
2146             return;
2147           }
2148         }
2149
2150         LEAVE_GL();
2151
2152         /* After all the extensions, if still unhandled, report fixme */
2153         FIXME("Unhandled texture operation %s\n", debug_d3dtop(op));
2154         #undef GLINFO_LOCATION
2155 }
2156 #endif
2157
2158 /* Setup this textures matrix according to the texture flags*/
2159 void set_texture_matrix(const float *smat, DWORD flags, BOOL calculatedCoords)
2160 {
2161     float mat[16];
2162
2163     glMatrixMode(GL_TEXTURE);
2164     checkGLcall("glMatrixMode(GL_TEXTURE)");
2165
2166     if (flags == D3DTTFF_DISABLE) {
2167         glLoadIdentity();
2168         checkGLcall("glLoadIdentity()");
2169         return;
2170     }
2171
2172     if (flags == (D3DTTFF_COUNT1|D3DTTFF_PROJECTED)) {
2173         ERR("Invalid texture transform flags: D3DTTFF_COUNT1|D3DTTFF_PROJECTED\n");
2174         return;
2175     }
2176
2177     memcpy(mat, smat, 16 * sizeof(float));
2178
2179     switch (flags & ~D3DTTFF_PROJECTED) {
2180     case D3DTTFF_COUNT1: mat[1] = mat[5] = mat[13] = 0;
2181     case D3DTTFF_COUNT2: mat[2] = mat[6] = mat[10] = mat[14] = 0;
2182     default: mat[3] = mat[7] = mat[11] = 0, mat[15] = 1;
2183     }
2184
2185     if (flags & D3DTTFF_PROJECTED) {
2186         switch (flags & ~D3DTTFF_PROJECTED) {
2187         case D3DTTFF_COUNT2:
2188             mat[3] = mat[1], mat[7] = mat[5], mat[11] = mat[9], mat[15] = mat[13];
2189             mat[1] = mat[5] = mat[9] = mat[13] = 0;
2190             break;
2191         case D3DTTFF_COUNT3:
2192             mat[3] = mat[2], mat[7] = mat[6], mat[11] = mat[10], mat[15] = mat[14];
2193             mat[2] = mat[6] = mat[10] = mat[14] = 0;
2194             break;
2195         }
2196     } else if(!calculatedCoords) { /* under directx the R/Z coord can be used for translation, under opengl we use the Q coord instead */
2197         mat[12] = mat[8];
2198         mat[13] = mat[9];
2199     }
2200
2201     glLoadMatrixf(mat);
2202     checkGLcall("glLoadMatrixf(mat)");
2203 }
2204
2205 #define GLINFO_LOCATION ((IWineD3DImpl *)(This->wineD3D))->gl_info
2206
2207 /* Convertes a D3D format into a OpenGL configuration format */
2208 int D3DFmtMakeGlCfg(D3DFORMAT BackBufferFormat, D3DFORMAT StencilBufferFormat, int *attribs, int* nAttribs, BOOL alternate){
2209 #define PUSH1(att)        attribs[(*nAttribs)++] = (att);
2210 #define PUSH2(att,value)  attribs[(*nAttribs)++] = (att); attribs[(*nAttribs)++] = (value);
2211     /*We need to do some Card specific stuff in here at some point,
2212     D3D now supports floating point format buffers, and there are a number of different OpelGl ways of managing these e.g.
2213     GLX_ATI_pixel_format_float
2214     */
2215     switch (BackBufferFormat) {
2216         /* color buffer */
2217     case WINED3DFMT_P8:
2218         PUSH2(GLX_RENDER_TYPE,  GLX_COLOR_INDEX_BIT);
2219         PUSH2(GLX_BUFFER_SIZE,  8);
2220         PUSH2(GLX_DOUBLEBUFFER, TRUE);
2221         break;
2222
2223     case WINED3DFMT_R3G3B2:
2224         PUSH2(GLX_RENDER_TYPE,  GLX_RGBA_BIT);
2225         PUSH2(GLX_RED_SIZE,     3);
2226         PUSH2(GLX_GREEN_SIZE,   3);
2227         PUSH2(GLX_BLUE_SIZE,    2);
2228         break;
2229
2230     case WINED3DFMT_A1R5G5B5:
2231         PUSH2(GLX_ALPHA_SIZE,   1);
2232     case WINED3DFMT_X1R5G5B5:
2233         PUSH2(GLX_RED_SIZE,     5);
2234         PUSH2(GLX_GREEN_SIZE,   5);
2235         PUSH2(GLX_BLUE_SIZE,    5);
2236         break;
2237
2238     case WINED3DFMT_R5G6B5:
2239         PUSH2(GLX_RED_SIZE,     5);
2240         PUSH2(GLX_GREEN_SIZE,   6);
2241         PUSH2(GLX_BLUE_SIZE,    5);
2242         break;
2243
2244     case WINED3DFMT_A4R4G4B4:
2245         PUSH2(GLX_ALPHA_SIZE,   4);
2246     case WINED3DFMT_X4R4G4B4:
2247         PUSH2(GLX_RED_SIZE,     4);
2248         PUSH2(GLX_GREEN_SIZE,   4);
2249         PUSH2(GLX_BLUE_SIZE,    4);
2250         break;
2251
2252     case WINED3DFMT_A8R8G8B8:
2253         PUSH2(GLX_ALPHA_SIZE,   8);
2254     case WINED3DFMT_R8G8B8:
2255     case WINED3DFMT_X8R8G8B8:
2256         PUSH2(GLX_RED_SIZE,     8);
2257         PUSH2(GLX_GREEN_SIZE,   8);
2258         PUSH2(GLX_BLUE_SIZE,    8);
2259         break;
2260
2261     case WINED3DFMT_A2R10G10B10:
2262         PUSH2(GLX_ALPHA_SIZE,   2);
2263         PUSH2(GLX_RED_SIZE,    10);
2264         PUSH2(GLX_GREEN_SIZE,  10);
2265         PUSH2(GLX_BLUE_SIZE,   10);
2266         break;
2267
2268     case WINED3DFMT_A16B16G16R16:
2269         PUSH2(GLX_ALPHA_SIZE,  16);
2270         PUSH2(GLX_RED_SIZE,    16);
2271         PUSH2(GLX_GREEN_SIZE,  16);
2272         PUSH2(GLX_BLUE_SIZE,   16);
2273         break;
2274
2275     default:
2276         FIXME("Unsupported color format: %s\n", debug_d3dformat(BackBufferFormat));
2277         break;
2278     }
2279     if(!alternate){
2280         switch (StencilBufferFormat) {
2281     case 0:
2282         break;
2283
2284     case WINED3DFMT_D16_LOCKABLE:
2285     case WINED3DFMT_D16:
2286         PUSH2(GLX_DEPTH_SIZE,   16);
2287         break;
2288
2289     case WINED3DFMT_D15S1:
2290         PUSH2(GLX_DEPTH_SIZE,   15);
2291         PUSH2(GLX_STENCIL_SIZE, 1);
2292         /*Does openGl support a 1bit stencil?, I've seen it used elsewhere
2293         e.g. http://www.ks.uiuc.edu/Research/vmd/doxygen/OpenGLDisplayDevice_8C-source.html*/
2294         break;
2295
2296     case WINED3DFMT_D24X8:
2297         PUSH2(GLX_DEPTH_SIZE,   24);
2298         break;
2299
2300     case WINED3DFMT_D24X4S4:
2301         PUSH2(GLX_DEPTH_SIZE,   24);
2302         PUSH2(GLX_STENCIL_SIZE, 4);
2303         break;
2304
2305     case WINED3DFMT_D24S8:
2306         PUSH2(GLX_DEPTH_SIZE,   24);
2307         PUSH2(GLX_STENCIL_SIZE, 8);
2308         break;
2309
2310     case WINED3DFMT_D24FS8:
2311         PUSH2(GLX_DEPTH_SIZE,   24);
2312         PUSH2(GLX_STENCIL_SIZE, 8);
2313         break;
2314
2315     case WINED3DFMT_D32:
2316         PUSH2(GLX_DEPTH_SIZE,   32);
2317         break;
2318
2319     default:
2320         FIXME("Unsupported stencil format: %s\n", debug_d3dformat(StencilBufferFormat));
2321         break;
2322     }
2323
2324     } else { /* it the device doesn't support the 'exact' format, try to find something close */
2325         switch (StencilBufferFormat) {
2326         case 0:
2327             break;
2328
2329         case WINED3DFMT_D16_LOCKABLE:
2330         case WINED3DFMT_D16:
2331             PUSH2(GLX_DEPTH_SIZE,   1);
2332             break;
2333
2334         case WINED3DFMT_D15S1:
2335             PUSH2(GLX_DEPTH_SIZE,   1);
2336             PUSH2(GLX_STENCIL_SIZE, 1);
2337             /*Does openGl support a 1bit stencil?, I've seen it used elsewhere
2338             e.g. http://www.ks.uiuc.edu/Research/vmd/doxygen/OpenGLDisplayDevice_8C-source.html*/
2339             break;
2340
2341         case WINED3DFMT_D24X8:
2342             PUSH2(GLX_DEPTH_SIZE,   1);
2343             break;
2344
2345         case WINED3DFMT_D24X4S4:
2346             PUSH2(GLX_DEPTH_SIZE,   1);
2347             PUSH2(GLX_STENCIL_SIZE, 1);
2348             break;
2349
2350         case WINED3DFMT_D24S8:
2351             PUSH2(GLX_DEPTH_SIZE,   1);
2352             PUSH2(GLX_STENCIL_SIZE, 1);
2353             break;
2354
2355         case WINED3DFMT_D24FS8:
2356             PUSH2(GLX_DEPTH_SIZE,   1);
2357             PUSH2(GLX_STENCIL_SIZE, 1);
2358             break;
2359
2360         case WINED3DFMT_D32:
2361             PUSH2(GLX_DEPTH_SIZE,   1);
2362             break;
2363
2364         default:
2365             FIXME("Unsupported stencil format: %s\n", debug_d3dformat(StencilBufferFormat));
2366             break;
2367         }
2368     }
2369
2370     return *nAttribs;
2371 }
2372
2373 #undef GLINFO_LOCATION
2374
2375 /* DirectDraw stuff */
2376 WINED3DFORMAT pixelformat_for_depth(DWORD depth) {
2377     switch(depth) {
2378         case 8:  return D3DFMT_P8; break;
2379         case 15: return WINED3DFMT_X1R5G5B5; break;
2380         case 16: return WINED3DFMT_R5G6B5; break;
2381         case 24: return WINED3DFMT_R8G8B8; break;
2382         case 32: return WINED3DFMT_X8R8G8B8; break;
2383         default: return WINED3DFMT_UNKNOWN;
2384     }
2385 }
2386
2387 void multiply_matrix(D3DMATRIX *dest, D3DMATRIX *src1, D3DMATRIX *src2) {
2388     D3DMATRIX temp;
2389
2390     /* Now do the multiplication 'by hand'.
2391        I know that all this could be optimised, but this will be done later :-) */
2392     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);
2393     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);
2394     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);
2395     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);
2396
2397     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);
2398     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);
2399     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);
2400     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);
2401
2402     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);
2403     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);
2404     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);
2405     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);
2406
2407     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);
2408     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);
2409     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);
2410     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);
2411
2412     /* And copy the new matrix in the good storage.. */
2413     memcpy(dest, &temp, 16 * sizeof(float));
2414 }
2415
2416 DWORD get_flexible_vertex_size(DWORD d3dvtVertexType) {
2417     DWORD size = 0;
2418     int i;
2419     int numTextures = (d3dvtVertexType & D3DFVF_TEXCOUNT_MASK) >> D3DFVF_TEXCOUNT_SHIFT;
2420
2421     if (d3dvtVertexType & D3DFVF_NORMAL) size += 3 * sizeof(float);
2422     if (d3dvtVertexType & D3DFVF_DIFFUSE) size += sizeof(DWORD);
2423     if (d3dvtVertexType & D3DFVF_SPECULAR) size += sizeof(DWORD);
2424     if (d3dvtVertexType & D3DFVF_PSIZE) size += sizeof(DWORD);
2425     switch (d3dvtVertexType & D3DFVF_POSITION_MASK) {
2426         case D3DFVF_XYZ: size += 3 * sizeof(float); break;
2427         case D3DFVF_XYZRHW: size += 4 * sizeof(float); break;
2428         default: TRACE(" matrix weighting not handled yet...\n");
2429     }
2430     for (i = 0; i < numTextures; i++) {
2431         size += GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType, i) * sizeof(float);
2432     }
2433
2434     return size;
2435 }
2436
2437 /***********************************************************************
2438  * CalculateTexRect
2439  *
2440  * Calculates the dimensions of the opengl texture used for blits.
2441  * Handled oversized opengl textures and updates the source rectangle
2442  * accordingly
2443  *
2444  * Params:
2445  *  This: Surface to operate on
2446  *  Rect: Requested rectangle
2447  *
2448  * Returns:
2449  *  TRUE if the texture part can be loaded,
2450  *  FALSE otherwise
2451  *
2452  *********************************************************************/
2453 #define GLINFO_LOCATION ((IWineD3DImpl *)(This->resource.wineD3DDevice->wineD3D))->gl_info
2454
2455 BOOL CalculateTexRect(IWineD3DSurfaceImpl *This, RECT *Rect, float glTexCoord[4]) {
2456     int x1 = Rect->left, x2 = Rect->right;
2457     int y1 = Rect->top, y2 = Rect->bottom;
2458     GLint maxSize = GL_LIMITS(texture_size);
2459
2460     TRACE("(%p)->(%ld,%ld)-(%ld,%ld)\n", This,
2461           Rect->left, Rect->top, Rect->right, Rect->bottom);
2462
2463     /* The sizes might be reversed */
2464     if(Rect->left > Rect->right) {
2465         x1 = Rect->right;
2466         x2 = Rect->left;
2467     }
2468     if(Rect->top > Rect->bottom) {
2469         y1 = Rect->bottom;
2470         y2 = Rect->top;
2471     }
2472
2473     /* No oversized texture? This is easy */
2474     if(!(This->Flags & SFLAG_OVERSIZE)) {
2475         /* Which rect from the texture do I need? */
2476         glTexCoord[0] = (float) Rect->left / (float) This->pow2Width;
2477         glTexCoord[2] = (float) Rect->top / (float) This->pow2Height;
2478         glTexCoord[1] = (float) Rect->right / (float) This->pow2Width;
2479         glTexCoord[3] = (float) Rect->bottom / (float) This->pow2Height;
2480
2481         return TRUE;
2482     } else {
2483         /* Check if we can succeed at all */
2484         if( (x2 - x1) > maxSize ||
2485             (y2 - y1) > maxSize ) {
2486             TRACE("Requested rectangle is too large for gl\n");
2487             return FALSE;
2488         }
2489
2490         /* A part of the texture has to be picked. First, check if
2491          * some texture part is loaded already, if yes try to re-use it.
2492          * If the texture is dirty, or the part can't be used,
2493          * re-position the part to load
2494          */
2495         if(!(This->Flags & SFLAG_DIRTY)) {
2496             if(This->glRect.left <= x1 && This->glRect.right >= x2 &&
2497                This->glRect.top <= y1 && This->glRect.bottom >= x2 ) {
2498                 /* Ok, the rectangle is ok, re-use it */
2499                 TRACE("Using existing gl Texture\n");
2500             } else {
2501                 /* Rectangle is not ok, dirtify the texture to reload it */
2502                 TRACE("Dirtifying texture to force reload\n");
2503                 This->Flags |= SFLAG_DIRTY;
2504             }
2505         }
2506
2507         /* Now if we are dirty(no else if!) */
2508         if(This->Flags & SFLAG_DIRTY) {
2509             /* Set the new rectangle. Use the following strategy:
2510              * 1) Use as big textures as possible.
2511              * 2) Place the texture part in the way that the requested
2512              *    part is in the middle of the texture(well, almost)
2513              * 3) If the texture is moved over the edges of the
2514              *    surface, replace it nicely
2515              * 4) If the coord is not limiting the texture size,
2516              *    use the whole size
2517              */
2518             if((This->pow2Width) > maxSize) {
2519                 This->glRect.left = x1 - maxSize / 2;
2520                 if(This->glRect.left < 0) {
2521                     This->glRect.left = 0;
2522                 }
2523                 This->glRect.right = This->glRect.left + maxSize;
2524                 if(This->glRect.right > This->currentDesc.Width) {
2525                     This->glRect.right = This->currentDesc.Width;
2526                     This->glRect.left = This->glRect.right - maxSize;
2527                 }
2528             } else {
2529                 This->glRect.left = 0;
2530                 This->glRect.right = This->pow2Width;
2531             }
2532
2533             if(This->pow2Height > maxSize) {
2534                 This->glRect.top = x1 - GL_LIMITS(texture_size) / 2;
2535                 if(This->glRect.top < 0) This->glRect.top = 0;
2536                 This->glRect.bottom = This->glRect.left + maxSize;
2537                 if(This->glRect.bottom > This->currentDesc.Height) {
2538                     This->glRect.bottom = This->currentDesc.Height;
2539                     This->glRect.top = This->glRect.bottom - maxSize;
2540                 }
2541             } else {
2542                 This->glRect.top = 0;
2543                 This->glRect.bottom = This->pow2Height;
2544             }
2545             TRACE("(%p): Using rect (%ld,%ld)-(%ld,%ld)\n", This,
2546                    This->glRect.left, This->glRect.top, This->glRect.right, This->glRect.bottom);
2547         }
2548
2549         /* Re-calculate the rect to draw */
2550         Rect->left -= This->glRect.left;
2551         Rect->right -= This->glRect.left;
2552         Rect->top -= This->glRect.top;
2553         Rect->bottom -= This->glRect.top;
2554
2555         /* Get the gl coordinates. The gl rectangle is a power of 2, eigher the max size,
2556          * or the pow2Width / pow2Height of the surface
2557          */
2558         glTexCoord[0] = (float) Rect->left / (float) (This->glRect.right - This->glRect.left);
2559         glTexCoord[2] = (float) Rect->top / (float) (This->glRect.bottom - This->glRect.top);
2560         glTexCoord[1] = (float) Rect->right / (float) (This->glRect.right - This->glRect.left);
2561         glTexCoord[3] = (float) Rect->bottom / (float) (This->glRect.bottom - This->glRect.top);
2562     }
2563     return TRUE;
2564 }
2565 #undef GLINFO_LOCATION