dlls/wined3d/baseshader.c

   1 /*
   2  * shaders implementation
   3  *
   4  * Copyright 2002-2003 Jason Edmeades
   5  * Copyright 2002-2003 Raphael Junqueira
   6  * Copyright 2004 Christian Costa
   7  * Copyright 2005 Oliver Stieber
   8  * Copyright 2006 Ivan Gyurdiev
   9  * Copyright 2007-2008 Stefan Dösinger for CodeWeavers
  10  *
  11  * This library is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Lesser General Public
  13  * License as published by the Free Software Foundation; either
  14  * version 2.1 of the License, or (at your option) any later version.
  15  *
  16  * This library is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public
  22  * License along with this library; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  24  */
  25
  26 #include "config.h"
  27 #include <string.h>
  28 #include <stdio.h>
  29 #include "wined3d_private.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
  32 WINE_DECLARE_DEBUG_CHANNEL(d3d);
  33
  34 #define GLNAME_REQUIRE_GLSL  ((const char *)1)
  35
  36 static void shader_dump_param(const DWORD param, const DWORD addr_token, int input, DWORD shader_version);
  37
  38 static inline BOOL shader_is_version_token(DWORD token) {
  39     return shader_is_pshader_version(token) ||
  40            shader_is_vshader_version(token);
  41 }
  42
  43 void shader_buffer_init(struct SHADER_BUFFER *buffer)
  44 {
  45     buffer->buffer = HeapAlloc(GetProcessHeap(), 0, SHADER_PGMSIZE);
  46     buffer->buffer[0] = '\0';
  47     buffer->bsize = 0;
  48     buffer->lineNo = 0;
  49     buffer->newline = TRUE;
  50 }
  51
  52 void shader_buffer_free(struct SHADER_BUFFER *buffer)
  53 {
  54     HeapFree(GetProcessHeap(), 0, buffer->buffer);
  55 }
  56
  57 int shader_addline(
  58     SHADER_BUFFER* buffer,
  59     const char *format, ...) {
  60
  61     char* base = buffer->buffer + buffer->bsize;
  62     int rc;
  63
  64     va_list args;
  65     va_start(args, format);
  66     rc = vsnprintf(base, SHADER_PGMSIZE - 1 - buffer->bsize, format, args);
  67     va_end(args);
  68
  69     if (rc < 0 ||                                   /* C89 */
  70         rc > SHADER_PGMSIZE - 1 - buffer->bsize) {  /* C99 */
  71
  72         ERR("The buffer allocated for the shader program string "
  73             "is too small at %d bytes.\n", SHADER_PGMSIZE);
  74         buffer->bsize = SHADER_PGMSIZE - 1;
  75         return -1;
  76     }
  77
  78     if (buffer->newline) {
  79         TRACE("GL HW (%u, %u) : %s", buffer->lineNo + 1, buffer->bsize, base);
  80         buffer->newline = FALSE;
  81     } else {
  82         TRACE("%s", base);
  83     }
  84
  85     buffer->bsize += rc;
  86     if (buffer->buffer[buffer->bsize-1] == '\n') {
  87         buffer->lineNo++;
  88         buffer->newline = TRUE;
  89     }
  90     return 0;
  91 }
  92
  93 const SHADER_OPCODE *shader_get_opcode(const SHADER_OPCODE *opcode_table, DWORD shader_version, DWORD code)
  94 {
  95     DWORD i = 0;
  96
  97     /** TODO: use dichotomic search */
  98     while (opcode_table[i].name)
  99     {
 100         if ((code & WINED3DSI_OPCODE_MASK) == opcode_table[i].opcode
 101                 && shader_version >= opcode_table[i].min_version
 102                 && (!opcode_table[i].max_version || shader_version <= opcode_table[i].max_version))
 103         {
 104             return &opcode_table[i];
 105         }
 106         ++i;
 107     }
 108
 109     FIXME("Unsupported opcode %#x(%d) masked %#x, shader version %#x\n",
 110             code, code, code & WINED3DSI_OPCODE_MASK, shader_version);
 111
 112     return NULL;
 113 }
 114
 115 /* Read a parameter opcode from the input stream,
 116  * and possibly a relative addressing token.
 117  * Return the number of tokens read */
 118 static int shader_get_param(const DWORD *pToken, DWORD shader_version, DWORD *param, DWORD *addr_token)
 119 {
 120     /* PS >= 3.0 have relative addressing (with token)
 121      * VS >= 2.0 have relative addressing (with token)
 122      * VS >= 1.0 < 2.0 have relative addressing (without token)
 123      * The version check below should work in general */
 124
 125     char rel_token = WINED3DSHADER_VERSION_MAJOR(shader_version) >= 2 &&
 126         ((*pToken & WINED3DSHADER_ADDRESSMODE_MASK) == WINED3DSHADER_ADDRMODE_RELATIVE);
 127
 128     *param = *pToken;
 129     *addr_token = rel_token? *(pToken + 1): 0;
 130     return rel_token? 2:1;
 131 }
 132
 133 /* Return the number of parameters to skip for an opcode */
 134 static inline int shader_skip_opcode(const SHADER_OPCODE *curOpcode, DWORD opcode_token, DWORD shader_version)
 135 {
 136    /* Shaders >= 2.0 may contain address tokens, but fortunately they
 137     * have a useful length mask - use it here. Shaders 1.0 contain no such tokens */
 138     return (WINED3DSHADER_VERSION_MAJOR(shader_version) >= 2)
 139             ? ((opcode_token & WINED3DSI_INSTLENGTH_MASK) >> WINED3DSI_INSTLENGTH_SHIFT) : curOpcode->num_params;
 140 }
 141
 142 /* Read the parameters of an unrecognized opcode from the input stream
 143  * Return the number of tokens read.
 144  *
 145  * Note: This function assumes source or destination token format.
 146  * It will not work with specially-formatted tokens like DEF or DCL,
 147  * but hopefully those would be recognized */
 148 static int shader_skip_unrecognized(const DWORD *pToken, DWORD shader_version)
 149 {
 150     int tokens_read = 0;
 151     int i = 0;
 152
 153     /* TODO: Think of a good name for 0x80000000 and replace it with a constant */
 154     while (*pToken & 0x80000000) {
 155
 156         DWORD param, addr_token;
 157         tokens_read += shader_get_param(pToken, shader_version, &param, &addr_token);
 158         pToken += tokens_read;
 159
 160         FIXME("Unrecognized opcode param: token=0x%08x "
 161             "addr_token=0x%08x name=", param, addr_token);
 162         shader_dump_param(param, addr_token, i, shader_version);
 163         FIXME("\n");
 164         ++i;
 165     }
 166     return tokens_read;
 167 }
 168
 169 /* Convert floating point offset relative
 170  * to a register file to an absolute offset for float constants */
 171 static unsigned int shader_get_float_offset(const DWORD reg)
 172 {
 173      unsigned int regnum = reg & WINED3DSP_REGNUM_MASK;
 174      int regtype = shader_get_regtype(reg);
 175
 176      switch (regtype) {
 177         case WINED3DSPR_CONST: return regnum;
 178         case WINED3DSPR_CONST2: return 2048 + regnum;
 179         case WINED3DSPR_CONST3: return 4096 + regnum;
 180         case WINED3DSPR_CONST4: return 6144 + regnum;
 181         default:
 182             FIXME("Unsupported register type: %d\n", regtype);
 183             return regnum;
 184      }
 185 }
 186
 187 static void shader_delete_constant_list(struct list* clist) {
 188
 189     struct list *ptr;
 190     struct local_constant* constant;
 191
 192     ptr = list_head(clist);
 193     while (ptr) {
 194         constant = LIST_ENTRY(ptr, struct local_constant, entry);
 195         ptr = list_next(clist, ptr);
 196         HeapFree(GetProcessHeap(), 0, constant);
 197     }
 198     list_init(clist);
 199 }
 200
 201 /* Note that this does not count the loop register
 202  * as an address register. */
 203
 204 HRESULT shader_get_registers_used(IWineD3DBaseShader *iface, struct shader_reg_maps *reg_maps,
 205         struct semantic *semantics_in, struct semantic *semantics_out, const DWORD *byte_code)
 206 {
 207     IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
 208     const SHADER_OPCODE *shader_ins = This->baseShader.shader_ins;
 209     DWORD shader_version;
 210     unsigned int cur_loop_depth = 0, max_loop_depth = 0;
 211     const DWORD* pToken = byte_code;
 212     char pshader;
 213
 214     /* There are some minor differences between pixel and vertex shaders */
 215
 216     memset(reg_maps->bumpmat, 0, sizeof(reg_maps->bumpmat));
 217     memset(reg_maps->luminanceparams, 0, sizeof(reg_maps->luminanceparams));
 218
 219     /* get_registers_used is called on every compile on some 1.x shaders, which can result
 220      * in stacking up a collection of local constants. Delete the old constants if existing
 221      */
 222     shader_delete_constant_list(&This->baseShader.constantsF);
 223     shader_delete_constant_list(&This->baseShader.constantsB);
 224     shader_delete_constant_list(&This->baseShader.constantsI);
 225
 226     /* The version token is supposed to be the first token */
 227     if (!shader_is_version_token(*pToken))
 228     {
 229         FIXME("First token is not a version token, invalid shader.\n");
 230         return WINED3DERR_INVALIDCALL;
 231     }
 232     reg_maps->shader_version = shader_version = *pToken++;
 233     pshader = shader_is_pshader_version(shader_version);
 234
 235     while (WINED3DVS_END() != *pToken) {
 236         CONST SHADER_OPCODE* curOpcode;
 237         DWORD opcode_token;
 238
 239         /* Skip comments */
 240         if (shader_is_comment(*pToken))
 241         {
 242              DWORD comment_len = (*pToken & WINED3DSI_COMMENTSIZE_MASK) >> WINED3DSI_COMMENTSIZE_SHIFT;
 243              ++pToken;
 244              pToken += comment_len;
 245              continue;
 246         }
 247
 248         /* Fetch opcode */
 249         opcode_token = *pToken++;
 250         curOpcode = shader_get_opcode(shader_ins, shader_version, opcode_token);
 251
 252         /* Unhandled opcode, and its parameters */
 253         if (NULL == curOpcode) {
 254            while (*pToken & 0x80000000)
 255                ++pToken;
 256
 257         /* Handle declarations */
 258         } else if (WINED3DSIO_DCL == curOpcode->opcode) {
 259
 260             DWORD usage = *pToken++;
 261             DWORD param = *pToken++;
 262             DWORD regtype = shader_get_regtype(param);
 263             unsigned int regnum = param & WINED3DSP_REGNUM_MASK;
 264
 265             /* Vshader: mark attributes used
 266                Pshader: mark 3.0 input registers used, save token */
 267             if (WINED3DSPR_INPUT == regtype) {
 268
 269                 if (!pshader)
 270                     reg_maps->attributes[regnum] = 1;
 271                 else
 272                     reg_maps->packed_input[regnum] = 1;
 273
 274                 semantics_in[regnum].usage = usage;
 275                 semantics_in[regnum].reg = param;
 276
 277             /* Vshader: mark 3.0 output registers used, save token */
 278             } else if (WINED3DSPR_OUTPUT == regtype) {
 279                 reg_maps->packed_output[regnum] = 1;
 280                 semantics_out[regnum].usage = usage;
 281                 semantics_out[regnum].reg = param;
 282                 if (usage & (WINED3DDECLUSAGE_FOG << WINED3DSP_DCL_USAGE_SHIFT))
 283                     reg_maps->fog = 1;
 284
 285             /* Save sampler usage token */
 286             } else if (WINED3DSPR_SAMPLER == regtype)
 287                 reg_maps->samplers[regnum] = usage;
 288
 289         } else if (WINED3DSIO_DEF == curOpcode->opcode) {
 290
 291             local_constant* lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant));
 292             if (!lconst) return E_OUTOFMEMORY;
 293             lconst->idx = *pToken & WINED3DSP_REGNUM_MASK;
 294             memcpy(lconst->value, pToken + 1, 4 * sizeof(DWORD));
 295
 296             /* In pixel shader 1.X shaders, the constants are clamped between [-1;1] */
 297             if (WINED3DSHADER_VERSION_MAJOR(shader_version) == 1 && pshader)
 298             {
 299                 float *value = (float *) lconst->value;
 300                 if(value[0] < -1.0) value[0] = -1.0;
 301                 else if(value[0] >  1.0) value[0] =  1.0;
 302                 if(value[1] < -1.0) value[1] = -1.0;
 303                 else if(value[1] >  1.0) value[1] =  1.0;
 304                 if(value[2] < -1.0) value[2] = -1.0;
 305                 else if(value[2] >  1.0) value[2] =  1.0;
 306                 if(value[3] < -1.0) value[3] = -1.0;
 307                 else if(value[3] >  1.0) value[3] =  1.0;
 308             }
 309
 310             list_add_head(&This->baseShader.constantsF, &lconst->entry);
 311             pToken += curOpcode->num_params;
 312
 313         } else if (WINED3DSIO_DEFI == curOpcode->opcode) {
 314
 315             local_constant* lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant));
 316             if (!lconst) return E_OUTOFMEMORY;
 317             lconst->idx = *pToken & WINED3DSP_REGNUM_MASK;
 318             memcpy(lconst->value, pToken + 1, 4 * sizeof(DWORD));
 319             list_add_head(&This->baseShader.constantsI, &lconst->entry);
 320             pToken += curOpcode->num_params;
 321
 322         } else if (WINED3DSIO_DEFB == curOpcode->opcode) {
 323
 324             local_constant* lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant));
 325             if (!lconst) return E_OUTOFMEMORY;
 326             lconst->idx = *pToken & WINED3DSP_REGNUM_MASK;
 327             memcpy(lconst->value, pToken + 1, 1 * sizeof(DWORD));
 328             list_add_head(&This->baseShader.constantsB, &lconst->entry);
 329             pToken += curOpcode->num_params;
 330
 331         /* If there's a loop in the shader */
 332         } else if (WINED3DSIO_LOOP == curOpcode->opcode ||
 333                    WINED3DSIO_REP == curOpcode->opcode) {
 334             cur_loop_depth++;
 335             if(cur_loop_depth > max_loop_depth)
 336                 max_loop_depth = cur_loop_depth;
 337             pToken += curOpcode->num_params;
 338
 339             /* Rep and Loop always use an integer constant for the control parameters */
 340             This->baseShader.uses_int_consts = TRUE;
 341         } else if (WINED3DSIO_ENDLOOP == curOpcode->opcode ||
 342                    WINED3DSIO_ENDREP == curOpcode->opcode) {
 343             cur_loop_depth--;
 344
 345         /* For subroutine prototypes */
 346         } else if (WINED3DSIO_LABEL == curOpcode->opcode) {
 347
 348             DWORD snum = *pToken & WINED3DSP_REGNUM_MASK;
 349             reg_maps->labels[snum] = 1;
 350             pToken += curOpcode->num_params;
 351
 352         /* Set texture, address, temporary registers */
 353         } else {
 354             int i, limit;
 355
 356             /* Declare 1.X samplers implicitly, based on the destination reg. number */
 357             if (WINED3DSHADER_VERSION_MAJOR(shader_version) == 1
 358                     && pshader /* Filter different instructions with the same enum values in VS */
 359                     && (WINED3DSIO_TEX == curOpcode->opcode
 360                         || WINED3DSIO_TEXBEM == curOpcode->opcode
 361                         || WINED3DSIO_TEXBEML == curOpcode->opcode
 362                         || WINED3DSIO_TEXDP3TEX == curOpcode->opcode
 363                         || WINED3DSIO_TEXM3x2TEX == curOpcode->opcode
 364                         || WINED3DSIO_TEXM3x3SPEC == curOpcode->opcode
 365                         || WINED3DSIO_TEXM3x3TEX == curOpcode->opcode
 366                         || WINED3DSIO_TEXM3x3VSPEC == curOpcode->opcode
 367                         || WINED3DSIO_TEXREG2AR == curOpcode->opcode
 368                         || WINED3DSIO_TEXREG2GB == curOpcode->opcode
 369                         || WINED3DSIO_TEXREG2RGB == curOpcode->opcode))
 370             {
 371                 /* Fake sampler usage, only set reserved bit and ttype */
 372                 DWORD sampler_code = *pToken & WINED3DSP_REGNUM_MASK;
 373
 374                 TRACE("Setting fake 2D sampler for 1.x pixelshader\n");
 375                 reg_maps->samplers[sampler_code] = (0x1 << 31) | WINED3DSTT_2D;
 376
 377                 /* texbem is only valid with < 1.4 pixel shaders */
 378                 if(WINED3DSIO_TEXBEM  == curOpcode->opcode ||
 379                     WINED3DSIO_TEXBEML == curOpcode->opcode) {
 380                     reg_maps->bumpmat[sampler_code] = TRUE;
 381                     if(WINED3DSIO_TEXBEML == curOpcode->opcode) {
 382                         reg_maps->luminanceparams[sampler_code] = TRUE;
 383                     }
 384                 }
 385             }
 386             if(WINED3DSIO_NRM  == curOpcode->opcode) {
 387                 reg_maps->usesnrm = 1;
 388             } else if(WINED3DSIO_BEM == curOpcode->opcode && pshader) {
 389                 DWORD regnum = *pToken & WINED3DSP_REGNUM_MASK;
 390                 reg_maps->bumpmat[regnum] = TRUE;
 391             } else if(WINED3DSIO_DSY  == curOpcode->opcode) {
 392                 reg_maps->usesdsy = 1;
 393             }
 394
 395             /* This will loop over all the registers and try to
 396              * make a bitmask of the ones we're interested in.
 397              *
 398              * Relative addressing tokens are ignored, but that's
 399              * okay, since we'll catch any address registers when
 400              * they are initialized (required by spec) */
 401
 402             limit = (opcode_token & WINED3DSHADER_INSTRUCTION_PREDICATED)?
 403                 curOpcode->num_params + 1: curOpcode->num_params;
 404
 405             for (i = 0; i < limit; ++i) {
 406
 407                 DWORD param, addr_token, reg, regtype;
 408                 pToken += shader_get_param(pToken, shader_version, &param, &addr_token);
 409
 410                 regtype = shader_get_regtype(param);
 411                 reg = param & WINED3DSP_REGNUM_MASK;
 412
 413                 if (WINED3DSPR_TEXTURE == regtype) { /* vs: WINED3DSPR_ADDR */
 414
 415                     if (pshader)
 416                         reg_maps->texcoord[reg] = 1;
 417                     else
 418                         reg_maps->address[reg] = 1;
 419                 }
 420
 421                 else if (WINED3DSPR_TEMP == regtype)
 422                     reg_maps->temporary[reg] = 1;
 423
 424                 else if (WINED3DSPR_INPUT == regtype) {
 425                     if( !pshader)
 426                         reg_maps->attributes[reg] = 1;
 427                     else {
 428                         if(param & WINED3DSHADER_ADDRMODE_RELATIVE) {
 429                             /* If relative addressing is used, we must assume that all registers
 430                              * are used. Even if it is a construct like v3[aL], we can't assume
 431                              * that v0, v1 and v2 aren't read because aL can be negative
 432                              */
 433                             unsigned int i;
 434                             for(i = 0; i < MAX_REG_INPUT; i++) {
 435                                 ((IWineD3DPixelShaderImpl *) This)->input_reg_used[i] = TRUE;
 436                             }
 437                         } else {
 438                             ((IWineD3DPixelShaderImpl *) This)->input_reg_used[reg] = TRUE;
 439                         }
 440                     }
 441                 }
 442
 443                 else if (WINED3DSPR_RASTOUT == regtype && reg == 1)
 444                     reg_maps->fog = 1;
 445
 446                 else if (WINED3DSPR_MISCTYPE == regtype && reg == 0 && pshader)
 447                     reg_maps->vpos = 1;
 448
 449                 else if(WINED3DSPR_CONST == regtype) {
 450                     if(param & WINED3DSHADER_ADDRMODE_RELATIVE) {
 451                         if(!pshader) {
 452                             if(reg <= ((IWineD3DVertexShaderImpl *) This)->min_rel_offset) {
 453                                 ((IWineD3DVertexShaderImpl *) This)->min_rel_offset = reg;
 454                             } else if(reg >= ((IWineD3DVertexShaderImpl *) This)->max_rel_offset) {
 455                                 ((IWineD3DVertexShaderImpl *) This)->max_rel_offset = reg;
 456                             }
 457                         }
 458                         reg_maps->usesrelconstF = TRUE;
 459                     }
 460                 }
 461                 else if(WINED3DSPR_CONSTINT == regtype) {
 462                     This->baseShader.uses_int_consts = TRUE;
 463                 }
 464                 else if(WINED3DSPR_CONSTBOOL == regtype) {
 465                     This->baseShader.uses_bool_consts = TRUE;
 466                 }
 467
 468                 /* WINED3DSPR_TEXCRDOUT is the same as WINED3DSPR_OUTPUT. _OUTPUT can be > MAX_REG_TEXCRD and is used
 469                  * in >= 3.0 shaders. Filter 3.0 shaders to prevent overflows, and also filter pixel shaders because TECRDOUT
 470                  * isn't used in them, but future register types might cause issues
 471                  */
 472                 else if (WINED3DSPR_TEXCRDOUT == regtype && i == 0 /* Only look at writes */
 473                         && !pshader && WINED3DSHADER_VERSION_MAJOR(shader_version) < 3)
 474                 {
 475                     reg_maps->texcoord_mask[reg] |= shader_get_writemask(param);
 476                 }
 477             }
 478         }
 479     }
 480     ++pToken;
 481     reg_maps->loop_depth = max_loop_depth;
 482
 483     This->baseShader.functionLength = ((char *)pToken - (char *)byte_code);
 484
 485     return WINED3D_OK;
 486 }
 487
 488 static void shader_dump_decl_usage(DWORD decl, DWORD param, DWORD shader_version)
 489 {
 490     DWORD regtype = shader_get_regtype(param);
 491
 492     TRACE("dcl");
 493
 494     if (regtype == WINED3DSPR_SAMPLER) {
 495         DWORD ttype = decl & WINED3DSP_TEXTURETYPE_MASK;
 496
 497         switch (ttype) {
 498             case WINED3DSTT_2D: TRACE("_2d"); break;
 499             case WINED3DSTT_CUBE: TRACE("_cube"); break;
 500             case WINED3DSTT_VOLUME: TRACE("_volume"); break;
 501             default: TRACE("_unknown_ttype(0x%08x)", ttype);
 502        }
 503
 504     } else {
 505
 506         DWORD usage = decl & WINED3DSP_DCL_USAGE_MASK;
 507         DWORD idx = (decl & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
 508
 509         /* Pixel shaders 3.0 don't have usage semantics */
 510         if (shader_is_pshader_version(shader_version) && shader_version < WINED3DPS_VERSION(3,0))
 511             return;
 512         else
 513             TRACE("_");
 514
 515         switch(usage) {
 516         case WINED3DDECLUSAGE_POSITION:
 517             TRACE("position%d", idx);
 518             break;
 519         case WINED3DDECLUSAGE_BLENDINDICES:
 520             TRACE("blend");
 521             break;
 522         case WINED3DDECLUSAGE_BLENDWEIGHT:
 523             TRACE("weight");
 524             break;
 525         case WINED3DDECLUSAGE_NORMAL:
 526             TRACE("normal%d", idx);
 527             break;
 528         case WINED3DDECLUSAGE_PSIZE:
 529             TRACE("psize");
 530             break;
 531         case WINED3DDECLUSAGE_COLOR:
 532             if(idx == 0)  {
 533                 TRACE("color");
 534             } else {
 535                 TRACE("specular%d", (idx - 1));
 536             }
 537             break;
 538         case WINED3DDECLUSAGE_TEXCOORD:
 539             TRACE("texture%d", idx);
 540             break;
 541         case WINED3DDECLUSAGE_TANGENT:
 542             TRACE("tangent");
 543             break;
 544         case WINED3DDECLUSAGE_BINORMAL:
 545             TRACE("binormal");
 546             break;
 547         case WINED3DDECLUSAGE_TESSFACTOR:
 548             TRACE("tessfactor");
 549             break;
 550         case WINED3DDECLUSAGE_POSITIONT:
 551             TRACE("positionT%d", idx);
 552             break;
 553         case WINED3DDECLUSAGE_FOG:
 554             TRACE("fog");
 555             break;
 556         case WINED3DDECLUSAGE_DEPTH:
 557             TRACE("depth");
 558             break;
 559         case WINED3DDECLUSAGE_SAMPLE:
 560             TRACE("sample");
 561             break;
 562         default:
 563             FIXME("unknown_semantics(0x%08x)", usage);
 564         }
 565     }
 566 }
 567
 568 static void shader_dump_arr_entry(const DWORD param, const DWORD addr_token,
 569         unsigned int reg, int input, DWORD shader_version)
 570 {
 571     char relative =
 572         ((param & WINED3DSHADER_ADDRESSMODE_MASK) == WINED3DSHADER_ADDRMODE_RELATIVE);
 573
 574     if (relative) {
 575         TRACE("[");
 576         if (addr_token)
 577             shader_dump_param(addr_token, 0, input, shader_version);
 578         else
 579             TRACE("a0.x");
 580         TRACE(" + ");
 581      }
 582      TRACE("%u", reg);
 583      if (relative)
 584          TRACE("]");
 585 }
 586
 587 static void shader_dump_param(const DWORD param, const DWORD addr_token, int input, DWORD shader_version)
 588 {
 589     static const char * const rastout_reg_names[] = { "oPos", "oFog", "oPts" };
 590     static const char * const misctype_reg_names[] = { "vPos", "vFace"};
 591     char swizzle_reg_chars[4];
 592
 593     DWORD reg = param & WINED3DSP_REGNUM_MASK;
 594     DWORD regtype = shader_get_regtype(param);
 595     DWORD modifier = param & WINED3DSP_SRCMOD_MASK;
 596
 597     /* There are some minor differences between pixel and vertex shaders */
 598     char pshader = shader_is_pshader_version(shader_version);
 599
 600     /* For one, we'd prefer color components to be shown for pshaders.
 601      * FIXME: use the swizzle function for this */
 602
 603     swizzle_reg_chars[0] = pshader? 'r': 'x';
 604     swizzle_reg_chars[1] = pshader? 'g': 'y';
 605     swizzle_reg_chars[2] = pshader? 'b': 'z';
 606     swizzle_reg_chars[3] = pshader? 'a': 'w';
 607
 608     if (input) {
 609         if ( (modifier == WINED3DSPSM_NEG) ||
 610              (modifier == WINED3DSPSM_BIASNEG) ||
 611              (modifier == WINED3DSPSM_SIGNNEG) ||
 612              (modifier == WINED3DSPSM_X2NEG) ||
 613              (modifier == WINED3DSPSM_ABSNEG) )
 614             TRACE("-");
 615         else if (modifier == WINED3DSPSM_COMP)
 616             TRACE("1-");
 617         else if (modifier == WINED3DSPSM_NOT)
 618             TRACE("!");
 619
 620         if (modifier == WINED3DSPSM_ABS || modifier == WINED3DSPSM_ABSNEG)
 621             TRACE("abs(");
 622     }
 623
 624     switch (regtype) {
 625         case WINED3DSPR_TEMP:
 626             TRACE("r%u", reg);
 627             break;
 628         case WINED3DSPR_INPUT:
 629             TRACE("v");
 630             shader_dump_arr_entry(param, addr_token, reg, input, shader_version);
 631             break;
 632         case WINED3DSPR_CONST:
 633         case WINED3DSPR_CONST2:
 634         case WINED3DSPR_CONST3:
 635         case WINED3DSPR_CONST4:
 636             TRACE("c");
 637             shader_dump_arr_entry(param, addr_token, shader_get_float_offset(param), input, shader_version);
 638             break;
 639         case WINED3DSPR_TEXTURE: /* vs: case D3DSPR_ADDR */
 640             TRACE("%c%u", (pshader? 't':'a'), reg);
 641             break;
 642         case WINED3DSPR_RASTOUT:
 643             TRACE("%s", rastout_reg_names[reg]);
 644             break;
 645         case WINED3DSPR_COLOROUT:
 646             TRACE("oC%u", reg);
 647             break;
 648         case WINED3DSPR_DEPTHOUT:
 649             TRACE("oDepth");
 650             break;
 651         case WINED3DSPR_ATTROUT:
 652             TRACE("oD%u", reg);
 653             break;
 654         case WINED3DSPR_TEXCRDOUT:
 655
 656             /* Vertex shaders >= 3.0 use general purpose output registers
 657              * (WINED3DSPR_OUTPUT), which can include an address token */
 658
 659             if (WINED3DSHADER_VERSION_MAJOR(shader_version) >= 3) {
 660                 TRACE("o");
 661                 shader_dump_arr_entry(param, addr_token, reg, input, shader_version);
 662             }
 663             else
 664                TRACE("oT%u", reg);
 665             break;
 666         case WINED3DSPR_CONSTINT:
 667             TRACE("i");
 668             shader_dump_arr_entry(param, addr_token, reg, input, shader_version);
 669             break;
 670         case WINED3DSPR_CONSTBOOL:
 671             TRACE("b");
 672             shader_dump_arr_entry(param, addr_token, reg, input, shader_version);
 673             break;
 674         case WINED3DSPR_LABEL:
 675             TRACE("l%u", reg);
 676             break;
 677         case WINED3DSPR_LOOP:
 678             TRACE("aL");
 679             break;
 680         case WINED3DSPR_SAMPLER:
 681             TRACE("s%u", reg);
 682             break;
 683         case WINED3DSPR_MISCTYPE:
 684             if (reg > 1) {
 685                 FIXME("Unhandled misctype register %d\n", reg);
 686             } else {
 687                 TRACE("%s", misctype_reg_names[reg]);
 688             }
 689             break;
 690         case WINED3DSPR_PREDICATE:
 691             TRACE("p%u", reg);
 692             break;
 693         default:
 694             TRACE("unhandled_rtype(%#x)", regtype);
 695             break;
 696    }
 697
 698    if (!input) {
 699        /* operand output (for modifiers and shift, see dump_ins_modifiers) */
 700
 701        if ((param & WINED3DSP_WRITEMASK_ALL) != WINED3DSP_WRITEMASK_ALL) {
 702            TRACE(".");
 703            if (param & WINED3DSP_WRITEMASK_0) TRACE("%c", swizzle_reg_chars[0]);
 704            if (param & WINED3DSP_WRITEMASK_1) TRACE("%c", swizzle_reg_chars[1]);
 705            if (param & WINED3DSP_WRITEMASK_2) TRACE("%c", swizzle_reg_chars[2]);
 706            if (param & WINED3DSP_WRITEMASK_3) TRACE("%c", swizzle_reg_chars[3]);
 707        }
 708
 709    } else {
 710         /** operand input */
 711         DWORD swizzle = (param & WINED3DSP_SWIZZLE_MASK) >> WINED3DSP_SWIZZLE_SHIFT;
 712         DWORD swizzle_r = swizzle & 0x03;
 713         DWORD swizzle_g = (swizzle >> 2) & 0x03;
 714         DWORD swizzle_b = (swizzle >> 4) & 0x03;
 715         DWORD swizzle_a = (swizzle >> 6) & 0x03;
 716
 717         if (0 != modifier) {
 718             switch (modifier) {
 719                 case WINED3DSPSM_NONE:    break;
 720                 case WINED3DSPSM_NEG:     break;
 721                 case WINED3DSPSM_NOT:     break;
 722                 case WINED3DSPSM_BIAS:    TRACE("_bias"); break;
 723                 case WINED3DSPSM_BIASNEG: TRACE("_bias"); break;
 724                 case WINED3DSPSM_SIGN:    TRACE("_bx2"); break;
 725                 case WINED3DSPSM_SIGNNEG: TRACE("_bx2"); break;
 726                 case WINED3DSPSM_COMP:    break;
 727                 case WINED3DSPSM_X2:      TRACE("_x2"); break;
 728                 case WINED3DSPSM_X2NEG:   TRACE("_x2"); break;
 729                 case WINED3DSPSM_DZ:      TRACE("_dz"); break;
 730                 case WINED3DSPSM_DW:      TRACE("_dw"); break;
 731                 case WINED3DSPSM_ABSNEG:  TRACE(")"); break;
 732                 case WINED3DSPSM_ABS:     TRACE(")"); break;
 733                 default:
 734                     TRACE("_unknown_modifier(%#x)", modifier >> WINED3DSP_SRCMOD_SHIFT);
 735             }
 736         }
 737
 738         /**
 739         * swizzle bits fields:
 740         *  RRGGBBAA
 741         */
 742         if ((WINED3DVS_NOSWIZZLE >> WINED3DVS_SWIZZLE_SHIFT) != swizzle) {
 743             if (swizzle_r == swizzle_g &&
 744                 swizzle_r == swizzle_b &&
 745                 swizzle_r == swizzle_a) {
 746                     TRACE(".%c", swizzle_reg_chars[swizzle_r]);
 747             } else {
 748                 TRACE(".%c%c%c%c",
 749                 swizzle_reg_chars[swizzle_r],
 750                 swizzle_reg_chars[swizzle_g],
 751                 swizzle_reg_chars[swizzle_b],
 752                 swizzle_reg_chars[swizzle_a]);
 753             }
 754         }
 755     }
 756 }
 757
 758 static void shader_color_correction(IWineD3DBaseShaderImpl *shader,
 759         IWineD3DDeviceImpl *device, const struct SHADER_OPCODE_ARG *arg, DWORD shader_version)
 760 {
 761     IWineD3DBaseTextureImpl *texture;
 762     struct color_fixup_desc fixup;
 763     BOOL recorded = FALSE;
 764     DWORD sampler_idx;
 765     UINT i;
 766
 767     switch(arg->opcode->opcode)
 768     {
 769         case WINED3DSIO_TEX:
 770             if (WINED3DSHADER_VERSION_MAJOR(shader_version) < 2) sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
 771             else sampler_idx = arg->src[1] & WINED3DSP_REGNUM_MASK;
 772             break;
 773
 774         case WINED3DSIO_TEXLDL:
 775             FIXME("Add color fixup for vertex texture WINED3DSIO_TEXLDL\n");
 776             return;
 777
 778         case WINED3DSIO_TEXDP3TEX:
 779         case WINED3DSIO_TEXM3x3TEX:
 780         case WINED3DSIO_TEXM3x3SPEC:
 781         case WINED3DSIO_TEXM3x3VSPEC:
 782         case WINED3DSIO_TEXBEM:
 783         case WINED3DSIO_TEXREG2AR:
 784         case WINED3DSIO_TEXREG2GB:
 785         case WINED3DSIO_TEXREG2RGB:
 786             sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
 787             break;
 788
 789         default:
 790             /* Not a texture sampling instruction, nothing to do */
 791             return;
 792     };
 793
 794     texture = (IWineD3DBaseTextureImpl *)device->stateBlock->textures[sampler_idx];
 795     if (texture) fixup = texture->baseTexture.shader_color_fixup;
 796     else fixup = COLOR_FIXUP_IDENTITY;
 797
 798     /* before doing anything, record the sampler with the format in the format conversion list,
 799      * but check if it's not there already */
 800     for (i = 0; i < shader->baseShader.num_sampled_samplers; ++i)
 801     {
 802         if (shader->baseShader.sampled_samplers[i] == sampler_idx)
 803         {
 804             recorded = TRUE;
 805             break;
 806         }
 807     }
 808
 809     if (!recorded)
 810     {
 811         shader->baseShader.sampled_samplers[shader->baseShader.num_sampled_samplers] = sampler_idx;
 812         ++shader->baseShader.num_sampled_samplers;
 813     }
 814
 815     device->shader_backend->shader_color_correction(arg, fixup);
 816 }
 817
 818 /* Shared code in order to generate the bulk of the shader string.
 819  * NOTE: A description of how to parse tokens can be found on msdn */
 820 void shader_generate_main(IWineD3DBaseShader *iface, SHADER_BUFFER* buffer,
 821         const shader_reg_maps* reg_maps, CONST DWORD* pFunction)
 822 {
 823     IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
 824     IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) This->baseShader.device; /* To access shader backend callbacks */
 825     const SHADER_OPCODE *opcode_table = This->baseShader.shader_ins;
 826     const SHADER_HANDLER *handler_table = device->shader_backend->shader_instruction_handler_table;
 827     DWORD shader_version = reg_maps->shader_version;
 828     const DWORD *pToken = pFunction;
 829     const SHADER_OPCODE *curOpcode;
 830     SHADER_HANDLER hw_fct;
 831     DWORD i;
 832     SHADER_OPCODE_ARG hw_arg;
 833
 834     /* Initialize current parsing state */
 835     hw_arg.shader = iface;
 836     hw_arg.buffer = buffer;
 837     hw_arg.reg_maps = reg_maps;
 838     This->baseShader.parse_state.current_row = 0;
 839
 840     while (WINED3DPS_END() != *pToken)
 841     {
 842         /* Skip version token */
 843         if (shader_is_version_token(*pToken))
 844         {
 845             ++pToken;
 846             continue;
 847         }
 848
 849         /* Skip comment tokens */
 850         if (shader_is_comment(*pToken))
 851         {
 852             pToken += (*pToken & WINED3DSI_COMMENTSIZE_MASK) >> WINED3DSI_COMMENTSIZE_SHIFT;
 853             ++pToken;
 854             continue;
 855         }
 856
 857         /* Read opcode */
 858         hw_arg.opcode_token = *pToken++;
 859         curOpcode = shader_get_opcode(opcode_table, shader_version, hw_arg.opcode_token);
 860
 861         /* Unknown opcode and its parameters */
 862         if (!curOpcode)
 863         {
 864             FIXME("Unrecognized opcode: token=0x%08x\n", hw_arg.opcode_token);
 865             pToken += shader_skip_unrecognized(pToken, shader_version);
 866             continue;
 867         }
 868
 869         /* Nothing to do */
 870         if (WINED3DSIO_DCL == curOpcode->opcode
 871                 || WINED3DSIO_NOP == curOpcode->opcode
 872                 || WINED3DSIO_DEF == curOpcode->opcode
 873                 || WINED3DSIO_DEFI == curOpcode->opcode
 874                 || WINED3DSIO_DEFB == curOpcode->opcode
 875                 || WINED3DSIO_PHASE == curOpcode->opcode
 876                 || WINED3DSIO_RET == curOpcode->opcode)
 877         {
 878             pToken += shader_skip_opcode(curOpcode, hw_arg.opcode_token, shader_version);
 879             continue;
 880         }
 881
 882         /* Select handler */
 883         hw_fct = handler_table[curOpcode->handler_idx];
 884
 885         /* Unhandled opcode */
 886         if (!hw_fct)
 887         {
 888             FIXME("Can't handle opcode %s in hwShader\n", curOpcode->name);
 889             pToken += shader_skip_opcode(curOpcode, hw_arg.opcode_token, shader_version);
 890             continue;
 891         }
 892
 893         hw_arg.opcode = curOpcode;
 894
 895         /* Destination token */
 896         if (curOpcode->dst_token)
 897         {
 898             DWORD param, addr_token = 0;
 899             pToken += shader_get_param(pToken, shader_version, &param, &addr_token);
 900             hw_arg.dst = param;
 901             hw_arg.dst_addr = addr_token;
 902         }
 903
 904         /* Predication token */
 905         if (hw_arg.opcode_token & WINED3DSHADER_INSTRUCTION_PREDICATED) hw_arg.predicate = *pToken++;
 906
 907         /* Other source tokens */
 908         for (i = 0; i < (curOpcode->num_params - curOpcode->dst_token); ++i)
 909         {
 910             DWORD param, addr_token = 0;
 911             pToken += shader_get_param(pToken, shader_version, &param, &addr_token);
 912             hw_arg.src[i] = param;
 913             hw_arg.src_addr[i] = addr_token;
 914         }
 915
 916         /* Call appropriate function for output target */
 917         hw_fct(&hw_arg);
 918
 919         /* Add color correction if needed */
 920         shader_color_correction(This, device, &hw_arg, shader_version);
 921
 922         /* Process instruction modifiers for GLSL apps ( _sat, etc. ) */
 923         /* FIXME: This should be internal to the shader backend.
 924          * Also, right now this is the only reason "shader_mode" exists. */
 925         if (This->baseShader.shader_mode == SHADER_GLSL) shader_glsl_add_instruction_modifiers(&hw_arg);
 926     }
 927 }
 928
 929 static void shader_dump_ins_modifiers(const DWORD output)
 930 {
 931     DWORD shift = (output & WINED3DSP_DSTSHIFT_MASK) >> WINED3DSP_DSTSHIFT_SHIFT;
 932     DWORD mmask = output & WINED3DSP_DSTMOD_MASK;
 933
 934     switch (shift) {
 935         case 0: break;
 936         case 13: TRACE("_d8"); break;
 937         case 14: TRACE("_d4"); break;
 938         case 15: TRACE("_d2"); break;
 939         case 1: TRACE("_x2"); break;
 940         case 2: TRACE("_x4"); break;
 941         case 3: TRACE("_x8"); break;
 942         default: TRACE("_unhandled_shift(%d)", shift); break;
 943     }
 944
 945     if (mmask & WINED3DSPDM_SATURATE)         TRACE("_sat");
 946     if (mmask & WINED3DSPDM_PARTIALPRECISION) TRACE("_pp");
 947     if (mmask & WINED3DSPDM_MSAMPCENTROID)    TRACE("_centroid");
 948
 949     mmask &= ~(WINED3DSPDM_SATURATE | WINED3DSPDM_PARTIALPRECISION | WINED3DSPDM_MSAMPCENTROID);
 950     if (mmask)
 951         FIXME("_unrecognized_modifier(%#x)", mmask >> WINED3DSP_DSTMOD_SHIFT);
 952 }
 953
 954 void shader_trace_init(const DWORD *pFunction, const SHADER_OPCODE *opcode_table)
 955 {
 956     const DWORD* pToken = pFunction;
 957     const SHADER_OPCODE* curOpcode = NULL;
 958     DWORD shader_version;
 959     DWORD opcode_token;
 960     DWORD i;
 961
 962     TRACE("Parsing %p\n", pFunction);
 963
 964     /* The version token is supposed to be the first token */
 965     if (!shader_is_version_token(*pToken))
 966     {
 967         FIXME("First token is not a version token, invalid shader.\n");
 968         return;
 969     }
 970     shader_version = *pToken++;
 971     TRACE("%s_%u_%u\n", shader_is_pshader_version(shader_version) ? "ps": "vs",
 972             WINED3DSHADER_VERSION_MAJOR(shader_version), WINED3DSHADER_VERSION_MINOR(shader_version));
 973
 974     while (WINED3DVS_END() != *pToken)
 975     {
 976         if (shader_is_comment(*pToken)) /* comment */
 977         {
 978             DWORD comment_len = (*pToken & WINED3DSI_COMMENTSIZE_MASK) >> WINED3DSI_COMMENTSIZE_SHIFT;
 979             ++pToken;
 980             TRACE("//%s\n", (const char*)pToken);
 981             pToken += comment_len;
 982             continue;
 983         }
 984         opcode_token = *pToken++;
 985         curOpcode = shader_get_opcode(opcode_table, shader_version, opcode_token);
 986
 987         if (!curOpcode)
 988         {
 989             int tokens_read;
 990             FIXME("Unrecognized opcode: token=0x%08x\n", opcode_token);
 991             tokens_read = shader_skip_unrecognized(pToken, shader_version);
 992             pToken += tokens_read;
 993         }
 994         else
 995         {
 996             if (curOpcode->opcode == WINED3DSIO_DCL)
 997             {
 998                 DWORD usage = *pToken;
 999                 DWORD param = *(pToken + 1);
1000
1001                 shader_dump_decl_usage(usage, param, shader_version);
1002                 shader_dump_ins_modifiers(param);
1003                 TRACE(" ");
1004                 shader_dump_param(param, 0, 0, shader_version);
1005                 pToken += 2;
1006             }
1007             else if (curOpcode->opcode == WINED3DSIO_DEF)
1008             {
1009                 unsigned int offset = shader_get_float_offset(*pToken);
1010
1011                 TRACE("def c%u = %f, %f, %f, %f", offset,
1012                         *(const float *)(pToken + 1),
1013                         *(const float *)(pToken + 2),
1014                         *(const float *)(pToken + 3),
1015                         *(const float *)(pToken + 4));
1016                 pToken += 5;
1017             }
1018             else if (curOpcode->opcode == WINED3DSIO_DEFI)
1019             {
1020                 TRACE("defi i%u = %d, %d, %d, %d", *pToken & WINED3DSP_REGNUM_MASK,
1021                         *(pToken + 1),
1022                         *(pToken + 2),
1023                         *(pToken + 3),
1024                         *(pToken + 4));
1025                 pToken += 5;
1026             }
1027             else if (curOpcode->opcode == WINED3DSIO_DEFB)
1028             {
1029                 TRACE("defb b%u = %s", *pToken & WINED3DSP_REGNUM_MASK,
1030                         *(pToken + 1)? "true": "false");
1031                 pToken += 2;
1032             }
1033             else
1034             {
1035                 DWORD param, addr_token;
1036                 int tokens_read;
1037
1038                 /* Print out predication source token first - it follows
1039                  * the destination token. */
1040                 if (opcode_token & WINED3DSHADER_INSTRUCTION_PREDICATED)
1041                 {
1042                     TRACE("(");
1043                     shader_dump_param(*(pToken + 2), 0, 1, shader_version);
1044                     TRACE(") ");
1045                 }
1046                 if (opcode_token & WINED3DSI_COISSUE)
1047                 {
1048                     /* PixWin marks instructions with the coissue flag with a '+' */
1049                     TRACE("+");
1050                 }
1051
1052                 TRACE("%s", curOpcode->name);
1053
1054                 if (curOpcode->opcode == WINED3DSIO_IFC
1055                         || curOpcode->opcode == WINED3DSIO_BREAKC)
1056                 {
1057                     DWORD op = (opcode_token & INST_CONTROLS_MASK) >> INST_CONTROLS_SHIFT;
1058
1059                     switch (op)
1060                     {
1061                         case COMPARISON_GT: TRACE("_gt"); break;
1062                         case COMPARISON_EQ: TRACE("_eq"); break;
1063                         case COMPARISON_GE: TRACE("_ge"); break;
1064                         case COMPARISON_LT: TRACE("_lt"); break;
1065                         case COMPARISON_NE: TRACE("_ne"); break;
1066                         case COMPARISON_LE: TRACE("_le"); break;
1067                         default: TRACE("_(%u)", op);
1068                     }
1069                 }
1070                 else if (curOpcode->opcode == WINED3DSIO_TEX
1071                         && shader_version >= WINED3DPS_VERSION(2,0)
1072                         && (opcode_token & WINED3DSI_TEXLD_PROJECT))
1073                 {
1074                     TRACE("p");
1075                 }
1076
1077                 /* Destination token */
1078                 if (curOpcode->dst_token)
1079                 {
1080                     tokens_read = shader_get_param(pToken, shader_version, &param, &addr_token);
1081                     pToken += tokens_read;
1082
1083                     shader_dump_ins_modifiers(param);
1084                     TRACE(" ");
1085                     shader_dump_param(param, addr_token, 0, shader_version);
1086                 }
1087
1088                 /* Predication token - already printed out, just skip it */
1089                 if (opcode_token & WINED3DSHADER_INSTRUCTION_PREDICATED)
1090                 {
1091                     pToken++;
1092                 }
1093
1094                 /* Other source tokens */
1095                 for (i = curOpcode->dst_token; i < curOpcode->num_params; ++i)
1096                 {
1097                     tokens_read = shader_get_param(pToken, shader_version, &param, &addr_token);
1098                     pToken += tokens_read;
1099
1100                     TRACE((i == 0)? " " : ", ");
1101                     shader_dump_param(param, addr_token, 1, shader_version);
1102                 }
1103             }
1104             TRACE("\n");
1105         }
1106     }
1107 }
1108
1109 void shader_cleanup(IWineD3DBaseShader *iface)
1110 {
1111     IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl *)iface;
1112
1113     ((IWineD3DDeviceImpl *)This->baseShader.device)->shader_backend->shader_destroy(iface);
1114     HeapFree(GetProcessHeap(), 0, This->baseShader.function);
1115     shader_delete_constant_list(&This->baseShader.constantsF);
1116     shader_delete_constant_list(&This->baseShader.constantsB);
1117     shader_delete_constant_list(&This->baseShader.constantsI);
1118     list_remove(&This->baseShader.shader_list_entry);
1119 }
1120
1121 static const SHADER_HANDLER shader_none_instruction_handler_table[WINED3DSIH_TABLE_SIZE] = {0};
1122 static void shader_none_select(IWineD3DDevice *iface, BOOL usePS, BOOL useVS) {}
1123 static void shader_none_select_depth_blt(IWineD3DDevice *iface, enum tex_types tex_type) {}
1124 static void shader_none_deselect_depth_blt(IWineD3DDevice *iface) {}
1125 static void shader_none_load_constants(IWineD3DDevice *iface, char usePS, char useVS) {}
1126 static void shader_none_color_correction(const struct SHADER_OPCODE_ARG *arg, struct color_fixup_desc fixup) {}
1127 static void shader_none_destroy(IWineD3DBaseShader *iface) {}
1128 static HRESULT shader_none_alloc(IWineD3DDevice *iface) {return WINED3D_OK;}
1129 static void shader_none_free(IWineD3DDevice *iface) {}
1130 static BOOL shader_none_dirty_const(IWineD3DDevice *iface) {return FALSE;}
1131 static GLuint shader_none_generate_pshader(IWineD3DPixelShader *iface, SHADER_BUFFER *buffer) {
1132     FIXME("NONE shader backend asked to generate a pixel shader\n");
1133     return 0;
1134 }
1135 static void shader_none_generate_vshader(IWineD3DVertexShader *iface, SHADER_BUFFER *buffer) {
1136     FIXME("NONE shader backend asked to generate a vertex shader\n");
1137 }
1138
1139 #define GLINFO_LOCATION      (*gl_info)
1140 static void shader_none_get_caps(WINED3DDEVTYPE devtype, const WineD3D_GL_Info *gl_info, struct shader_caps *pCaps)
1141 {
1142     /* Set the shader caps to 0 for the none shader backend */
1143     pCaps->VertexShaderVersion  = 0;
1144     pCaps->PixelShaderVersion    = 0;
1145     pCaps->PixelShader1xMaxValue = 0.0;
1146 }
1147 #undef GLINFO_LOCATION
1148 static BOOL shader_none_color_fixup_supported(struct color_fixup_desc fixup)
1149 {
1150     if (TRACE_ON(d3d_shader) && TRACE_ON(d3d))
1151     {
1152         TRACE("Checking support for fixup:\n");
1153         dump_color_fixup_desc(fixup);
1154     }
1155
1156     /* Faked to make some apps happy. */
1157     if (!is_yuv_fixup(fixup))
1158     {
1159         TRACE("[OK]\n");
1160         return TRUE;
1161     }
1162
1163     TRACE("[FAILED]\n");
1164     return FALSE;
1165 }
1166
1167 const shader_backend_t none_shader_backend = {
1168     shader_none_instruction_handler_table,
1169     shader_none_select,
1170     shader_none_select_depth_blt,
1171     shader_none_deselect_depth_blt,
1172     shader_none_load_constants,
1173     shader_none_color_correction,
1174     shader_none_destroy,
1175     shader_none_alloc,
1176     shader_none_free,
1177     shader_none_dirty_const,
1178     shader_none_generate_pshader,
1179     shader_none_generate_vshader,
1180     shader_none_get_caps,
1181     shader_none_color_fixup_supported,
1182 };