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