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