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  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 #include "config.h"
  25 #include "wined3d_private.h"
  26
  27 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
  28
  29 /*****************************************************************************
  30  * Pixel format array
  31  */
  32 static const PixelFormatDesc formats[] = {
  33   /*{WINED3DFORMAT          ,alphamask  ,redmask    ,greenmask  ,bluemask   ,bpp    ,isFourcc   ,internal   ,format ,type   }*/
  34     {WINED3DFMT_UNKNOWN     ,0x0        ,0x0        ,0x0        ,0x0        ,1      ,FALSE      ,0                      ,0                  ,0                              },
  35     /* FourCC formats, kept here to have WINED3DFMT_R8G8B8(=20) at position 20 */
  36     {WINED3DFMT_UYVY        ,0x0        ,0x0        ,0x0        ,0x0        ,1/*?*/ ,TRUE       ,0                      ,0                  ,0                              },
  37     {WINED3DFMT_YUY2        ,0x0        ,0x0        ,0x0        ,0x0        ,1/*?*/ ,TRUE       ,0                      ,0                  ,0                              },
  38     {WINED3DFMT_DXT1        ,0x0        ,0x0        ,0x0        ,0x0        ,1      ,TRUE       ,GL_COMPRESSED_RGBA_S3TC_DXT1_EXT,GL_COMPRESSED_RGBA_S3TC_DXT1_EXT,0        },
  39     {WINED3DFMT_DXT2        ,0x0        ,0x0        ,0x0        ,0x0        ,1      ,TRUE       ,GL_COMPRESSED_RGBA_S3TC_DXT3_EXT,GL_COMPRESSED_RGBA_S3TC_DXT3_EXT,0        },
  40     {WINED3DFMT_DXT3        ,0x0        ,0x0        ,0x0        ,0x0        ,1      ,TRUE       ,GL_COMPRESSED_RGBA_S3TC_DXT3_EXT,GL_COMPRESSED_RGBA_S3TC_DXT3_EXT,0        },
  41     {WINED3DFMT_DXT4        ,0x0        ,0x0        ,0x0        ,0x0        ,1      ,TRUE       ,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,0        },
  42     {WINED3DFMT_DXT5        ,0x0        ,0x0        ,0x0        ,0x0        ,1      ,TRUE       ,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,0        },
  43     {WINED3DFMT_MULTI2_ARGB ,0x0        ,0x0        ,0x0        ,0x0        ,1/*?*/ ,TRUE       ,0                      ,0                  ,0                              },
  44     {WINED3DFMT_G8R8_G8B8   ,0x0        ,0x0        ,0x0        ,0x0        ,1/*?*/ ,TRUE       ,0                      ,0                  ,0                              },
  45     {WINED3DFMT_R8G8_B8G8   ,0x0        ,0x0        ,0x0        ,0x0        ,1/*?*/ ,TRUE       ,0                      ,0                  ,0                              },
  46     /* IEEE formats */
  47     {WINED3DFMT_R32F        ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,FALSE      ,0                      ,0                  ,0                              },
  48     {WINED3DFMT_G32R32F     ,0x0        ,0x0        ,0x0        ,0x0        ,8      ,FALSE      ,0                      ,0                  ,0                              },
  49     {WINED3DFMT_A32B32G32R32F,0x0       ,0x0        ,0x0        ,0x0        ,16     ,FALSE      ,0                      ,0                  ,0                              },
  50     /* Hmm? */
  51     {WINED3DFMT_CxV8U8      ,0x0        ,0x0        ,0x0        ,0x0        ,2      ,FALSE      ,0                      ,0                  ,0                              },
  52     /* Float */
  53     {WINED3DFMT_R16F        ,0x0        ,0x0        ,0x0        ,0x0        ,2      ,FALSE      ,0                      ,0                  ,0                              },
  54     {WINED3DFMT_G16R16F     ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,FALSE      ,0                      ,0                  ,0                              },
  55     {WINED3DFMT_A16B16G16R16F,0x0       ,0x0        ,0x0        ,0x0        ,8      ,FALSE      ,0                      ,0                  ,0                              },
  56     /* Palettized formats */
  57     {WINED3DFMT_A8P8        ,0x0000ff00 ,0x0        ,0x0        ,0x0        ,2      ,FALSE      ,0                      ,0                  ,0                              },
  58     {WINED3DFMT_P8          ,0x0        ,0x0        ,0x0        ,0x0        ,1      ,FALSE      ,GL_COLOR_INDEX8_EXT    ,GL_COLOR_INDEX     ,GL_UNSIGNED_BYTE               },
  59     /* Standard ARGB formats. Keep WINED3DFMT_R8G8B8(=20) at position 20 */
  60     {WINED3DFMT_R8G8B8      ,0x0        ,0x00ff0000 ,0x0000ff00 ,0x000000ff ,3      ,FALSE      ,GL_RGB8                ,GL_RGB             ,GL_UNSIGNED_BYTE               },
  61     {WINED3DFMT_A8R8G8B8    ,0xff000000 ,0x00ff0000 ,0x0000ff00 ,0x000000ff ,4      ,FALSE      ,GL_RGBA8               ,GL_BGRA            ,GL_UNSIGNED_INT_8_8_8_8_REV    },
  62     {WINED3DFMT_X8R8G8B8    ,0x0        ,0x00ff0000 ,0x0000ff00 ,0x000000ff ,4      ,FALSE      ,GL_RGB8                ,GL_BGRA            ,GL_UNSIGNED_INT_8_8_8_8_REV    },
  63     {WINED3DFMT_R5G6B5      ,0x0        ,0x0000F800 ,0x000007e0 ,0x0000001f ,2      ,FALSE      ,GL_RGB5                ,GL_RGB             ,GL_UNSIGNED_SHORT_5_6_5        },
  64     {WINED3DFMT_X1R5G5B5    ,0x0        ,0x00007c00 ,0x000003e0 ,0x0000001f ,2      ,FALSE      ,GL_RGB5_A1             ,GL_BGRA            ,GL_UNSIGNED_SHORT_1_5_5_5_REV  },
  65     {WINED3DFMT_A1R5G5B5    ,0x00008000 ,0x00007c00 ,0x000003e0 ,0x0000001f ,2      ,FALSE      ,GL_RGB5_A1             ,GL_BGRA            ,GL_UNSIGNED_SHORT_1_5_5_5_REV  },
  66     {WINED3DFMT_A4R4G4B4    ,0x0000f000 ,0x00000f00 ,0x000000f0 ,0x0000000f ,2      ,FALSE      ,GL_RGBA4               ,GL_BGRA            ,GL_UNSIGNED_SHORT_4_4_4_4_REV  },
  67     {WINED3DFMT_R3G3B2      ,0x0        ,0x000000e0 ,0x0000001c ,0x00000003 ,1      ,FALSE      ,GL_R3_G3_B2            ,GL_RGB             ,GL_UNSIGNED_BYTE_2_3_3_REV     },
  68     {WINED3DFMT_A8          ,0x000000ff ,0x0        ,0x0        ,0x0        ,1      ,FALSE      ,GL_ALPHA8              ,GL_ALPHA           ,GL_ALPHA                       },
  69     {WINED3DFMT_A8R3G3B2    ,0x0000ff00 ,0x000000e0 ,0x0000001c ,0x00000003 ,2      ,FALSE      ,0                      ,0                  ,0                              },
  70     {WINED3DFMT_X4R4G4B4    ,0x0        ,0x00000f00 ,0x000000f0 ,0x0000000f ,2      ,FALSE      ,GL_RGB4                ,GL_BGRA            ,GL_UNSIGNED_SHORT_4_4_4_4_REV  },
  71     {WINED3DFMT_A2B10G10R10 ,0xb0000000 ,0x000003ff ,0x000ffc00 ,0x3ff00000 ,4      ,FALSE      ,0                      ,0                  ,0                              },
  72     {WINED3DFMT_A8B8G8R8    ,0xff000000 ,0x000000ff ,0x0000ff00 ,0x00ff0000 ,4      ,FALSE      ,GL_RGBA8               ,GL_RGBA            ,GL_UNSIGNED_INT_8_8_8_8_REV    },
  73     {WINED3DFMT_X8B8G8R8    ,0x0        ,0x000000ff ,0x0000ff00 ,0x00ff0000 ,4      ,FALSE      ,GL_RGB8                ,GL_RGBA            ,GL_UNSIGNED_INT_8_8_8_8_REV    },
  74     {WINED3DFMT_G16R16      ,0x0        ,0x0000ffff ,0xffff0000 ,0x0        ,4      ,FALSE      ,0                      ,0                  ,0                              },
  75     {WINED3DFMT_A2R10G10B10 ,0xb0000000 ,0x3ff00000 ,0x000ffc00 ,0x000003ff ,4      ,FALSE      ,0                      ,0                  ,0                              },
  76     {WINED3DFMT_A16B16G16R16,0x0        ,0x0000ffff ,0xffff0000 ,0x0        ,8      ,FALSE      ,GL_RGBA16_EXT          ,GL_RGBA            ,GL_UNSIGNED_SHORT              },
  77     /* Luminance */
  78     {WINED3DFMT_L8          ,0x0        ,0x0        ,0x0        ,0x0        ,1      ,FALSE      ,GL_LUMINANCE8          ,GL_LUMINANCE       ,GL_UNSIGNED_BYTE               },
  79     {WINED3DFMT_A8L8        ,0x0000ff00 ,0x0        ,0x0        ,0x0        ,2      ,FALSE      ,GL_LUMINANCE8_ALPHA8   ,GL_LUMINANCE_ALPHA ,GL_UNSIGNED_BYTE               },
  80     {WINED3DFMT_A4L4        ,0x000000f0 ,0x0        ,0x0        ,0x0        ,1      ,FALSE      ,GL_LUMINANCE4_ALPHA4   ,GL_LUMINANCE_ALPHA ,GL_UNSIGNED_BYTE               },
  81     /* Bump mapping stuff */
  82     {WINED3DFMT_V8U8        ,0x0        ,0x0        ,0x0        ,0x0        ,2      ,FALSE      ,GL_COLOR_INDEX8_EXT    ,GL_COLOR_INDEX     ,GL_UNSIGNED_BYTE               },
  83     {WINED3DFMT_L6V5U5      ,0x0        ,0x0        ,0x0        ,0x0        ,2      ,FALSE      ,GL_COLOR_INDEX8_EXT    ,GL_COLOR_INDEX     ,GL_UNSIGNED_SHORT_5_5_5_1      },
  84     {WINED3DFMT_X8L8V8U8    ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,FALSE      ,GL_RGBA8               ,GL_BGRA            ,GL_UNSIGNED_BYTE               },
  85     {WINED3DFMT_Q8W8V8U8    ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,FALSE      ,GL_RGBA8               ,GL_RGBA            ,GL_UNSIGNED_INT_8_8_8_8_REV/*?*/},
  86     {WINED3DFMT_V16U16      ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,FALSE      ,GL_COLOR_INDEX         ,GL_COLOR_INDEX     ,GL_UNSIGNED_SHORT              },
  87     {WINED3DFMT_W11V11U10   ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,FALSE      ,0                      ,0                  ,0                              },
  88     {WINED3DFMT_A2W10V10U10 ,0xb0000000 ,0x0        ,0x0        ,0x0        ,4      ,FALSE      ,0                      ,0                  ,0                              },
  89     /* Depth stencil formats */
  90     {WINED3DFMT_D16_LOCKABLE,0x0        ,0x0        ,0x0        ,0x0        ,2      ,FALSE      ,GL_COLOR_INDEX         ,GL_COLOR_INDEX     ,GL_UNSIGNED_SHORT              },
  91     {WINED3DFMT_D32         ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,FALSE      ,GL_COLOR_INDEX         ,GL_COLOR_INDEX     ,GL_UNSIGNED_INT                },
  92     {WINED3DFMT_D15S1       ,0x0        ,0x0        ,0x0        ,0x0        ,2      ,FALSE      ,GL_COLOR_INDEX         ,GL_COLOR_INDEX     ,GL_UNSIGNED_SHORT              },
  93     {WINED3DFMT_D24S8       ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,FALSE      ,GL_COLOR_INDEX         ,GL_COLOR_INDEX     ,GL_UNSIGNED_INT                },
  94     {WINED3DFMT_D24X8       ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,FALSE      ,GL_COLOR_INDEX         ,GL_COLOR_INDEX     ,GL_UNSIGNED_INT                },
  95     {WINED3DFMT_D24X4S4     ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,FALSE      ,GL_COLOR_INDEX         ,GL_COLOR_INDEX     ,GL_UNSIGNED_INT                },
  96     {WINED3DFMT_D16         ,0x0        ,0x0        ,0x0        ,0x0        ,2      ,FALSE      ,GL_COLOR_INDEX         ,GL_COLOR_INDEX     ,GL_UNSIGNED_SHORT              },
  97     {WINED3DFMT_L16         ,0x0        ,0x0        ,0x0        ,0x0        ,2      ,FALSE      ,GL_LUMINANCE16_EXT     ,GL_LUMINANCE       ,GL_UNSIGNED_SHORT              },
  98     {WINED3DFMT_D32F_LOCKABLE,0x0       ,0x0        ,0x0        ,0x0        ,4      ,FALSE      ,0                      ,0                  ,0                              },
  99     {WINED3DFMT_D24FS8      ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,FALSE      ,0                      ,0                  ,0                              },
 100     /* Is this a vertex buffer? */
 101     {WINED3DFMT_VERTEXDATA  ,0x0        ,0x0        ,0x0        ,0x0        ,0      ,FALSE      ,0                      ,0                  ,0                              },
 102     {WINED3DFMT_INDEX16     ,0x0        ,0x0        ,0x0        ,0x0        ,2      ,FALSE      ,0                      ,0                  ,0                              },
 103     {WINED3DFMT_INDEX32     ,0x0        ,0x0        ,0x0        ,0x0        ,4      ,FALSE      ,0                      ,0                  ,0                              },
 104     {WINED3DFMT_Q16W16V16U16,0x0        ,0x0        ,0x0        ,0x0        ,8      ,FALSE      ,GL_COLOR_INDEX         ,GL_COLOR_INDEX     ,GL_UNSIGNED_SHORT              }
 105 };
 106
 107 const PixelFormatDesc *getFormatDescEntry(WINED3DFORMAT fmt)
 108 {
 109     /* First check if the format is at the position of its value.
 110      * This will catch the argb formats before the loop is entered
 111      */
 112     if(fmt < (sizeof(formats) / sizeof(formats[0])) && formats[fmt].format == fmt) {
 113         return &formats[fmt];
 114     } else {
 115         unsigned int i;
 116         for(i = 0; i < (sizeof(formats) / sizeof(formats[0])); i++) {
 117             if(formats[i].format == fmt) {
 118                 return &formats[i];
 119             }
 120         }
 121     }
 122     FIXME("Can't find format %s(%d) in the format lookup table\n", debug_d3dformat(fmt), fmt);
 123     if(fmt == WINED3DFMT_UNKNOWN) {
 124         ERR("Format table corrupt - Can't find WINED3DFMT_UNKNOWN\n");
 125         return NULL;
 126     }
 127     /* Get the caller a valid pointer */
 128     return getFormatDescEntry(WINED3DFMT_UNKNOWN);
 129 }
 130
 131 /*****************************************************************************
 132  * Trace formatting of useful values
 133  */
 134 const char* debug_d3dformat(WINED3DFORMAT fmt) {
 135   switch (fmt) {
 136 #define FMT_TO_STR(fmt) case fmt: return #fmt
 137     FMT_TO_STR(WINED3DFMT_UNKNOWN);
 138     FMT_TO_STR(WINED3DFMT_R8G8B8);
 139     FMT_TO_STR(WINED3DFMT_A8R8G8B8);
 140     FMT_TO_STR(WINED3DFMT_X8R8G8B8);
 141     FMT_TO_STR(WINED3DFMT_R5G6B5);
 142     FMT_TO_STR(WINED3DFMT_X1R5G5B5);
 143     FMT_TO_STR(WINED3DFMT_A1R5G5B5);
 144     FMT_TO_STR(WINED3DFMT_A4R4G4B4);
 145     FMT_TO_STR(WINED3DFMT_R3G3B2);
 146     FMT_TO_STR(WINED3DFMT_A8);
 147     FMT_TO_STR(WINED3DFMT_A8R3G3B2);
 148     FMT_TO_STR(WINED3DFMT_X4R4G4B4);
 149     FMT_TO_STR(WINED3DFMT_A2B10G10R10);
 150     FMT_TO_STR(WINED3DFMT_A8B8G8R8);
 151     FMT_TO_STR(WINED3DFMT_X8B8G8R8);
 152     FMT_TO_STR(WINED3DFMT_G16R16);
 153     FMT_TO_STR(WINED3DFMT_A2R10G10B10);
 154     FMT_TO_STR(WINED3DFMT_A16B16G16R16);
 155     FMT_TO_STR(WINED3DFMT_A8P8);
 156     FMT_TO_STR(WINED3DFMT_P8);
 157     FMT_TO_STR(WINED3DFMT_L8);
 158     FMT_TO_STR(WINED3DFMT_A8L8);
 159     FMT_TO_STR(WINED3DFMT_A4L4);
 160     FMT_TO_STR(WINED3DFMT_V8U8);
 161     FMT_TO_STR(WINED3DFMT_L6V5U5);
 162     FMT_TO_STR(WINED3DFMT_X8L8V8U8);
 163     FMT_TO_STR(WINED3DFMT_Q8W8V8U8);
 164     FMT_TO_STR(WINED3DFMT_V16U16);
 165     FMT_TO_STR(WINED3DFMT_W11V11U10);
 166     FMT_TO_STR(WINED3DFMT_A2W10V10U10);
 167     FMT_TO_STR(WINED3DFMT_UYVY);
 168     FMT_TO_STR(WINED3DFMT_YUY2);
 169     FMT_TO_STR(WINED3DFMT_DXT1);
 170     FMT_TO_STR(WINED3DFMT_DXT2);
 171     FMT_TO_STR(WINED3DFMT_DXT3);
 172     FMT_TO_STR(WINED3DFMT_DXT4);
 173     FMT_TO_STR(WINED3DFMT_DXT5);
 174     FMT_TO_STR(WINED3DFMT_MULTI2_ARGB);
 175     FMT_TO_STR(WINED3DFMT_G8R8_G8B8);
 176     FMT_TO_STR(WINED3DFMT_R8G8_B8G8);
 177     FMT_TO_STR(WINED3DFMT_D16_LOCKABLE);
 178     FMT_TO_STR(WINED3DFMT_D32);
 179     FMT_TO_STR(WINED3DFMT_D15S1);
 180     FMT_TO_STR(WINED3DFMT_D24S8);
 181     FMT_TO_STR(WINED3DFMT_D24X8);
 182     FMT_TO_STR(WINED3DFMT_D24X4S4);
 183     FMT_TO_STR(WINED3DFMT_D16);
 184     FMT_TO_STR(WINED3DFMT_L16);
 185     FMT_TO_STR(WINED3DFMT_D32F_LOCKABLE);
 186     FMT_TO_STR(WINED3DFMT_D24FS8);
 187     FMT_TO_STR(WINED3DFMT_VERTEXDATA);
 188     FMT_TO_STR(WINED3DFMT_INDEX16);
 189     FMT_TO_STR(WINED3DFMT_INDEX32);
 190     FMT_TO_STR(WINED3DFMT_Q16W16V16U16);
 191     FMT_TO_STR(WINED3DFMT_R16F);
 192     FMT_TO_STR(WINED3DFMT_G16R16F);
 193     FMT_TO_STR(WINED3DFMT_A16B16G16R16F);
 194     FMT_TO_STR(WINED3DFMT_R32F);
 195     FMT_TO_STR(WINED3DFMT_G32R32F);
 196     FMT_TO_STR(WINED3DFMT_A32B32G32R32F);
 197     FMT_TO_STR(WINED3DFMT_CxV8U8);
 198 #undef FMT_TO_STR
 199   default:
 200     {
 201       char fourcc[5];
 202       fourcc[0] = (char)(fmt);
 203       fourcc[1] = (char)(fmt >> 8);
 204       fourcc[2] = (char)(fmt >> 16);
 205       fourcc[3] = (char)(fmt >> 24);
 206       fourcc[4] = 0;
 207       if( isprint(fourcc[0]) && isprint(fourcc[1]) && isprint(fourcc[2]) && isprint(fourcc[3]) )
 208         FIXME("Unrecognized %u (as fourcc: %s) D3DFORMAT!\n", fmt, fourcc);
 209       else
 210         FIXME("Unrecognized %u D3DFORMAT!\n", fmt);
 211     }
 212     return "unrecognized";
 213   }
 214 }
 215
 216 const char* debug_d3ddevicetype(D3DDEVTYPE devtype) {
 217   switch (devtype) {
 218 #define DEVTYPE_TO_STR(dev) case dev: return #dev
 219     DEVTYPE_TO_STR(D3DDEVTYPE_HAL);
 220     DEVTYPE_TO_STR(D3DDEVTYPE_REF);
 221     DEVTYPE_TO_STR(D3DDEVTYPE_SW);
 222 #undef DEVTYPE_TO_STR
 223   default:
 224     FIXME("Unrecognized %u D3DDEVTYPE!\n", devtype);
 225     return "unrecognized";
 226   }
 227 }
 228
 229 const char* debug_d3dusage(DWORD usage) {
 230   switch (usage) {
 231 #define WINED3DUSAGE_TO_STR(u) case u: return #u
 232     WINED3DUSAGE_TO_STR(WINED3DUSAGE_RENDERTARGET);
 233     WINED3DUSAGE_TO_STR(WINED3DUSAGE_DEPTHSTENCIL);
 234     WINED3DUSAGE_TO_STR(WINED3DUSAGE_WRITEONLY);
 235     WINED3DUSAGE_TO_STR(WINED3DUSAGE_SOFTWAREPROCESSING);
 236     WINED3DUSAGE_TO_STR(WINED3DUSAGE_DONOTCLIP);
 237     WINED3DUSAGE_TO_STR(WINED3DUSAGE_POINTS);
 238     WINED3DUSAGE_TO_STR(WINED3DUSAGE_RTPATCHES);
 239     WINED3DUSAGE_TO_STR(WINED3DUSAGE_NPATCHES);
 240     WINED3DUSAGE_TO_STR(WINED3DUSAGE_DYNAMIC);
 241 #undef WINED3DUSAGE_TO_STR
 242   case 0: return "none";
 243   default:
 244     FIXME("Unrecognized %lu Usage!\n", usage);
 245     return "unrecognized";
 246   }
 247 }
 248
 249 const char* debug_d3dresourcetype(WINED3DRESOURCETYPE res) {
 250   switch (res) {
 251 #define RES_TO_STR(res) case res: return #res;
 252     RES_TO_STR(WINED3DRTYPE_SURFACE);
 253     RES_TO_STR(WINED3DRTYPE_VOLUME);
 254     RES_TO_STR(WINED3DRTYPE_TEXTURE);
 255     RES_TO_STR(WINED3DRTYPE_VOLUMETEXTURE);
 256     RES_TO_STR(WINED3DRTYPE_CUBETEXTURE);
 257     RES_TO_STR(WINED3DRTYPE_VERTEXBUFFER);
 258     RES_TO_STR(WINED3DRTYPE_INDEXBUFFER);
 259 #undef  RES_TO_STR
 260   default:
 261     FIXME("Unrecognized %u WINED3DRESOURCETYPE!\n", res);
 262     return "unrecognized";
 263   }
 264 }
 265
 266 const char* debug_d3dprimitivetype(D3DPRIMITIVETYPE PrimitiveType) {
 267   switch (PrimitiveType) {
 268 #define PRIM_TO_STR(prim) case prim: return #prim;
 269     PRIM_TO_STR(D3DPT_POINTLIST);
 270     PRIM_TO_STR(D3DPT_LINELIST);
 271     PRIM_TO_STR(D3DPT_LINESTRIP);
 272     PRIM_TO_STR(D3DPT_TRIANGLELIST);
 273     PRIM_TO_STR(D3DPT_TRIANGLESTRIP);
 274     PRIM_TO_STR(D3DPT_TRIANGLEFAN);
 275 #undef  PRIM_TO_STR
 276   default:
 277     FIXME("Unrecognized %u D3DPRIMITIVETYPE!\n", PrimitiveType);
 278     return "unrecognized";
 279   }
 280 }
 281
 282 const char* debug_d3drenderstate(DWORD state) {
 283   switch (state) {
 284 #define D3DSTATE_TO_STR(u) case u: return #u
 285     D3DSTATE_TO_STR(WINED3DRS_TEXTUREHANDLE             );
 286     D3DSTATE_TO_STR(WINED3DRS_ANTIALIAS                 );
 287     D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESS            );
 288     D3DSTATE_TO_STR(WINED3DRS_TEXTUREPERSPECTIVE        );
 289     D3DSTATE_TO_STR(WINED3DRS_WRAPU                     );
 290     D3DSTATE_TO_STR(WINED3DRS_WRAPV                     );
 291     D3DSTATE_TO_STR(WINED3DRS_ZENABLE                   );
 292     D3DSTATE_TO_STR(WINED3DRS_FILLMODE                  );
 293     D3DSTATE_TO_STR(WINED3DRS_SHADEMODE                 );
 294     D3DSTATE_TO_STR(WINED3DRS_LINEPATTERN               );
 295     D3DSTATE_TO_STR(WINED3DRS_MONOENABLE                );
 296     D3DSTATE_TO_STR(WINED3DRS_ROP2                      );
 297     D3DSTATE_TO_STR(WINED3DRS_PLANEMASK                 );
 298     D3DSTATE_TO_STR(WINED3DRS_ZWRITEENABLE              );
 299     D3DSTATE_TO_STR(WINED3DRS_ALPHATESTENABLE           );
 300     D3DSTATE_TO_STR(WINED3DRS_LASTPIXEL                 );
 301     D3DSTATE_TO_STR(WINED3DRS_TEXTUREMAG                );
 302     D3DSTATE_TO_STR(WINED3DRS_TEXTUREMIN                );
 303     D3DSTATE_TO_STR(WINED3DRS_SRCBLEND                  );
 304     D3DSTATE_TO_STR(WINED3DRS_DESTBLEND                 );
 305     D3DSTATE_TO_STR(WINED3DRS_TEXTUREMAPBLEND           );
 306     D3DSTATE_TO_STR(WINED3DRS_CULLMODE                  );
 307     D3DSTATE_TO_STR(WINED3DRS_ZFUNC                     );
 308     D3DSTATE_TO_STR(WINED3DRS_ALPHAREF                  );
 309     D3DSTATE_TO_STR(WINED3DRS_ALPHAFUNC                 );
 310     D3DSTATE_TO_STR(WINED3DRS_DITHERENABLE              );
 311     D3DSTATE_TO_STR(WINED3DRS_ALPHABLENDENABLE          );
 312     D3DSTATE_TO_STR(WINED3DRS_FOGENABLE                 );
 313     D3DSTATE_TO_STR(WINED3DRS_SPECULARENABLE            );
 314     D3DSTATE_TO_STR(WINED3DRS_ZVISIBLE                  );
 315     D3DSTATE_TO_STR(WINED3DRS_SUBPIXEL                  );
 316     D3DSTATE_TO_STR(WINED3DRS_SUBPIXELX                 );
 317     D3DSTATE_TO_STR(WINED3DRS_STIPPLEDALPHA             );
 318     D3DSTATE_TO_STR(WINED3DRS_FOGCOLOR                  );
 319     D3DSTATE_TO_STR(WINED3DRS_FOGTABLEMODE              );
 320     D3DSTATE_TO_STR(WINED3DRS_FOGSTART                  );
 321     D3DSTATE_TO_STR(WINED3DRS_FOGEND                    );
 322     D3DSTATE_TO_STR(WINED3DRS_FOGDENSITY                );
 323     D3DSTATE_TO_STR(WINED3DRS_STIPPLEENABLE             );
 324     D3DSTATE_TO_STR(WINED3DRS_EDGEANTIALIAS             );
 325     D3DSTATE_TO_STR(WINED3DRS_COLORKEYENABLE            );
 326     D3DSTATE_TO_STR(WINED3DRS_BORDERCOLOR               );
 327     D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESSU           );
 328     D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESSV           );
 329     D3DSTATE_TO_STR(WINED3DRS_MIPMAPLODBIAS             );
 330     D3DSTATE_TO_STR(WINED3DRS_ZBIAS                     );
 331     D3DSTATE_TO_STR(WINED3DRS_RANGEFOGENABLE            );
 332     D3DSTATE_TO_STR(WINED3DRS_ANISOTROPY                );
 333     D3DSTATE_TO_STR(WINED3DRS_FLUSHBATCH                );
 334     D3DSTATE_TO_STR(WINED3DRS_TRANSLUCENTSORTINDEPENDENT);
 335     D3DSTATE_TO_STR(WINED3DRS_STENCILENABLE             );
 336     D3DSTATE_TO_STR(WINED3DRS_STENCILFAIL               );
 337     D3DSTATE_TO_STR(WINED3DRS_STENCILZFAIL              );
 338     D3DSTATE_TO_STR(WINED3DRS_STENCILPASS               );
 339     D3DSTATE_TO_STR(WINED3DRS_STENCILFUNC               );
 340     D3DSTATE_TO_STR(WINED3DRS_STENCILREF                );
 341     D3DSTATE_TO_STR(WINED3DRS_STENCILMASK               );
 342     D3DSTATE_TO_STR(WINED3DRS_STENCILWRITEMASK          );
 343     D3DSTATE_TO_STR(WINED3DRS_TEXTUREFACTOR             );
 344     D3DSTATE_TO_STR(WINED3DRS_WRAP0                     );
 345     D3DSTATE_TO_STR(WINED3DRS_WRAP1                     );
 346     D3DSTATE_TO_STR(WINED3DRS_WRAP2                     );
 347     D3DSTATE_TO_STR(WINED3DRS_WRAP3                     );
 348     D3DSTATE_TO_STR(WINED3DRS_WRAP4                     );
 349     D3DSTATE_TO_STR(WINED3DRS_WRAP5                     );
 350     D3DSTATE_TO_STR(WINED3DRS_WRAP6                     );
 351     D3DSTATE_TO_STR(WINED3DRS_WRAP7                     );
 352     D3DSTATE_TO_STR(WINED3DRS_CLIPPING                  );
 353     D3DSTATE_TO_STR(WINED3DRS_LIGHTING                  );
 354     D3DSTATE_TO_STR(WINED3DRS_EXTENTS                   );
 355     D3DSTATE_TO_STR(WINED3DRS_AMBIENT                   );
 356     D3DSTATE_TO_STR(WINED3DRS_FOGVERTEXMODE             );
 357     D3DSTATE_TO_STR(WINED3DRS_COLORVERTEX               );
 358     D3DSTATE_TO_STR(WINED3DRS_LOCALVIEWER               );
 359     D3DSTATE_TO_STR(WINED3DRS_NORMALIZENORMALS          );
 360     D3DSTATE_TO_STR(WINED3DRS_COLORKEYBLENDENABLE       );
 361     D3DSTATE_TO_STR(WINED3DRS_DIFFUSEMATERIALSOURCE     );
 362     D3DSTATE_TO_STR(WINED3DRS_SPECULARMATERIALSOURCE    );
 363     D3DSTATE_TO_STR(WINED3DRS_AMBIENTMATERIALSOURCE     );
 364     D3DSTATE_TO_STR(WINED3DRS_EMISSIVEMATERIALSOURCE    );
 365     D3DSTATE_TO_STR(WINED3DRS_VERTEXBLEND               );
 366     D3DSTATE_TO_STR(WINED3DRS_CLIPPLANEENABLE           );
 367     D3DSTATE_TO_STR(WINED3DRS_SOFTWAREVERTEXPROCESSING  );
 368     D3DSTATE_TO_STR(WINED3DRS_POINTSIZE                 );
 369     D3DSTATE_TO_STR(WINED3DRS_POINTSIZE_MIN             );
 370     D3DSTATE_TO_STR(WINED3DRS_POINTSPRITEENABLE         );
 371     D3DSTATE_TO_STR(WINED3DRS_POINTSCALEENABLE          );
 372     D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_A              );
 373     D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_B              );
 374     D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_C              );
 375     D3DSTATE_TO_STR(WINED3DRS_MULTISAMPLEANTIALIAS      );
 376     D3DSTATE_TO_STR(WINED3DRS_MULTISAMPLEMASK           );
 377     D3DSTATE_TO_STR(WINED3DRS_PATCHEDGESTYLE            );
 378     D3DSTATE_TO_STR(WINED3DRS_PATCHSEGMENTS             );
 379     D3DSTATE_TO_STR(WINED3DRS_DEBUGMONITORTOKEN         );
 380     D3DSTATE_TO_STR(WINED3DRS_POINTSIZE_MAX             );
 381     D3DSTATE_TO_STR(WINED3DRS_INDEXEDVERTEXBLENDENABLE  );
 382     D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE          );
 383     D3DSTATE_TO_STR(WINED3DRS_TWEENFACTOR               );
 384     D3DSTATE_TO_STR(WINED3DRS_BLENDOP                   );
 385     D3DSTATE_TO_STR(WINED3DRS_POSITIONDEGREE            );
 386     D3DSTATE_TO_STR(WINED3DRS_NORMALDEGREE              );
 387     D3DSTATE_TO_STR(WINED3DRS_SCISSORTESTENABLE         );
 388     D3DSTATE_TO_STR(WINED3DRS_SLOPESCALEDEPTHBIAS       );
 389     D3DSTATE_TO_STR(WINED3DRS_ANTIALIASEDLINEENABLE     );
 390     D3DSTATE_TO_STR(WINED3DRS_MINTESSELLATIONLEVEL      );
 391     D3DSTATE_TO_STR(WINED3DRS_MAXTESSELLATIONLEVEL      );
 392     D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_X            );
 393     D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_Y            );
 394     D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_Z            );
 395     D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_W            );
 396     D3DSTATE_TO_STR(WINED3DRS_ENABLEADAPTIVETESSELLATION);
 397     D3DSTATE_TO_STR(WINED3DRS_TWOSIDEDSTENCILMODE       );
 398     D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILFAIL           );
 399     D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILZFAIL          );
 400     D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILPASS           );
 401     D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILFUNC           );
 402     D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE1         );
 403     D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE2         );
 404     D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE3         );
 405     D3DSTATE_TO_STR(WINED3DRS_BLENDFACTOR               );
 406     D3DSTATE_TO_STR(WINED3DRS_SRGBWRITEENABLE           );
 407     D3DSTATE_TO_STR(WINED3DRS_DEPTHBIAS                 );
 408     D3DSTATE_TO_STR(WINED3DRS_WRAP8                     );
 409     D3DSTATE_TO_STR(WINED3DRS_WRAP9                     );
 410     D3DSTATE_TO_STR(WINED3DRS_WRAP10                    );
 411     D3DSTATE_TO_STR(WINED3DRS_WRAP11                    );
 412     D3DSTATE_TO_STR(WINED3DRS_WRAP12                    );
 413     D3DSTATE_TO_STR(WINED3DRS_WRAP13                    );
 414     D3DSTATE_TO_STR(WINED3DRS_WRAP14                    );
 415     D3DSTATE_TO_STR(WINED3DRS_WRAP15                    );
 416     D3DSTATE_TO_STR(WINED3DRS_SEPARATEALPHABLENDENABLE  );
 417     D3DSTATE_TO_STR(WINED3DRS_SRCBLENDALPHA             );
 418     D3DSTATE_TO_STR(WINED3DRS_DESTBLENDALPHA            );
 419     D3DSTATE_TO_STR(WINED3DRS_BLENDOPALPHA              );
 420 #undef D3DSTATE_TO_STR
 421   default:
 422     FIXME("Unrecognized %lu render state!\n", state);
 423     return "unrecognized";
 424   }
 425 }
 426
 427 const char* debug_d3dsamplerstate(DWORD state) {
 428   switch (state) {
 429 #define D3DSTATE_TO_STR(u) case u: return #u
 430     D3DSTATE_TO_STR(WINED3DSAMP_BORDERCOLOR  );
 431     D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSU     );
 432     D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSV     );
 433     D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSW     );
 434     D3DSTATE_TO_STR(WINED3DSAMP_MAGFILTER    );
 435     D3DSTATE_TO_STR(WINED3DSAMP_MINFILTER    );
 436     D3DSTATE_TO_STR(WINED3DSAMP_MIPFILTER    );
 437     D3DSTATE_TO_STR(WINED3DSAMP_MIPMAPLODBIAS);
 438     D3DSTATE_TO_STR(WINED3DSAMP_MAXMIPLEVEL  );
 439     D3DSTATE_TO_STR(WINED3DSAMP_MAXANISOTROPY);
 440     D3DSTATE_TO_STR(WINED3DSAMP_SRGBTEXTURE  );
 441     D3DSTATE_TO_STR(WINED3DSAMP_ELEMENTINDEX );
 442     D3DSTATE_TO_STR(WINED3DSAMP_DMAPOFFSET   );
 443 #undef D3DSTATE_TO_STR
 444   default:
 445     FIXME("Unrecognized %lu sampler state!\n", state);
 446     return "unrecognized";
 447   }
 448 }
 449
 450 const char* debug_d3dtexturestate(DWORD state) {
 451   switch (state) {
 452 #define D3DSTATE_TO_STR(u) case u: return #u
 453     D3DSTATE_TO_STR(WINED3DTSS_COLOROP               );
 454     D3DSTATE_TO_STR(WINED3DTSS_COLORARG1             );
 455     D3DSTATE_TO_STR(WINED3DTSS_COLORARG2             );
 456     D3DSTATE_TO_STR(WINED3DTSS_ALPHAOP               );
 457     D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG1             );
 458     D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG2             );
 459     D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT00          );
 460     D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT01          );
 461     D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT10          );
 462     D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT11          );
 463     D3DSTATE_TO_STR(WINED3DTSS_TEXCOORDINDEX         );
 464     D3DSTATE_TO_STR(WINED3DTSS_BUMPENVLSCALE         );
 465     D3DSTATE_TO_STR(WINED3DTSS_BUMPENVLOFFSET        );
 466     D3DSTATE_TO_STR(WINED3DTSS_TEXTURETRANSFORMFLAGS );
 467     D3DSTATE_TO_STR(WINED3DTSS_ADDRESSW              );
 468     D3DSTATE_TO_STR(WINED3DTSS_COLORARG0             );
 469     D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG0             );
 470     D3DSTATE_TO_STR(WINED3DTSS_RESULTARG             );
 471     D3DSTATE_TO_STR(WINED3DTSS_CONSTANT              );
 472 #undef D3DSTATE_TO_STR
 473   case 12:
 474     /* Note D3DTSS are not consecutive, so skip these */
 475     return "unused";
 476     break;
 477   default:
 478     FIXME("Unrecognized %lu texture state!\n", state);
 479     return "unrecognized";
 480   }
 481 }
 482
 483 const char* debug_d3dpool(WINED3DPOOL Pool) {
 484   switch (Pool) {
 485 #define POOL_TO_STR(p) case p: return #p;
 486     POOL_TO_STR(WINED3DPOOL_DEFAULT);
 487     POOL_TO_STR(WINED3DPOOL_MANAGED);
 488     POOL_TO_STR(WINED3DPOOL_SYSTEMMEM);
 489     POOL_TO_STR(WINED3DPOOL_SCRATCH);
 490 #undef  POOL_TO_STR
 491   default:
 492     FIXME("Unrecognized %u WINED3DPOOL!\n", Pool);
 493     return "unrecognized";
 494   }
 495 }
 496 /*****************************************************************************
 497  * Useful functions mapping GL <-> D3D values
 498  */
 499 GLenum StencilOp(DWORD op) {
 500     switch(op) {
 501     case D3DSTENCILOP_KEEP    : return GL_KEEP;
 502     case D3DSTENCILOP_ZERO    : return GL_ZERO;
 503     case D3DSTENCILOP_REPLACE : return GL_REPLACE;
 504     case D3DSTENCILOP_INCRSAT : return GL_INCR;
 505     case D3DSTENCILOP_DECRSAT : return GL_DECR;
 506     case D3DSTENCILOP_INVERT  : return GL_INVERT;
 507     case D3DSTENCILOP_INCR    : return GL_INCR_WRAP_EXT;
 508     case D3DSTENCILOP_DECR    : return GL_DECR_WRAP_EXT;
 509     default:
 510         FIXME("Unrecognized stencil op %ld\n", op);
 511         return GL_KEEP;
 512     }
 513 }
 514
 515 GLenum StencilFunc(DWORD func) {
 516     switch ((D3DCMPFUNC)func) {
 517     case D3DCMP_NEVER        : return GL_NEVER;
 518     case D3DCMP_LESS         : return GL_LESS;
 519     case D3DCMP_EQUAL        : return GL_EQUAL;
 520     case D3DCMP_LESSEQUAL    : return GL_LEQUAL;
 521     case D3DCMP_GREATER      : return GL_GREATER;
 522     case D3DCMP_NOTEQUAL     : return GL_NOTEQUAL;
 523     case D3DCMP_GREATEREQUAL : return GL_GEQUAL;
 524     case D3DCMP_ALWAYS       : return GL_ALWAYS;
 525     default:
 526         FIXME("Unrecognized D3DCMPFUNC value %ld\n", func);
 527         return GL_ALWAYS;
 528     }
 529 }
 530
 531 static void get_src_and_opr(DWORD arg, BOOL is_alpha, GLenum* source, GLenum* operand) {
 532     /* The D3DTA_ALPHAREPLICATE flag specifies the alpha component of the
 533      * input should be used for all input components. The D3DTA_COMPLEMENT
 534      * flag specifies the complement of the input should be used. */
 535     BOOL from_alpha = is_alpha || arg & D3DTA_ALPHAREPLICATE;
 536     BOOL complement = arg & D3DTA_COMPLEMENT;
 537
 538     /* Calculate the operand */
 539     if (complement) {
 540         if (from_alpha) *operand = GL_ONE_MINUS_SRC_ALPHA;
 541         else *operand = GL_ONE_MINUS_SRC_COLOR;
 542     } else {
 543         if (from_alpha) *operand = GL_SRC_ALPHA;
 544         else *operand = GL_SRC_COLOR;
 545     }
 546
 547     /* Calculate the source */
 548     switch (arg & D3DTA_SELECTMASK) {
 549         case D3DTA_CURRENT: *source = GL_PREVIOUS_EXT; break;
 550         case D3DTA_DIFFUSE: *source = GL_PRIMARY_COLOR_EXT; break;
 551         case D3DTA_TEXTURE: *source = GL_TEXTURE; break;
 552         case D3DTA_TFACTOR: *source = GL_CONSTANT_EXT; break;
 553         case D3DTA_SPECULAR:
 554             /*
 555              * According to the GL_ARB_texture_env_combine specs, SPECULAR is
 556              * 'Secondary color' and isn't supported until base GL supports it
 557              * There is no concept of temp registers as far as I can tell
 558              */
 559             FIXME("Unhandled texture arg D3DTA_SPECULAR\n");
 560             *source = GL_TEXTURE;
 561             break;
 562         default:
 563             FIXME("Unrecognized texture arg %#lx\n", arg);
 564             *source = GL_TEXTURE;
 565             break;
 566     }
 567 }
 568
 569 /* Set texture operations up - The following avoids lots of ifdefs in this routine!*/
 570 #if defined (GL_VERSION_1_3)
 571 # define useext(A) A
 572 # define combine_ext 1
 573 #elif defined (GL_EXT_texture_env_combine)
 574 # define useext(A) A##_EXT
 575 # define combine_ext 1
 576 #elif defined (GL_ARB_texture_env_combine)
 577 # define useext(A) A##_ARB
 578 # define combine_ext 1
 579 #else
 580 # undef combine_ext
 581 #endif
 582
 583 #if !defined(combine_ext)
 584 void set_tex_op(IWineD3DDevice *iface, BOOL isAlpha, int Stage, D3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3)
 585 {
 586         FIXME("Requires opengl combine extensions to work\n");
 587         return;
 588 }
 589 #else
 590 /* Setup the texture operations texture stage states */
 591 void set_tex_op(IWineD3DDevice *iface, BOOL isAlpha, int Stage, D3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3)
 592 {
 593 #define GLINFO_LOCATION ((IWineD3DImpl *)(This->wineD3D))->gl_info
 594         GLenum src1, src2, src3;
 595         GLenum opr1, opr2, opr3;
 596         GLenum comb_target;
 597         GLenum src0_target, src1_target, src2_target;
 598         GLenum opr0_target, opr1_target, opr2_target;
 599         GLenum scal_target;
 600         GLenum opr=0, invopr, src3_target, opr3_target;
 601         BOOL Handled = FALSE;
 602         IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
 603
 604         TRACE("Alpha?(%d), Stage:%d Op(%d), a1(%ld), a2(%ld), a3(%ld)\n", isAlpha, Stage, op, arg1, arg2, arg3);
 605
 606         ENTER_GL();
 607
 608         /* Note: Operations usually involve two ars, src0 and src1 and are operations of
 609            the form (a1 <operation> a2). However, some of the more complex operations
 610            take 3 parameters. Instead of the (sensible) addition of a3, Microsoft added
 611            in a third parameter called a0. Therefore these are operations of the form
 612            a0 <operation> a1 <operation> a2, ie the new parameter goes to the front.
 613
 614            However, below we treat the new (a0) parameter as src2/opr2, so in the actual
 615            functions below, expect their syntax to differ slightly to those listed in the
 616            manuals, ie replace arg1 with arg3, arg2 with arg1 and arg3 with arg2
 617            This affects D3DTOP_MULTIPLYADD and D3DTOP_LERP                               */
 618
 619         if (isAlpha) {
 620                 comb_target = useext(GL_COMBINE_ALPHA);
 621                 src0_target = useext(GL_SOURCE0_ALPHA);
 622                 src1_target = useext(GL_SOURCE1_ALPHA);
 623                 src2_target = useext(GL_SOURCE2_ALPHA);
 624                 opr0_target = useext(GL_OPERAND0_ALPHA);
 625                 opr1_target = useext(GL_OPERAND1_ALPHA);
 626                 opr2_target = useext(GL_OPERAND2_ALPHA);
 627                 scal_target = GL_ALPHA_SCALE;
 628         }
 629         else {
 630                 comb_target = useext(GL_COMBINE_RGB);
 631                 src0_target = useext(GL_SOURCE0_RGB);
 632                 src1_target = useext(GL_SOURCE1_RGB);
 633                 src2_target = useext(GL_SOURCE2_RGB);
 634                 opr0_target = useext(GL_OPERAND0_RGB);
 635                 opr1_target = useext(GL_OPERAND1_RGB);
 636                 opr2_target = useext(GL_OPERAND2_RGB);
 637                 scal_target = useext(GL_RGB_SCALE);
 638         }
 639
 640         /* From MSDN (WINED3DTSS_ALPHAARG1) :
 641            The default argument is D3DTA_TEXTURE. If no texture is set for this stage,
 642                    then the default argument is D3DTA_DIFFUSE.
 643                    FIXME? If texture added/removed, may need to reset back as well?    */
 644         if (isAlpha && This->stateBlock->textures[Stage] == NULL && arg1 == D3DTA_TEXTURE) {
 645             get_src_and_opr(D3DTA_DIFFUSE, isAlpha, &src1, &opr1);
 646         } else {
 647             get_src_and_opr(arg1, isAlpha, &src1, &opr1);
 648         }
 649         get_src_and_opr(arg2, isAlpha, &src2, &opr2);
 650         get_src_and_opr(arg3, isAlpha, &src3, &opr3);
 651
 652         TRACE("ct(%x), 1:(%x,%x), 2:(%x,%x), 3:(%x,%x)\n", comb_target, src1, opr1, src2, opr2, src3, opr3);
 653
 654         Handled = TRUE; /* Assume will be handled */
 655
 656         /* Other texture operations require special extensions: */
 657         if (GL_SUPPORT(NV_TEXTURE_ENV_COMBINE4)) {
 658           if (isAlpha) {
 659             opr = GL_SRC_ALPHA;
 660             invopr = GL_ONE_MINUS_SRC_ALPHA;
 661             src3_target = GL_SOURCE3_ALPHA_NV;
 662             opr3_target = GL_OPERAND3_ALPHA_NV;
 663           } else {
 664             opr = GL_SRC_COLOR;
 665             invopr = GL_ONE_MINUS_SRC_COLOR;
 666             src3_target = GL_SOURCE3_RGB_NV;
 667             opr3_target = GL_OPERAND3_RGB_NV;
 668           }
 669           switch (op) {
 670           case D3DTOP_DISABLE: /* Only for alpha */
 671             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
 672             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
 673             glTexEnvi(GL_TEXTURE_ENV, src0_target, GL_PREVIOUS_EXT);
 674             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
 675             glTexEnvi(GL_TEXTURE_ENV, opr0_target, GL_SRC_ALPHA);
 676             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
 677             glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
 678             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
 679             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
 680             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
 681             glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
 682             checkGLcall("GL_TEXTURE_ENV, src2_target, GL_ZERO");
 683             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
 684             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
 685             glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
 686             checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
 687             glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
 688             checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
 689             break;
 690           case D3DTOP_SELECTARG1:                                          /* = a1 * 1 + 0 * 0 */
 691           case D3DTOP_SELECTARG2:                                          /* = a2 * 1 + 0 * 0 */
 692             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
 693             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
 694             if (op == D3DTOP_SELECTARG1) {
 695               glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
 696               checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
 697               glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
 698               checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
 699             } else {
 700               glTexEnvi(GL_TEXTURE_ENV, src0_target, src2);
 701               checkGLcall("GL_TEXTURE_ENV, src0_target, src2");
 702               glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr2);
 703               checkGLcall("GL_TEXTURE_ENV, opr0_target, opr2");
 704             }
 705             glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
 706             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
 707             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
 708             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
 709             glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
 710             checkGLcall("GL_TEXTURE_ENV, src2_target, GL_ZERO");
 711             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
 712             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
 713             glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
 714             checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
 715             glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
 716             checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
 717             break;
 718
 719           case D3DTOP_MODULATE:
 720             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
 721             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
 722             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
 723             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
 724             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
 725             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
 726             glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
 727             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
 728             glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
 729             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
 730             glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
 731             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
 732             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
 733             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
 734             glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
 735             checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
 736             glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
 737             checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
 738             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
 739             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
 740             break;
 741           case D3DTOP_MODULATE2X:
 742             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
 743             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
 744             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
 745             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
 746             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
 747             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
 748             glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
 749             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
 750             glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
 751             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
 752             glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
 753             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
 754             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
 755             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
 756             glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
 757             checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
 758             glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
 759             checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
 760             glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
 761             checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
 762             break;
 763           case D3DTOP_MODULATE4X:
 764             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
 765             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
 766             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
 767             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
 768             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
 769             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
 770             glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
 771             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
 772             glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
 773             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
 774             glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
 775             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
 776             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
 777             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
 778             glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
 779             checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
 780             glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
 781             checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
 782             glTexEnvi(GL_TEXTURE_ENV, scal_target, 4);
 783             checkGLcall("GL_TEXTURE_ENV, scal_target, 4");
 784             break;
 785
 786           case D3DTOP_ADD:
 787             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
 788             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
 789             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
 790             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
 791             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
 792             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
 793             glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
 794             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
 795             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
 796             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
 797             glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
 798             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
 799             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
 800             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
 801             glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
 802             checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
 803             glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
 804             checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
 805             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
 806             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
 807             break;
 808
 809           case D3DTOP_ADDSIGNED:
 810             glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED));
 811             checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED)");
 812             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
 813             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
 814             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
 815             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
 816             glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
 817             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
 818             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
 819             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
 820             glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
 821             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
 822             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
 823             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
 824             glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
 825             checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
 826             glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
 827             checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
 828             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
 829             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
 830             break;
 831
 832           case D3DTOP_ADDSIGNED2X:
 833             glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED));
 834             checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED)");
 835             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
 836             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
 837             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
 838             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
 839             glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
 840             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
 841             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
 842             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
 843             glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
 844             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
 845             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
 846             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
 847             glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
 848             checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
 849             glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
 850             checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
 851             glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
 852             checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
 853             break;
 854
 855           case D3DTOP_ADDSMOOTH:
 856             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
 857             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
 858             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
 859             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
 860             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
 861             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
 862             glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
 863             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
 864             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
 865             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
 866             glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
 867             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
 868             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
 869             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
 870             glTexEnvi(GL_TEXTURE_ENV, src3_target, src1);
 871             checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
 872             switch (opr1) {
 873             case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_COLOR; break;
 874             case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_COLOR; break;
 875             case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
 876             case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
 877             }
 878             glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
 879             checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
 880             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
 881             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
 882             break;
 883
 884           case D3DTOP_BLENDDIFFUSEALPHA:
 885             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
 886             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
 887             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
 888             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
 889             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
 890             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
 891             glTexEnvi(GL_TEXTURE_ENV, src1_target, useext(GL_PRIMARY_COLOR));
 892             checkGLcall("GL_TEXTURE_ENV, src1_target, useext(GL_PRIMARY_COLOR)");
 893             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
 894             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
 895             glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
 896             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
 897             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
 898             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
 899             glTexEnvi(GL_TEXTURE_ENV, src3_target, useext(GL_PRIMARY_COLOR));
 900             checkGLcall("GL_TEXTURE_ENV, src3_target, useext(GL_PRIMARY_COLOR)");
 901             glTexEnvi(GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA);
 902             checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
 903             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
 904             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
 905             break;
 906           case D3DTOP_BLENDTEXTUREALPHA:
 907             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
 908             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
 909             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
 910             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
 911             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
 912             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
 913             glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_TEXTURE);
 914             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_TEXTURE");
 915             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
 916             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
 917             glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
 918             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
 919             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
 920             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
 921             glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_TEXTURE);
 922             checkGLcall("GL_TEXTURE_ENV, src3_target, GL_TEXTURE");
 923             glTexEnvi(GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA);
 924             checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
 925             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
 926             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
 927             break;
 928           case D3DTOP_BLENDFACTORALPHA:
 929             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
 930             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
 931             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
 932             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
 933             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
 934             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
 935             glTexEnvi(GL_TEXTURE_ENV, src1_target, useext(GL_CONSTANT));
 936             checkGLcall("GL_TEXTURE_ENV, src1_target, useext(GL_CONSTANT)");
 937             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
 938             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
 939             glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
 940             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
 941             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
 942             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
 943             glTexEnvi(GL_TEXTURE_ENV, src3_target, useext(GL_CONSTANT));
 944             checkGLcall("GL_TEXTURE_ENV, src3_target, useext(GL_CONSTANT)");
 945             glTexEnvi(GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA);
 946             checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
 947             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
 948             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
 949             break;
 950           case D3DTOP_BLENDTEXTUREALPHAPM:
 951             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
 952             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
 953             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
 954             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
 955             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
 956             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
 957             glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
 958             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
 959             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
 960             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
 961             glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
 962             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
 963             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
 964             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
 965             glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_TEXTURE);
 966             checkGLcall("GL_TEXTURE_ENV, src3_target, GL_TEXTURE");
 967             glTexEnvi(GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA);
 968             checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
 969             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
 970             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
 971             break;
 972           case D3DTOP_MODULATEALPHA_ADDCOLOR:
 973             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
 974             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");  /* Add = a0*a1 + a2*a3 */
 975             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);        /*   a0 = src1/opr1    */
 976             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
 977             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
 978             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");    /*   a1 = 1 (see docs) */
 979             glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
 980             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
 981             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
 982             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
 983             glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);        /*   a2 = arg2         */
 984             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
 985             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
 986             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");     /*  a3 = src1 alpha   */
 987             glTexEnvi(GL_TEXTURE_ENV, src3_target, src1);
 988             checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
 989             switch (opr) {
 990             case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
 991             case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
 992             }
 993             glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
 994             checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
 995             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
 996             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
 997             break;
 998           case D3DTOP_MODULATECOLOR_ADDALPHA:
 999             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1000             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1001             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1002             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1003             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1004             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1005             glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1006             checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1007             glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1008             checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1009             glTexEnvi(GL_TEXTURE_ENV, src2_target, src1);
1010             checkGLcall("GL_TEXTURE_ENV, src2_target, src1");
1011             switch (opr1) {
1012             case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
1013             case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1014             }
1015             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
1016             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
1017             glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1018             checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1019             glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
1020             checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
1021             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1022             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1023             break;
1024           case D3DTOP_MODULATEINVALPHA_ADDCOLOR:
1025             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1026             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1027             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1028             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1029             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1030             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1031             glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
1032             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1033             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1034             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1035             glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1036             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1037             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1038             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1039             glTexEnvi(GL_TEXTURE_ENV, src3_target, src1);
1040             checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
1041             switch (opr1) {
1042             case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1043             case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_ALPHA; break;
1044             case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1045             case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
1046             }
1047             glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
1048             checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
1049             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1050             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1051             break;
1052           case D3DTOP_MODULATEINVCOLOR_ADDALPHA:
1053             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1054             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1055             glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1056             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1057             switch (opr1) {
1058             case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_COLOR; break;
1059             case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_COLOR; break;
1060             case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1061             case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
1062             }
1063             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
1064             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
1065             glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1066             checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1067             glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1068             checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1069             glTexEnvi(GL_TEXTURE_ENV, src2_target, src1);
1070             checkGLcall("GL_TEXTURE_ENV, src2_target, src1");
1071             switch (opr1) {
1072             case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
1073             case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1074             }
1075             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
1076             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
1077             glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1078             checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1079             glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
1080             checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
1081             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1082             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1083             break;
1084           case D3DTOP_MULTIPLYADD:
1085             glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1086             checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1087             glTexEnvi(GL_TEXTURE_ENV, src0_target, src3);
1088             checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1089             glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr3);
1090             checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1091             glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
1092             checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1093             glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1094             checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1095             glTexEnvi(GL_TEXTURE_ENV, src2_target, src1);
1096             checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1097             glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr1);
1098             checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1099             glTexEnvi(GL_TEXTURE_ENV, src3_target, src2);
1100             checkGLcall("GL_TEXTURE_ENV, src3_target, src3");
1101             glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr2);
1102             checkGLcall("GL_TEXTURE_ENV, opr3_target, opr3");
1103             glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1104             checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1105             break;
1106
1107           case D3DTOP_BUMPENVMAP:
1108             {
1109               if (GL_SUPPORT(NV_TEXTURE_SHADER)) {
1110                 /*
1111                   texture unit 0: GL_TEXTURE_2D
1112                   texture unit 1: GL_DOT_PRODUCT_NV
1113                   texture unit 2: GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV
1114                   texture unit 3: GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV
1115                 */
1116                 float m[2][2];
1117
1118                 union {
1119                   float f;
1120                   DWORD d;
1121                 } tmpvalue;
1122
1123                 tmpvalue.d = This->stateBlock->textureState[Stage][WINED3DTSS_BUMPENVMAT00];
1124                 m[0][0] = tmpvalue.f;
1125                 tmpvalue.d = This->stateBlock->textureState[Stage][WINED3DTSS_BUMPENVMAT01];
1126                 m[0][1] = tmpvalue.f;
1127                 tmpvalue.d = This->stateBlock->textureState[Stage][WINED3DTSS_BUMPENVMAT10];
1128                 m[1][0] = tmpvalue.f;
1129                 tmpvalue.d = This->stateBlock->textureState[Stage][WINED3DTSS_BUMPENVMAT11];
1130                 m[1][1] = tmpvalue.f;
1131
1132                 /*FIXME("Stage %d matrix is (%.2f,%.2f),(%.2f,%.2f)\n", Stage, m[0][0], m[0][1], m[1][0], m[1][0]);*/
1133
1134                 if (FALSE == This->texture_shader_active) {
1135                   This->texture_shader_active = TRUE;
1136                   glEnable(GL_TEXTURE_SHADER_NV);
1137                 }
1138
1139                 /*
1140                 glEnable(GL_REGISTER_COMBINERS_NV);
1141                 glCombinerParameteriNV (GL_NUM_GENERAL_COMBINERS_NV, 1);
1142                 glCombinerInputNV (GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_A_NV, GL_TEXTURE0_ARB, GL_SIGNED_IDENTITY_NV, GL_RGB);
1143                 glCombinerInputNV (GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_B_NV, GL_NONE, GL_UNSIGNED_INVERT_NV, GL_RGB);
1144                 glCombinerInputNV (GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_C_NV, GL_TEXTURE2_ARB, GL_SIGNED_IDENTITY_NV, GL_RGB);
1145                 glCombinerInputNV (GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_D_NV, GL_NONE, GL_UNSIGNED_INVERT_NV, GL_RGB);
1146                 glCombinerOutputNV (GL_COMBINER0_NV, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV, GL_PRIMARY_COLOR_NV, 0, 0, 0, 0, 0);
1147                 glCombinerInputNV (GL_COMBINER0_NV, GL_ALPHA, GL_VARIABLE_A_NV, GL_TEXTURE0_ARB, GL_SIGNED_IDENTITY_NV, GL_ALPHA);
1148                 glCombinerInputNV (GL_COMBINER0_NV, GL_ALPHA, GL_VARIABLE_B_NV, GL_NONE, GL_UNSIGNED_INVERT_NV, GL_ALPHA);
1149                 glCombinerInputNV (GL_COMBINER0_NV, GL_ALPHA, GL_VARIABLE_C_NV, GL_TEXTURE2_ARB, GL_SIGNED_IDENTITY_NV, GL_ALPHA);
1150                 glCombinerInputNV (GL_COMBINER0_NV, GL_ALPHA, GL_VARIABLE_D_NV, GL_NONE, GL_UNSIGNED_INVERT_NV, GL_ALPHA);
1151                 glCombinerOutputNV (GL_COMBINER0_NV, GL_ALPHA, GL_DISCARD_NV, GL_DISCARD_NV, GL_PRIMARY_COLOR_NV, 0, 0, 0, 0, 0);
1152                 glDisable (GL_PER_STAGE_CONSTANTS_NV);
1153                 glCombinerParameteriNV (GL_COLOR_SUM_CLAMP_NV, 0);
1154                 glFinalCombinerInputNV (GL_VARIABLE_A_NV, 0, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
1155                 glFinalCombinerInputNV (GL_VARIABLE_B_NV, 0, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
1156                 glFinalCombinerInputNV (GL_VARIABLE_C_NV, 0, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
1157                 glFinalCombinerInputNV (GL_VARIABLE_D_NV, GL_PRIMARY_COLOR_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
1158                 glFinalCombinerInputNV (GL_VARIABLE_E_NV, 0, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
1159                 glFinalCombinerInputNV (GL_VARIABLE_F_NV, 0, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
1160                 glFinalCombinerInputNV (GL_VARIABLE_G_NV, GL_PRIMARY_COLOR_NV, GL_UNSIGNED_IDENTITY_NV, GL_ALPHA);
1161                 */
1162                 /*
1163                 int i;
1164                 for (i = 0; i < Stage; i++) {
1165                   if (GL_SUPPORT(ARB_MULTITEXTURE)) {
1166                     GL_ACTIVETEXTURE(i);
1167                     glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_2D);
1168                     checkGLcall("Activate texture..");
1169                   } else if (i>0) {
1170                     FIXME("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1171                   }
1172                 }
1173                 */
1174                 /*
1175                   GL_ACTIVETEXTURE(Stage - 1);
1176                   glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_2D);
1177                 */
1178                 /*
1179                 GL_ACTIVETEXTURE(Stage);
1180                 checkGLcall("Activate texture.. to update const color");
1181                 glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_OFFSET_TEXTURE_2D_NV);
1182                 checkGLcall("glTexEnv");
1183                 glTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, GL_TEXTURE0_ARB + Stage - 1);
1184                 checkGLcall("glTexEnv");
1185                 glTexEnvfv(GL_TEXTURE_SHADER_NV, GL_OFFSET_TEXTURE_MATRIX_NV, (float*)&m[0]);
1186                 checkGLcall("glTexEnv");
1187                 */
1188                 LEAVE_GL();
1189                 return;
1190               }
1191             }
1192
1193           case D3DTOP_BUMPENVMAPLUMINANCE:
1194
1195           default:
1196             Handled = FALSE;
1197           }
1198           if (Handled) {
1199             glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE4_NV);
1200             checkGLcall("GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE4_NV");
1201
1202             LEAVE_GL();
1203             return;
1204           }
1205         } /* GL_NV_texture_env_combine4 */
1206
1207         Handled = TRUE; /* Again, assume handled */
1208         switch (op) {
1209         case D3DTOP_DISABLE: /* Only for alpha */
1210                 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_REPLACE);
1211                 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
1212                 glTexEnvi(GL_TEXTURE_ENV, src0_target, GL_PREVIOUS_EXT);
1213                 checkGLcall("GL_TEXTURE_ENV, src0_target, GL_PREVIOUS_EXT");
1214                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, GL_SRC_ALPHA);
1215                 checkGLcall("GL_TEXTURE_ENV, opr0_target, GL_SRC_ALPHA");
1216                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1217                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1218                 break;
1219         case D3DTOP_SELECTARG1:
1220                 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_REPLACE);
1221                 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
1222                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1223                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1224                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1225                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1226                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1227                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1228                 break;
1229         case D3DTOP_SELECTARG2:
1230                 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_REPLACE);
1231                 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
1232                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src2);
1233                 checkGLcall("GL_TEXTURE_ENV, src0_target, src2");
1234                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr2);
1235                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr2");
1236                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1237                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1238                 break;
1239         case D3DTOP_MODULATE:
1240                 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE);
1241                 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
1242                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1243                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1244                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1245                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1246                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1247                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1248                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1249                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1250                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1251                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1252                 break;
1253         case D3DTOP_MODULATE2X:
1254                 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE);
1255                 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
1256                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1257                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1258                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1259                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1260                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1261                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1262                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1263                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1264                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
1265                 checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
1266                 break;
1267         case D3DTOP_MODULATE4X:
1268                 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE);
1269                 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
1270                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1271                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1272                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1273                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1274                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1275                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1276                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1277                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1278                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 4);
1279                 checkGLcall("GL_TEXTURE_ENV, scal_target, 4");
1280                 break;
1281         case D3DTOP_ADD:
1282                 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1283                 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1284                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1285                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1286                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1287                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1288                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1289                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1290                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1291                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1292                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1293                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1294                 break;
1295         case D3DTOP_ADDSIGNED:
1296                 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED));
1297                 checkGLcall("GL_TEXTURE_ENV, comb_target, useext((GL_ADD_SIGNED)");
1298                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1299                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1300                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1301                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1302                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1303                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1304                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1305                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1306                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1307                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1308                 break;
1309         case D3DTOP_ADDSIGNED2X:
1310                 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED));
1311                 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED)");
1312                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1313                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1314                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1315                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1316                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1317                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1318                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1319                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1320                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
1321                 checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
1322                 break;
1323         case D3DTOP_SUBTRACT:
1324           if (GL_SUPPORT(ARB_TEXTURE_ENV_COMBINE)) {
1325                 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_SUBTRACT);
1326                 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_SUBTRACT)");
1327                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1328                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1329                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1330                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1331                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1332                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1333                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1334                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1335                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1336                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1337           } else {
1338                 FIXME("This version of opengl does not support GL_SUBTRACT\n");
1339           }
1340           break;
1341
1342         case D3DTOP_BLENDDIFFUSEALPHA:
1343                 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
1344                 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
1345                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1346                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1347                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1348                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1349                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1350                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1351                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1352                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1353                 glTexEnvi(GL_TEXTURE_ENV, src2_target, useext(GL_PRIMARY_COLOR));
1354                 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_PRIMARY_COLOR");
1355                 glTexEnvi(GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA);
1356                 checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
1357                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1358                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1359                 break;
1360         case D3DTOP_BLENDTEXTUREALPHA:
1361                 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
1362                 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
1363                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1364                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1365                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1366                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1367                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1368                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1369                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1370                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1371                 glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_TEXTURE);
1372                 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_TEXTURE");
1373                 glTexEnvi(GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA);
1374                 checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
1375                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1376                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1377                 break;
1378         case D3DTOP_BLENDFACTORALPHA:
1379                 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
1380                 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
1381                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1382                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1383                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1384                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1385                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1386                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1387                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1388                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1389                 glTexEnvi(GL_TEXTURE_ENV, src2_target, useext(GL_CONSTANT));
1390                 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_CONSTANT");
1391                 glTexEnvi(GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA);
1392                 checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
1393                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1394                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1395                 break;
1396         case D3DTOP_BLENDCURRENTALPHA:
1397                 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
1398                 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
1399                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1400                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1401                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1402                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1403                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1404                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1405                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1406                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1407                 glTexEnvi(GL_TEXTURE_ENV, src2_target, useext(GL_PREVIOUS));
1408                 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_PREVIOUS");
1409                 glTexEnvi(GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA);
1410                 checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
1411                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1412                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1413                 break;
1414         case D3DTOP_DOTPRODUCT3:
1415                 if (GL_SUPPORT(ARB_TEXTURE_ENV_DOT3)) {
1416                   glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_ARB);
1417                   checkGLcall("GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_ARB");
1418                 } else if (GL_SUPPORT(EXT_TEXTURE_ENV_DOT3)) {
1419                   glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_EXT);
1420                   checkGLcall("GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_EXT");
1421                 } else {
1422                   FIXME("This version of opengl does not support GL_DOT3\n");
1423                 }
1424                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1425                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1426                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1427                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1428                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1429                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1430                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1431                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1432                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1433                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1434                 break;
1435         case D3DTOP_LERP:
1436                 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
1437                 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
1438                 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1439                 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1440                 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1441                 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1442                 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1443                 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1444                 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1445                 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1446                 glTexEnvi(GL_TEXTURE_ENV, src2_target, src3);
1447                 checkGLcall("GL_TEXTURE_ENV, src2_target, src3");
1448                 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr3);
1449                 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr3");
1450                 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1451                 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1452                 break;
1453         case D3DTOP_ADDSMOOTH:
1454                 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
1455                   glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
1456                   checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
1457                   glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1458                   checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1459                   switch (opr1) {
1460                   case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_COLOR; break;
1461                   case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_COLOR; break;
1462                   case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1463                   case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
1464                   }
1465                   glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
1466                   checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
1467                   glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
1468                   checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
1469                   glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
1470                   checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
1471                   glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1472                   checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1473                   glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1474                   checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1475                   glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1476                   checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1477                 } else
1478                   Handled = FALSE;
1479                 break;
1480         case D3DTOP_BLENDTEXTUREALPHAPM:
1481                 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
1482                   glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
1483                   checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
1484                   glTexEnvi(GL_TEXTURE_ENV, src0_target, GL_TEXTURE);
1485                   checkGLcall("GL_TEXTURE_ENV, src0_target, GL_TEXTURE");
1486                   glTexEnvi(GL_TEXTURE_ENV, opr0_target, GL_ONE_MINUS_SRC_ALPHA);
1487                   checkGLcall("GL_TEXTURE_ENV, opr0_target, GL_ONE_MINUS_SRC_APHA");
1488                   glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
1489                   checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
1490                   glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
1491                   checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
1492                   glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1493                   checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1494                   glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1495                   checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1496                   glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1497                   checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1498                 } else
1499                   Handled = FALSE;
1500                 break;
1501         case D3DTOP_MODULATEALPHA_ADDCOLOR:
1502                 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
1503                   glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
1504                   checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
1505                   glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1506                   checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1507                   switch (opr1) {
1508                   case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
1509                   case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1510                   case GL_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
1511                   case GL_ONE_MINUS_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1512                   }
1513                   glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
1514                   checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
1515                   glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
1516                   checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
1517                   glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
1518                   checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
1519                   glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1520                   checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1521                   glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1522                   checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1523                   glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1524                   checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1525                 } else
1526                   Handled = FALSE;
1527                 break;
1528         case D3DTOP_MODULATECOLOR_ADDALPHA:
1529                 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
1530                   glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
1531                   checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
1532                   glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1533                   checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1534                   glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1535                   checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1536                   glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
1537                   checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
1538                   switch (opr1) {
1539                   case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
1540                   case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1541                   case GL_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
1542                   case GL_ONE_MINUS_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1543                   }
1544                   glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr);
1545                   checkGLcall("GL_TEXTURE_ENV, opr1_target, opr");
1546                   glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1547                   checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1548                   glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1549                   checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1550                   glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1551                   checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1552                 } else
1553                   Handled = FALSE;
1554                 break;
1555         case D3DTOP_MODULATEINVALPHA_ADDCOLOR:
1556                 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
1557                   glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
1558                   checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
1559                   glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1560                   checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1561                   switch (opr1) {
1562                   case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1563                   case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_ALPHA; break;
1564                   case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1565                   case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
1566                   }
1567                   glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
1568                   checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
1569                   glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
1570                   checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
1571                   glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
1572                   checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
1573                   glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1574                   checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1575                   glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1576                   checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1577                   glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1578                   checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1579                 } else
1580                   Handled = FALSE;
1581                 break;
1582         case D3DTOP_MODULATEINVCOLOR_ADDALPHA:
1583                 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
1584                   glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
1585                   checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
1586                   glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1587                   checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1588                   switch (opr1) {
1589                   case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_COLOR; break;
1590                   case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_COLOR; break;
1591                   case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1592                   case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
1593                   }
1594                   glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
1595                   checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
1596                   glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
1597                   checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
1598                   switch (opr1) {
1599                   case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
1600                   case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1601                   case GL_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
1602                   case GL_ONE_MINUS_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1603                   }
1604                   glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr);
1605                   checkGLcall("GL_TEXTURE_ENV, opr1_target, opr");
1606                   glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1607                   checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1608                   glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1609                   checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1610                   glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1611                   checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1612                 } else
1613                   Handled = FALSE;
1614                 break;
1615         case D3DTOP_MULTIPLYADD:
1616                 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
1617                   glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
1618                   checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
1619                   glTexEnvi(GL_TEXTURE_ENV, src0_target, src3);
1620                   checkGLcall("GL_TEXTURE_ENV, src0_target, src3");
1621                   glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr3);
1622                   checkGLcall("GL_TEXTURE_ENV, opr0_target, opr3");
1623                   glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
1624                   checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
1625                   glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
1626                   checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
1627                   glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1628                   checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1629                   glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1630                   checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1631                   glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1632                   checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1633                 } else
1634                   Handled = FALSE;
1635                 break;
1636         default:
1637                 Handled = FALSE;
1638         }
1639
1640         if (Handled) {
1641           BOOL  combineOK = TRUE;
1642           if (GL_SUPPORT(NV_TEXTURE_ENV_COMBINE4)) {
1643             DWORD op2;
1644
1645             if (isAlpha) {
1646               op2 = This->stateBlock->textureState[Stage][WINED3DTSS_COLOROP];
1647             } else {
1648               op2 = This->stateBlock->textureState[Stage][WINED3DTSS_ALPHAOP];
1649             }
1650
1651             /* Note: If COMBINE4 in effect can't go back to combine! */
1652             switch (op2) {
1653             case D3DTOP_ADDSMOOTH:
1654             case D3DTOP_BLENDTEXTUREALPHAPM:
1655             case D3DTOP_MODULATEALPHA_ADDCOLOR:
1656             case D3DTOP_MODULATECOLOR_ADDALPHA:
1657             case D3DTOP_MODULATEINVALPHA_ADDCOLOR:
1658             case D3DTOP_MODULATEINVCOLOR_ADDALPHA:
1659             case D3DTOP_MULTIPLYADD:
1660               /* Ignore those implemented in both cases */
1661               switch (op) {
1662               case D3DTOP_SELECTARG1:
1663               case D3DTOP_SELECTARG2:
1664                 combineOK = FALSE;
1665                 Handled   = FALSE;
1666                 break;
1667               default:
1668                 FIXME("Can't use COMBINE4 and COMBINE together, thisop=%d, otherop=%ld, isAlpha(%d)\n", op, op2, isAlpha);
1669                 LEAVE_GL();
1670                 return;
1671               }
1672             }
1673           }
1674
1675           if (combineOK) {
1676             glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, useext(GL_COMBINE));
1677             checkGLcall("GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, useext(GL_COMBINE)");
1678
1679             LEAVE_GL();
1680             return;
1681           }
1682         }
1683
1684         LEAVE_GL();
1685
1686         /* After all the extensions, if still unhandled, report fixme */
1687         FIXME("Unhandled texture operation %d\n", op);
1688         #undef GLINFO_LOCATION
1689 }
1690 #endif
1691
1692 /* Setup this textures matrix according to the texture flags*/
1693 void set_texture_matrix(const float *smat, DWORD flags, BOOL calculatedCoords)
1694 {
1695     float mat[16];
1696
1697     glMatrixMode(GL_TEXTURE);
1698     checkGLcall("glMatrixMode(GL_TEXTURE)");
1699
1700     if (flags == D3DTTFF_DISABLE) {
1701         glLoadIdentity();
1702         checkGLcall("glLoadIdentity()");
1703         return;
1704     }
1705
1706     if (flags == (D3DTTFF_COUNT1|D3DTTFF_PROJECTED)) {
1707         ERR("Invalid texture transform flags: D3DTTFF_COUNT1|D3DTTFF_PROJECTED\n");
1708         return;
1709     }
1710
1711     memcpy(mat, smat, 16 * sizeof(float));
1712
1713     switch (flags & ~D3DTTFF_PROJECTED) {
1714     case D3DTTFF_COUNT1: mat[1] = mat[5] = mat[13] = 0;
1715     case D3DTTFF_COUNT2: mat[2] = mat[6] = mat[10] = mat[14] = 0;
1716     default: mat[3] = mat[7] = mat[11] = 0, mat[15] = 1;
1717     }
1718
1719     if (flags & D3DTTFF_PROJECTED) {
1720         switch (flags & ~D3DTTFF_PROJECTED) {
1721         case D3DTTFF_COUNT2:
1722             mat[3] = mat[1], mat[7] = mat[5], mat[11] = mat[9], mat[15] = mat[13];
1723             mat[1] = mat[5] = mat[9] = mat[13] = 0;
1724             break;
1725         case D3DTTFF_COUNT3:
1726             mat[3] = mat[2], mat[7] = mat[6], mat[11] = mat[10], mat[15] = mat[14];
1727             mat[2] = mat[6] = mat[10] = mat[14] = 0;
1728             break;
1729         }
1730     } else if(!calculatedCoords) { /* under directx the R/Z coord can be used for translation, under opengl we use the Q coord instead */
1731         mat[12] = mat[8];
1732         mat[13] = mat[9];
1733     }
1734
1735     glLoadMatrixf(mat);
1736     checkGLcall("glLoadMatrixf(mat)");
1737 }
1738
1739 #define GLINFO_LOCATION ((IWineD3DImpl *)(This->wineD3D))->gl_info
1740
1741 /* Convertes a D3D format into a OpenGL configuration format */
1742 int D3DFmtMakeGlCfg(D3DFORMAT BackBufferFormat, D3DFORMAT StencilBufferFormat, int *attribs, int* nAttribs, BOOL alternate){
1743 #define PUSH1(att)        attribs[(*nAttribs)++] = (att);
1744 #define PUSH2(att,value)  attribs[(*nAttribs)++] = (att); attribs[(*nAttribs)++] = (value);
1745     /*We need to do some Card specific stuff in here at some point,
1746     D3D now supports floating point format buffers, and there are a number of different OpelGl ways of managing these e.g.
1747     GLX_ATI_pixel_format_float
1748     */
1749     switch (BackBufferFormat) {
1750         /* color buffer */
1751     case WINED3DFMT_P8:
1752         PUSH2(GLX_RENDER_TYPE,  GLX_COLOR_INDEX_BIT);
1753         PUSH2(GLX_BUFFER_SIZE,  8);
1754         PUSH2(GLX_DOUBLEBUFFER, TRUE);
1755         break;
1756
1757     case WINED3DFMT_R3G3B2:
1758         PUSH2(GLX_RENDER_TYPE,  GLX_RGBA_BIT);
1759         PUSH2(GLX_RED_SIZE,     3);
1760         PUSH2(GLX_GREEN_SIZE,   3);
1761         PUSH2(GLX_BLUE_SIZE,    2);
1762         break;
1763
1764     case WINED3DFMT_A1R5G5B5:
1765         PUSH2(GLX_ALPHA_SIZE,   1);
1766     case WINED3DFMT_X1R5G5B5:
1767         PUSH2(GLX_RED_SIZE,     5);
1768         PUSH2(GLX_GREEN_SIZE,   5);
1769         PUSH2(GLX_BLUE_SIZE,    5);
1770         break;
1771
1772     case WINED3DFMT_R5G6B5:
1773         PUSH2(GLX_RED_SIZE,     5);
1774         PUSH2(GLX_GREEN_SIZE,   6);
1775         PUSH2(GLX_BLUE_SIZE,    5);
1776         break;
1777
1778     case WINED3DFMT_A4R4G4B4:
1779         PUSH2(GLX_ALPHA_SIZE,   4);
1780     case WINED3DFMT_X4R4G4B4:
1781         PUSH2(GLX_RED_SIZE,     4);
1782         PUSH2(GLX_GREEN_SIZE,   4);
1783         PUSH2(GLX_BLUE_SIZE,    4);
1784         break;
1785
1786     case WINED3DFMT_A8R8G8B8:
1787         PUSH2(GLX_ALPHA_SIZE,   8);
1788     case WINED3DFMT_R8G8B8:
1789     case WINED3DFMT_X8R8G8B8:
1790         PUSH2(GLX_RED_SIZE,     8);
1791         PUSH2(GLX_GREEN_SIZE,   8);
1792         PUSH2(GLX_BLUE_SIZE,    8);
1793         break;
1794
1795     case WINED3DFMT_A2R10G10B10:
1796         PUSH2(GLX_ALPHA_SIZE,   2);
1797         PUSH2(GLX_RED_SIZE,    10);
1798         PUSH2(GLX_GREEN_SIZE,  10);
1799         PUSH2(GLX_BLUE_SIZE,   10);
1800         break;
1801
1802     case WINED3DFMT_A16B16G16R16:
1803         PUSH2(GLX_ALPHA_SIZE,  16);
1804         PUSH2(GLX_RED_SIZE,    16);
1805         PUSH2(GLX_GREEN_SIZE,  16);
1806         PUSH2(GLX_BLUE_SIZE,   16);
1807         break;
1808
1809     default:
1810         FIXME("Unsupported color format: %s\n", debug_d3dformat(BackBufferFormat));
1811         break;
1812     }
1813     if(!alternate){
1814         switch (StencilBufferFormat) {
1815     case 0:
1816         break;
1817
1818     case WINED3DFMT_D16_LOCKABLE:
1819     case WINED3DFMT_D16:
1820         PUSH2(GLX_DEPTH_SIZE,   16);
1821         break;
1822
1823     case WINED3DFMT_D15S1:
1824         PUSH2(GLX_DEPTH_SIZE,   15);
1825         PUSH2(GLX_STENCIL_SIZE, 1);
1826         /*Does openGl support a 1bit stencil?, I've seen it used elsewhere
1827         e.g. http://www.ks.uiuc.edu/Research/vmd/doxygen/OpenGLDisplayDevice_8C-source.html*/
1828         break;
1829
1830     case WINED3DFMT_D24X8:
1831         PUSH2(GLX_DEPTH_SIZE,   24);
1832         break;
1833
1834     case WINED3DFMT_D24X4S4:
1835         PUSH2(GLX_DEPTH_SIZE,   24);
1836         PUSH2(GLX_STENCIL_SIZE, 4);
1837         break;
1838
1839     case WINED3DFMT_D24S8:
1840         PUSH2(GLX_DEPTH_SIZE,   24);
1841         PUSH2(GLX_STENCIL_SIZE, 8);
1842         break;
1843
1844     case WINED3DFMT_D24FS8:
1845         PUSH2(GLX_DEPTH_SIZE,   24);
1846         PUSH2(GLX_STENCIL_SIZE, 8);
1847         break;
1848
1849     case WINED3DFMT_D32:
1850         PUSH2(GLX_DEPTH_SIZE,   32);
1851         break;
1852
1853     default:
1854         FIXME("Unsupported stencil format: %s\n", debug_d3dformat(StencilBufferFormat));
1855         break;
1856     }
1857
1858     } else { /* it the device doesn't support the 'exact' format, try to find something close */
1859         switch (StencilBufferFormat) {
1860         case 0:
1861             break;
1862
1863         case WINED3DFMT_D16_LOCKABLE:
1864         case WINED3DFMT_D16:
1865             PUSH2(GLX_DEPTH_SIZE,   1);
1866             break;
1867
1868         case WINED3DFMT_D15S1:
1869             PUSH2(GLX_DEPTH_SIZE,   1);
1870             PUSH2(GLX_STENCIL_SIZE, 1);
1871             /*Does openGl support a 1bit stencil?, I've seen it used elsewhere
1872             e.g. http://www.ks.uiuc.edu/Research/vmd/doxygen/OpenGLDisplayDevice_8C-source.html*/
1873             break;
1874
1875         case WINED3DFMT_D24X8:
1876             PUSH2(GLX_DEPTH_SIZE,   1);
1877             break;
1878
1879         case WINED3DFMT_D24X4S4:
1880             PUSH2(GLX_DEPTH_SIZE,   1);
1881             PUSH2(GLX_STENCIL_SIZE, 1);
1882             break;
1883
1884         case WINED3DFMT_D24S8:
1885             PUSH2(GLX_DEPTH_SIZE,   1);
1886             PUSH2(GLX_STENCIL_SIZE, 1);
1887             break;
1888
1889         case WINED3DFMT_D24FS8:
1890             PUSH2(GLX_DEPTH_SIZE,   1);
1891             PUSH2(GLX_STENCIL_SIZE, 1);
1892             break;
1893
1894         case WINED3DFMT_D32:
1895             PUSH2(GLX_DEPTH_SIZE,   1);
1896             break;
1897
1898         default:
1899             FIXME("Unsupported stencil format: %s\n", debug_d3dformat(StencilBufferFormat));
1900             break;
1901         }
1902     }
1903
1904     return *nAttribs;
1905 }
1906
1907 #undef GLINFO_LOCATION
1908
1909 /* DirectDraw stuff */
1910 WINED3DFORMAT pixelformat_for_depth(DWORD depth) {
1911     switch(depth) {
1912         case 8:  return D3DFMT_P8; break;
1913         case 15: return WINED3DFMT_X1R5G5B5; break;
1914         case 16: return WINED3DFMT_R5G6B5; break;
1915         case 24: return WINED3DFMT_R8G8B8; break;
1916         case 32: return WINED3DFMT_X8R8G8B8; break;
1917         default: return WINED3DFMT_UNKNOWN;
1918     }
1919 }
1920
1921 void multiply_matrix(D3DMATRIX *dest, D3DMATRIX *src1, D3DMATRIX *src2) {
1922     D3DMATRIX temp;
1923
1924     /* Now do the multiplication 'by hand'.
1925        I know that all this could be optimised, but this will be done later :-) */
1926     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);
1927     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);
1928     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);
1929     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);
1930
1931     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);
1932     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);
1933     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);
1934     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);
1935
1936     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);
1937     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);
1938     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);
1939     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);
1940
1941     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);
1942     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);
1943     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);
1944     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);
1945
1946     /* And copy the new matrix in the good storage.. */
1947     memcpy(dest, &temp, 16 * sizeof(float));
1948 }
1949
1950 DWORD get_flexible_vertex_size(DWORD d3dvtVertexType) {
1951     DWORD size = 0;
1952     int i;
1953     int numTextures = (d3dvtVertexType & D3DFVF_TEXCOUNT_MASK) >> D3DFVF_TEXCOUNT_SHIFT;
1954
1955     if (d3dvtVertexType & D3DFVF_NORMAL) size += 3 * sizeof(float);
1956     if (d3dvtVertexType & D3DFVF_DIFFUSE) size += sizeof(DWORD);
1957     if (d3dvtVertexType & D3DFVF_SPECULAR) size += sizeof(DWORD);
1958     if (d3dvtVertexType & D3DFVF_PSIZE) size += sizeof(DWORD);
1959     switch (d3dvtVertexType & D3DFVF_POSITION_MASK) {
1960         case D3DFVF_XYZ: size += 3 * sizeof(float); break;
1961         case D3DFVF_XYZRHW: size += 4 * sizeof(float); break;
1962         default: TRACE(" matrix weighting not handled yet...\n");
1963     }
1964     for (i = 0; i < numTextures; i++) {
1965         size += GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType, i) * sizeof(float);
1966     }
1967
1968     return size;
1969 }
1970
1971 /***********************************************************************
1972  * CalculateTexRect
1973  *
1974  * Calculates the dimensions of the opengl texture used for blits.
1975  * Handled oversized opengl textures and updates the source rectangle
1976  * accordingly
1977  *
1978  * Params:
1979  *  This: Surface to operate on
1980  *  Rect: Requested rectangle
1981  *
1982  * Returns:
1983  *  TRUE if the texture part can be loaded,
1984  *  FALSE otherwise
1985  *
1986  *********************************************************************/
1987 #define GLINFO_LOCATION ((IWineD3DImpl *)(This->resource.wineD3DDevice->wineD3D))->gl_info
1988
1989 BOOL CalculateTexRect(IWineD3DSurfaceImpl *This, RECT *Rect, float glTexCoord[4]) {
1990     int x1 = Rect->left, x2 = Rect->right;
1991     int y1 = Rect->top, y2 = Rect->bottom;
1992     GLint maxSize = GL_LIMITS(texture_size);
1993
1994     TRACE("(%p)->(%ld,%ld)-(%ld,%ld)\n", This,
1995           Rect->left, Rect->top, Rect->right, Rect->bottom);
1996
1997     /* The sizes might be reversed */
1998     if(Rect->left > Rect->right) {
1999         x1 = Rect->right;
2000         x2 = Rect->left;
2001     }
2002     if(Rect->top > Rect->bottom) {
2003         y1 = Rect->bottom;
2004         y2 = Rect->top;
2005     }
2006
2007     /* No oversized texture? This is easy */
2008     if(!(This->Flags & SFLAG_OVERSIZE)) {
2009         /* Which rect from the texture do I need? */
2010         glTexCoord[0] = (float) Rect->left / (float) This->pow2Width;
2011         glTexCoord[2] = (float) Rect->top / (float) This->pow2Height;
2012         glTexCoord[1] = (float) Rect->right / (float) This->pow2Width;
2013         glTexCoord[3] = (float) Rect->bottom / (float) This->pow2Height;
2014
2015         return TRUE;
2016     } else {
2017         /* Check if we can succeed at all */
2018         if( (x2 - x1) > maxSize ||
2019             (y2 - y1) > maxSize ) {
2020             TRACE("Requested rectangle is too large for gl\n");
2021             return FALSE;
2022         }
2023
2024         /* A part of the texture has to be picked. First, check if
2025          * some texture part is loaded already, if yes try to re-use it.
2026          * If the texture is dirty, or the part can't be used,
2027          * re-position the part to load
2028          */
2029         if(!(This->Flags & SFLAG_DIRTY)) {
2030             if(This->glRect.left <= x1 && This->glRect.right >= x2 &&
2031                This->glRect.top <= y1 && This->glRect.bottom >= x2 ) {
2032                 /* Ok, the rectangle is ok, re-use it */
2033                 TRACE("Using existing gl Texture\n");
2034             } else {
2035                 /* Rectangle is not ok, dirtify the texture to reload it */
2036                 TRACE("Dirtifying texture to force reload\n");
2037                 This->Flags |= SFLAG_DIRTY;
2038             }
2039         }
2040
2041         /* Now if we are dirty(no else if!) */
2042         if(This->Flags & SFLAG_DIRTY) {
2043             /* Set the new rectangle. Use the following strategy:
2044              * 1) Use as big textures as possible.
2045              * 2) Place the texture part in the way that the requested
2046              *    part is in the middle of the texture(well, almost)
2047              * 3) If the texture is moved over the edges of the
2048              *    surface, replace it nicely
2049              * 4) If the coord is not limiting the texture size,
2050              *    use the whole size
2051              */
2052             if((This->pow2Width) > maxSize) {
2053                 This->glRect.left = x1 - maxSize / 2;
2054                 if(This->glRect.left < 0) {
2055                     This->glRect.left = 0;
2056                 }
2057                 This->glRect.right = This->glRect.left + maxSize;
2058                 if(This->glRect.right > This->currentDesc.Width) {
2059                     This->glRect.right = This->currentDesc.Width;
2060                     This->glRect.left = This->glRect.right - maxSize;
2061                 }
2062             } else {
2063                 This->glRect.left = 0;
2064                 This->glRect.right = This->pow2Width;
2065             }
2066
2067             if(This->pow2Height > maxSize) {
2068                 This->glRect.top = x1 - GL_LIMITS(texture_size) / 2;
2069                 if(This->glRect.top < 0) This->glRect.top = 0;
2070                 This->glRect.bottom = This->glRect.left + maxSize;
2071                 if(This->glRect.bottom > This->currentDesc.Height) {
2072                     This->glRect.bottom = This->currentDesc.Height;
2073                     This->glRect.top = This->glRect.bottom - maxSize;
2074                 }
2075             } else {
2076                 This->glRect.top = 0;
2077                 This->glRect.bottom = This->pow2Height;
2078             }
2079             TRACE("(%p): Using rect (%ld,%ld)-(%ld,%ld)\n", This,
2080                    This->glRect.left, This->glRect.top, This->glRect.right, This->glRect.bottom);
2081         }
2082
2083         /* Re-calculate the rect to draw */
2084         Rect->left -= This->glRect.left;
2085         Rect->right -= This->glRect.left;
2086         Rect->top -= This->glRect.top;
2087         Rect->bottom -= This->glRect.top;
2088
2089         /* Get the gl coordinates. The gl rectangle is a power of 2, eigher the max size,
2090          * or the pow2Width / pow2Height of the surface
2091          */
2092         glTexCoord[0] = (float) Rect->left / (float) (This->glRect.right - This->glRect.left);
2093         glTexCoord[2] = (float) Rect->top / (float) (This->glRect.bottom - This->glRect.top);
2094         glTexCoord[1] = (float) Rect->right / (float) (This->glRect.right - This->glRect.left);
2095         glTexCoord[3] = (float) Rect->bottom / (float) (This->glRect.bottom - This->glRect.top);
2096     }
2097     return TRUE;
2098 }
2099 #undef GLINFO_LOCATION