git.oblomov.eu Git - wine/blob - 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  * Copyright 2009 Henri Verbeet for CodeWeavers
  11  *
  12  * This library is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU Lesser General Public
  14  * License as published by the Free Software Foundation; either
  15  * version 2.1 of the License, or (at your option) any later version.
  16  *
  17  * This library is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  * Lesser General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Lesser General Public
  23  * License along with this library; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  25  */
  26
  27 #include "config.h"
  28 #include <string.h>
  29 #include <stdio.h>
  30 #include "wined3d_private.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
  33 WINE_DECLARE_DEBUG_CHANNEL(d3d);
  34
  35 static const char *shader_opcode_names[] =
  36 {
  37     /* WINED3DSIH_ABS           */ "abs",
  38     /* WINED3DSIH_ADD           */ "add",
  39     /* WINED3DSIH_BEM           */ "bem",
  40     /* WINED3DSIH_BREAK         */ "break",
  41     /* WINED3DSIH_BREAKC        */ "breakc",
  42     /* WINED3DSIH_BREAKP        */ "breakp",
  43     /* WINED3DSIH_CALL          */ "call",
  44     /* WINED3DSIH_CALLNZ        */ "callnz",
  45     /* WINED3DSIH_CMP           */ "cmp",
  46     /* WINED3DSIH_CND           */ "cnd",
  47     /* WINED3DSIH_CRS           */ "crs",
  48     /* WINED3DSIH_DCL           */ "dcl",
  49     /* WINED3DSIH_DEF           */ "def",
  50     /* WINED3DSIH_DEFB          */ "defb",
  51     /* WINED3DSIH_DEFI          */ "defi",
  52     /* WINED3DSIH_DP2ADD        */ "dp2add",
  53     /* WINED3DSIH_DP3           */ "dp3",
  54     /* WINED3DSIH_DP4           */ "dp4",
  55     /* WINED3DSIH_DST           */ "dst",
  56     /* WINED3DSIH_DSX           */ "dsx",
  57     /* WINED3DSIH_DSY           */ "dsy",
  58     /* WINED3DSIH_ELSE          */ "else",
  59     /* WINED3DSIH_ENDIF         */ "endif",
  60     /* WINED3DSIH_ENDLOOP       */ "endloop",
  61     /* WINED3DSIH_ENDREP        */ "endrep",
  62     /* WINED3DSIH_EXP           */ "exp",
  63     /* WINED3DSIH_EXPP          */ "expp",
  64     /* WINED3DSIH_FRC           */ "frc",
  65     /* WINED3DSIH_IF            */ "if",
  66     /* WINED3DSIH_IFC           */ "ifc",
  67     /* WINED3DSIH_LABEL         */ "label",
  68     /* WINED3DSIH_LIT           */ "lit",
  69     /* WINED3DSIH_LOG           */ "log",
  70     /* WINED3DSIH_LOGP          */ "logp",
  71     /* WINED3DSIH_LOOP          */ "loop",
  72     /* WINED3DSIH_LRP           */ "lrp",
  73     /* WINED3DSIH_M3x2          */ "m3x2",
  74     /* WINED3DSIH_M3x3          */ "m3x3",
  75     /* WINED3DSIH_M3x4          */ "m3x4",
  76     /* WINED3DSIH_M4x3          */ "m4x3",
  77     /* WINED3DSIH_M4x4          */ "m4x4",
  78     /* WINED3DSIH_MAD           */ "mad",
  79     /* WINED3DSIH_MAX           */ "max",
  80     /* WINED3DSIH_MIN           */ "min",
  81     /* WINED3DSIH_MOV           */ "mov",
  82     /* WINED3DSIH_MOVA          */ "mova",
  83     /* WINED3DSIH_MUL           */ "mul",
  84     /* WINED3DSIH_NOP           */ "nop",
  85     /* WINED3DSIH_NRM           */ "nrm",
  86     /* WINED3DSIH_PHASE         */ "phase",
  87     /* WINED3DSIH_POW           */ "pow",
  88     /* WINED3DSIH_RCP           */ "rcp",
  89     /* WINED3DSIH_REP           */ "rep",
  90     /* WINED3DSIH_RET           */ "ret",
  91     /* WINED3DSIH_RSQ           */ "rsq",
  92     /* WINED3DSIH_SETP          */ "setp",
  93     /* WINED3DSIH_SGE           */ "sge",
  94     /* WINED3DSIH_SGN           */ "sgn",
  95     /* WINED3DSIH_SINCOS        */ "sincos",
  96     /* WINED3DSIH_SLT           */ "slt",
  97     /* WINED3DSIH_SUB           */ "sub",
  98     /* WINED3DSIH_TEX           */ "texld",
  99     /* WINED3DSIH_TEXBEM        */ "texbem",
 100     /* WINED3DSIH_TEXBEML       */ "texbeml",
 101     /* WINED3DSIH_TEXCOORD      */ "texcrd",
 102     /* WINED3DSIH_TEXDEPTH      */ "texdepth",
 103     /* WINED3DSIH_TEXDP3        */ "texdp3",
 104     /* WINED3DSIH_TEXDP3TEX     */ "texdp3tex",
 105     /* WINED3DSIH_TEXKILL       */ "texkill",
 106     /* WINED3DSIH_TEXLDD        */ "texldd",
 107     /* WINED3DSIH_TEXLDL        */ "texldl",
 108     /* WINED3DSIH_TEXM3x2DEPTH  */ "texm3x2depth",
 109     /* WINED3DSIH_TEXM3x2PAD    */ "texm3x2pad",
 110     /* WINED3DSIH_TEXM3x2TEX    */ "texm3x2tex",
 111     /* WINED3DSIH_TEXM3x3       */ "texm3x3",
 112     /* WINED3DSIH_TEXM3x3DIFF   */ "texm3x3diff",
 113     /* WINED3DSIH_TEXM3x3PAD    */ "texm3x3pad",
 114     /* WINED3DSIH_TEXM3x3SPEC   */ "texm3x3spec",
 115     /* WINED3DSIH_TEXM3x3TEX    */ "texm3x3tex",
 116     /* WINED3DSIH_TEXM3x3VSPEC  */ "texm3x3vspec",
 117     /* WINED3DSIH_TEXREG2AR     */ "texreg2ar",
 118     /* WINED3DSIH_TEXREG2GB     */ "texreg2gb",
 119     /* WINED3DSIH_TEXREG2RGB    */ "texreg2rgb",
 120 };
 121
 122 const struct wined3d_shader_frontend *shader_select_frontend(DWORD version_token)
 123 {
 124     switch (version_token >> 16)
 125     {
 126         case WINED3D_SM1_VS:
 127         case WINED3D_SM1_PS:
 128             return &sm1_shader_frontend;
 129
 130         case WINED3D_SM4_PS:
 131         case WINED3D_SM4_VS:
 132         case WINED3D_SM4_GS:
 133             return &sm4_shader_frontend;
 134
 135         default:
 136             FIXME("Unrecognised version token %#x\n", version_token);
 137             return NULL;
 138     }
 139 }
 140
 141 static inline BOOL shader_is_version_token(DWORD token) {
 142     return shader_is_pshader_version(token) ||
 143            shader_is_vshader_version(token);
 144 }
 145
 146 void shader_buffer_init(struct SHADER_BUFFER *buffer)
 147 {
 148     buffer->buffer = HeapAlloc(GetProcessHeap(), 0, SHADER_PGMSIZE);
 149     buffer->buffer[0] = '\0';
 150     buffer->bsize = 0;
 151     buffer->lineNo = 0;
 152     buffer->newline = TRUE;
 153 }
 154
 155 void shader_buffer_free(struct SHADER_BUFFER *buffer)
 156 {
 157     HeapFree(GetProcessHeap(), 0, buffer->buffer);
 158 }
 159
 160 int shader_vaddline(SHADER_BUFFER* buffer, const char *format, va_list args)
 161 {
 162     char* base = buffer->buffer + buffer->bsize;
 163     int rc;
 164
 165     rc = vsnprintf(base, SHADER_PGMSIZE - 1 - buffer->bsize, format, args);
 166
 167     if (rc < 0 ||                                   /* C89 */
 168         rc > SHADER_PGMSIZE - 1 - buffer->bsize) {  /* C99 */
 169
 170         ERR("The buffer allocated for the shader program string "
 171             "is too small at %d bytes.\n", SHADER_PGMSIZE);
 172         buffer->bsize = SHADER_PGMSIZE - 1;
 173         return -1;
 174     }
 175
 176     if (buffer->newline) {
 177         TRACE("GL HW (%u, %u) : %s", buffer->lineNo + 1, buffer->bsize, base);
 178         buffer->newline = FALSE;
 179     } else {
 180         TRACE("%s", base);
 181     }
 182
 183     buffer->bsize += rc;
 184     if (buffer->buffer[buffer->bsize-1] == '\n') {
 185         buffer->lineNo++;
 186         buffer->newline = TRUE;
 187     }
 188     return 0;
 189 }
 190
 191 int shader_addline(SHADER_BUFFER* buffer, const char *format, ...)
 192 {
 193     int ret;
 194     va_list args;
 195
 196     va_start(args, format);
 197     ret = shader_vaddline(buffer, format, args);
 198     va_end(args);
 199
 200     return ret;
 201 }
 202
 203 void shader_init(struct IWineD3DBaseShaderClass *shader, IWineD3DDevice *device)
 204 {
 205     shader->ref = 1;
 206     shader->device = device;
 207     list_init(&shader->linked_programs);
 208 }
 209
 210 /* Convert floating point offset relative
 211  * to a register file to an absolute offset for float constants */
 212 static unsigned int shader_get_float_offset(WINED3DSHADER_PARAM_REGISTER_TYPE register_type, UINT register_idx)
 213 {
 214     switch (register_type)
 215     {
 216         case WINED3DSPR_CONST: return register_idx;
 217         case WINED3DSPR_CONST2: return 2048 + register_idx;
 218         case WINED3DSPR_CONST3: return 4096 + register_idx;
 219         case WINED3DSPR_CONST4: return 6144 + register_idx;
 220         default:
 221             FIXME("Unsupported register type: %d\n", register_type);
 222             return register_idx;
 223     }
 224 }
 225
 226 static void shader_delete_constant_list(struct list* clist) {
 227
 228     struct list *ptr;
 229     struct local_constant* constant;
 230
 231     ptr = list_head(clist);
 232     while (ptr) {
 233         constant = LIST_ENTRY(ptr, struct local_constant, entry);
 234         ptr = list_next(clist, ptr);
 235         HeapFree(GetProcessHeap(), 0, constant);
 236     }
 237     list_init(clist);
 238 }
 239
 240 static inline void set_bitmap_bit(DWORD *bitmap, DWORD bit)
 241 {
 242     DWORD idx, shift;
 243     idx = bit >> 5;
 244     shift = bit & 0x1f;
 245     bitmap[idx] |= (1 << shift);
 246 }
 247
 248 static void shader_record_register_usage(IWineD3DBaseShaderImpl *This, struct shader_reg_maps *reg_maps,
 249         const struct wined3d_shader_register *reg, BOOL pshader)
 250 {
 251     switch (reg->type)
 252     {
 253         case WINED3DSPR_TEXTURE: /* WINED3DSPR_ADDR */
 254             if (pshader) reg_maps->texcoord[reg->idx] = 1;
 255             else reg_maps->address[reg->idx] = 1;
 256             break;
 257
 258         case WINED3DSPR_TEMP:
 259             reg_maps->temporary[reg->idx] = 1;
 260             break;
 261
 262         case WINED3DSPR_INPUT:
 263             if (!pshader) reg_maps->attributes[reg->idx] = 1;
 264             else
 265             {
 266                 if (reg->rel_addr)
 267                 {
 268                     /* If relative addressing is used, we must assume that all registers
 269                      * are used. Even if it is a construct like v3[aL], we can't assume
 270                      * that v0, v1 and v2 aren't read because aL can be negative */
 271                     unsigned int i;
 272                     for (i = 0; i < MAX_REG_INPUT; ++i)
 273                     {
 274                         ((IWineD3DPixelShaderImpl *)This)->input_reg_used[i] = TRUE;
 275                     }
 276                 }
 277                 else
 278                 {
 279                     ((IWineD3DPixelShaderImpl *)This)->input_reg_used[reg->idx] = TRUE;
 280                 }
 281             }
 282             break;
 283
 284         case WINED3DSPR_RASTOUT:
 285             if (reg->idx == 1) reg_maps->fog = 1;
 286             break;
 287
 288         case WINED3DSPR_MISCTYPE:
 289             if (pshader && reg->idx == 0) reg_maps->vpos = 1;
 290             break;
 291
 292         case WINED3DSPR_CONST:
 293             if (reg->rel_addr)
 294             {
 295                 if (!pshader)
 296                 {
 297                     if (reg->idx <= ((IWineD3DVertexShaderImpl *)This)->min_rel_offset)
 298                         ((IWineD3DVertexShaderImpl *)This)->min_rel_offset = reg->idx;
 299                     else if (reg->idx >= ((IWineD3DVertexShaderImpl *)This)->max_rel_offset)
 300                         ((IWineD3DVertexShaderImpl *)This)->max_rel_offset = reg->idx;
 301                 }
 302                 reg_maps->usesrelconstF = TRUE;
 303             }
 304             else
 305             {
 306                 set_bitmap_bit(reg_maps->constf, reg->idx);
 307             }
 308             break;
 309
 310         case WINED3DSPR_CONSTINT:
 311             reg_maps->integer_constants |= (1 << reg->idx);
 312             break;
 313
 314         case WINED3DSPR_CONSTBOOL:
 315             reg_maps->boolean_constants |= (1 << reg->idx);
 316             break;
 317
 318         default:
 319             TRACE("Not recording register of type %#x and idx %u\n", reg->type, reg->idx);
 320             break;
 321     }
 322 }
 323
 324 static unsigned int get_instr_extra_regcount(enum WINED3D_SHADER_INSTRUCTION_HANDLER instr, unsigned int param)
 325 {
 326     switch(instr)
 327     {
 328         case WINED3DSIH_M4x4:
 329         case WINED3DSIH_M3x4:
 330             return param == 1 ? 3 : 0;
 331
 332         case WINED3DSIH_M4x3:
 333         case WINED3DSIH_M3x3:
 334             return param == 1 ? 2 : 0;
 335
 336         case WINED3DSIH_M3x2:
 337             return param == 1 ? 1 : 0;
 338
 339         default:
 340             return 0;
 341     }
 342 }
 343
 344 /* Note that this does not count the loop register
 345  * as an address register. */
 346
 347 HRESULT shader_get_registers_used(IWineD3DBaseShader *iface, const struct wined3d_shader_frontend *fe,
 348         struct shader_reg_maps *reg_maps, struct wined3d_shader_semantic *semantics_in,
 349         struct wined3d_shader_semantic *semantics_out, const DWORD *byte_code, DWORD constf_size)
 350 {
 351     IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
 352     void *fe_data = This->baseShader.frontend_data;
 353     struct wined3d_shader_version shader_version;
 354     unsigned int cur_loop_depth = 0, max_loop_depth = 0;
 355     const DWORD* pToken = byte_code;
 356     char pshader;
 357
 358     /* There are some minor differences between pixel and vertex shaders */
 359
 360     memset(reg_maps, 0, sizeof(*reg_maps));
 361
 362     /* get_registers_used is called on every compile on some 1.x shaders, which can result
 363      * in stacking up a collection of local constants. Delete the old constants if existing
 364      */
 365     shader_delete_constant_list(&This->baseShader.constantsF);
 366     shader_delete_constant_list(&This->baseShader.constantsB);
 367     shader_delete_constant_list(&This->baseShader.constantsI);
 368
 369     fe->shader_read_header(fe_data, &pToken, &shader_version);
 370     reg_maps->shader_version = shader_version;
 371     pshader = shader_is_pshader_version(shader_version.type);
 372
 373     reg_maps->constf = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 374                                  sizeof(*reg_maps->constf) * ((constf_size + 31) / 32));
 375     if(!reg_maps->constf) {
 376         ERR("Out of memory\n");
 377         return E_OUTOFMEMORY;
 378     }
 379
 380     while (!fe->shader_is_end(fe_data, &pToken))
 381     {
 382         struct wined3d_shader_instruction ins;
 383         const char *comment;
 384         UINT param_size;
 385
 386         /* Skip comments */
 387         fe->shader_read_comment(&pToken, &comment);
 388         if (comment) continue;
 389
 390         /* Fetch opcode */
 391         fe->shader_read_opcode(fe_data, &pToken, &ins, &param_size);
 392
 393         /* Unhandled opcode, and its parameters */
 394         if (ins.handler_idx == WINED3DSIH_TABLE_SIZE)
 395         {
 396             TRACE("Skipping unrecognized instruction.\n");
 397             pToken += param_size;
 398             continue;
 399         }
 400
 401         /* Handle declarations */
 402         if (ins.handler_idx == WINED3DSIH_DCL)
 403         {
 404             struct wined3d_shader_semantic semantic;
 405
 406             fe->shader_read_semantic(&pToken, &semantic);
 407
 408             switch (semantic.reg.reg.type)
 409             {
 410                 /* Vshader: mark attributes used
 411                  * Pshader: mark 3.0 input registers used, save token */
 412                 case WINED3DSPR_INPUT:
 413                     if (!pshader) reg_maps->attributes[semantic.reg.reg.idx] = 1;
 414                     else reg_maps->packed_input[semantic.reg.reg.idx] = 1;
 415                     semantics_in[semantic.reg.reg.idx] = semantic;
 416                     break;
 417
 418                 /* Vshader: mark 3.0 output registers used, save token */
 419                 case WINED3DSPR_OUTPUT:
 420                     reg_maps->packed_output[semantic.reg.reg.idx] = 1;
 421                     semantics_out[semantic.reg.reg.idx] = semantic;
 422                     if (semantic.usage == WINED3DDECLUSAGE_FOG) reg_maps->fog = 1;
 423                     break;
 424
 425                 /* Save sampler usage token */
 426                 case WINED3DSPR_SAMPLER:
 427                     reg_maps->sampler_type[semantic.reg.reg.idx] = semantic.sampler_type;
 428                     break;
 429
 430                 default:
 431                     TRACE("Not recording DCL register type %#x.\n", semantic.reg.reg.type);
 432                     break;
 433             }
 434         }
 435         else if (ins.handler_idx == WINED3DSIH_DEF)
 436         {
 437             struct wined3d_shader_dst_param dst;
 438             struct wined3d_shader_src_param rel_addr;
 439
 440             local_constant* lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant));
 441             if (!lconst) return E_OUTOFMEMORY;
 442
 443             fe->shader_read_dst_param(fe_data, &pToken, &dst, &rel_addr);
 444             lconst->idx = dst.reg.idx;
 445
 446             memcpy(lconst->value, pToken, 4 * sizeof(DWORD));
 447             pToken += 4;
 448
 449             /* In pixel shader 1.X shaders, the constants are clamped between [-1;1] */
 450             if (shader_version.major == 1 && pshader)
 451             {
 452                 float *value = (float *) lconst->value;
 453                 if(value[0] < -1.0) value[0] = -1.0;
 454                 else if(value[0] >  1.0) value[0] =  1.0;
 455                 if(value[1] < -1.0) value[1] = -1.0;
 456                 else if(value[1] >  1.0) value[1] =  1.0;
 457                 if(value[2] < -1.0) value[2] = -1.0;
 458                 else if(value[2] >  1.0) value[2] =  1.0;
 459                 if(value[3] < -1.0) value[3] = -1.0;
 460                 else if(value[3] >  1.0) value[3] =  1.0;
 461             }
 462
 463             list_add_head(&This->baseShader.constantsF, &lconst->entry);
 464         }
 465         else if (ins.handler_idx == WINED3DSIH_DEFI)
 466         {
 467             struct wined3d_shader_dst_param dst;
 468             struct wined3d_shader_src_param rel_addr;
 469
 470             local_constant* lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant));
 471             if (!lconst) return E_OUTOFMEMORY;
 472
 473             fe->shader_read_dst_param(fe_data, &pToken, &dst, &rel_addr);
 474             lconst->idx = dst.reg.idx;
 475
 476             memcpy(lconst->value, pToken, 4 * sizeof(DWORD));
 477             pToken += 4;
 478
 479             list_add_head(&This->baseShader.constantsI, &lconst->entry);
 480         }
 481         else if (ins.handler_idx == WINED3DSIH_DEFB)
 482         {
 483             struct wined3d_shader_dst_param dst;
 484             struct wined3d_shader_src_param rel_addr;
 485
 486             local_constant* lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant));
 487             if (!lconst) return E_OUTOFMEMORY;
 488
 489             fe->shader_read_dst_param(fe_data, &pToken, &dst, &rel_addr);
 490             lconst->idx = dst.reg.idx;
 491
 492             memcpy(lconst->value, pToken, sizeof(DWORD));
 493             ++pToken;
 494
 495             list_add_head(&This->baseShader.constantsB, &lconst->entry);
 496         }
 497         /* If there's a loop in the shader */
 498         else if (ins.handler_idx == WINED3DSIH_LOOP
 499                 || ins.handler_idx == WINED3DSIH_REP)
 500         {
 501             struct wined3d_shader_src_param src, rel_addr;
 502
 503             fe->shader_read_src_param(fe_data, &pToken, &src, &rel_addr);
 504
 505             /* Rep and Loop always use an integer constant for the control parameters */
 506             if (ins.handler_idx == WINED3DSIH_REP)
 507             {
 508                 reg_maps->integer_constants |= 1 << src.reg.idx;
 509             }
 510             else
 511             {
 512                 fe->shader_read_src_param(fe_data, &pToken, &src, &rel_addr);
 513                 reg_maps->integer_constants |= 1 << src.reg.idx;
 514             }
 515
 516             cur_loop_depth++;
 517             if(cur_loop_depth > max_loop_depth)
 518                 max_loop_depth = cur_loop_depth;
 519         }
 520         else if (ins.handler_idx == WINED3DSIH_ENDLOOP
 521                 || ins.handler_idx == WINED3DSIH_ENDREP)
 522         {
 523             cur_loop_depth--;
 524         }
 525         /* For subroutine prototypes */
 526         else if (ins.handler_idx == WINED3DSIH_LABEL)
 527         {
 528             struct wined3d_shader_src_param src, rel_addr;
 529
 530             fe->shader_read_src_param(fe_data, &pToken, &src, &rel_addr);
 531             reg_maps->labels[src.reg.idx] = 1;
 532         }
 533         /* Set texture, address, temporary registers */
 534         else
 535         {
 536             int i, limit;
 537
 538             /* This will loop over all the registers and try to
 539              * make a bitmask of the ones we're interested in.
 540              *
 541              * Relative addressing tokens are ignored, but that's
 542              * okay, since we'll catch any address registers when
 543              * they are initialized (required by spec) */
 544
 545             if (ins.dst_count)
 546             {
 547                 struct wined3d_shader_dst_param dst_param;
 548                 struct wined3d_shader_src_param dst_rel_addr;
 549
 550                 fe->shader_read_dst_param(fe_data, &pToken, &dst_param, &dst_rel_addr);
 551
 552                 /* WINED3DSPR_TEXCRDOUT is the same as WINED3DSPR_OUTPUT. _OUTPUT can be > MAX_REG_TEXCRD and
 553                  * is used in >= 3.0 shaders. Filter 3.0 shaders to prevent overflows, and also filter pixel
 554                  * shaders because TECRDOUT isn't used in them, but future register types might cause issues */
 555                 if (!pshader && shader_version.major < 3 && dst_param.reg.type == WINED3DSPR_TEXCRDOUT)
 556                 {
 557                     reg_maps->texcoord_mask[dst_param.reg.type] |= dst_param.write_mask;
 558                 }
 559                 else
 560                 {
 561                     shader_record_register_usage(This, reg_maps, &dst_param.reg, pshader);
 562                 }
 563
 564                 /* Declare 1.X samplers implicitly, based on the destination reg. number */
 565                 if (shader_version.major == 1
 566                         && pshader /* Filter different instructions with the same enum values in VS */
 567                         && (ins.handler_idx == WINED3DSIH_TEX
 568                             || ins.handler_idx == WINED3DSIH_TEXBEM
 569                             || ins.handler_idx == WINED3DSIH_TEXBEML
 570                             || ins.handler_idx == WINED3DSIH_TEXDP3TEX
 571                             || ins.handler_idx == WINED3DSIH_TEXM3x2TEX
 572                             || ins.handler_idx == WINED3DSIH_TEXM3x3SPEC
 573                             || ins.handler_idx == WINED3DSIH_TEXM3x3TEX
 574                             || ins.handler_idx == WINED3DSIH_TEXM3x3VSPEC
 575                             || ins.handler_idx == WINED3DSIH_TEXREG2AR
 576                             || ins.handler_idx == WINED3DSIH_TEXREG2GB
 577                             || ins.handler_idx == WINED3DSIH_TEXREG2RGB))
 578                 {
 579                     /* Fake sampler usage, only set reserved bit and ttype */
 580                     DWORD sampler_code = dst_param.reg.idx;
 581
 582                     TRACE("Setting fake 2D sampler for 1.x pixelshader\n");
 583                     reg_maps->sampler_type[sampler_code] = WINED3DSTT_2D;
 584
 585                     /* texbem is only valid with < 1.4 pixel shaders */
 586                     if (ins.handler_idx == WINED3DSIH_TEXBEM
 587                             || ins.handler_idx == WINED3DSIH_TEXBEML)
 588                     {
 589                         reg_maps->bumpmat[sampler_code] = TRUE;
 590                         if (ins.handler_idx == WINED3DSIH_TEXBEML)
 591                         {
 592                             reg_maps->luminanceparams[sampler_code] = TRUE;
 593                         }
 594                     }
 595                 }
 596                 else if (pshader && ins.handler_idx == WINED3DSIH_BEM)
 597                 {
 598                     reg_maps->bumpmat[dst_param.reg.idx] = TRUE;
 599                 }
 600             }
 601
 602             if (ins.handler_idx == WINED3DSIH_NRM)
 603             {
 604                 reg_maps->usesnrm = 1;
 605             }
 606             else if (ins.handler_idx == WINED3DSIH_DSY)
 607             {
 608                 reg_maps->usesdsy = 1;
 609             }
 610             else if(ins.handler_idx == WINED3DSIH_TEXLDD)
 611             {
 612                 reg_maps->usestexldd = 1;
 613             }
 614             else if(ins.handler_idx == WINED3DSIH_MOVA)
 615             {
 616                 reg_maps->usesmova = 1;
 617             }
 618
 619             limit = ins.src_count + (ins.predicate ? 1 : 0);
 620             for (i = 0; i < limit; ++i)
 621             {
 622                 struct wined3d_shader_src_param src_param, src_rel_addr;
 623                 unsigned int count;
 624
 625                 fe->shader_read_src_param(fe_data, &pToken, &src_param, &src_rel_addr);
 626                 count = get_instr_extra_regcount(ins.handler_idx, i);
 627
 628                 shader_record_register_usage(This, reg_maps, &src_param.reg, pshader);
 629                 while (count)
 630                 {
 631                     ++src_param.reg.idx;
 632                     shader_record_register_usage(This, reg_maps, &src_param.reg, pshader);
 633                     --count;
 634                 }
 635             }
 636         }
 637     }
 638     reg_maps->loop_depth = max_loop_depth;
 639
 640     This->baseShader.functionLength = ((char *)pToken - (char *)byte_code);
 641
 642     return WINED3D_OK;
 643 }
 644
 645 static void shader_dump_decl_usage(const struct wined3d_shader_semantic *semantic,
 646         const struct wined3d_shader_version *shader_version)
 647 {
 648     TRACE("dcl");
 649
 650     if (semantic->reg.reg.type == WINED3DSPR_SAMPLER)
 651     {
 652         switch (semantic->sampler_type)
 653         {
 654             case WINED3DSTT_2D: TRACE("_2d"); break;
 655             case WINED3DSTT_CUBE: TRACE("_cube"); break;
 656             case WINED3DSTT_VOLUME: TRACE("_volume"); break;
 657             default: TRACE("_unknown_ttype(0x%08x)", semantic->sampler_type);
 658         }
 659     }
 660     else
 661     {
 662         /* Pixel shaders 3.0 don't have usage semantics */
 663         if (shader_is_pshader_version(shader_version->type) && shader_version->major < 3)
 664             return;
 665         else
 666             TRACE("_");
 667
 668         switch (semantic->usage)
 669         {
 670             case WINED3DDECLUSAGE_POSITION:
 671                 TRACE("position%d", semantic->usage_idx);
 672                 break;
 673             case WINED3DDECLUSAGE_BLENDINDICES:
 674                 TRACE("blend");
 675                 break;
 676             case WINED3DDECLUSAGE_BLENDWEIGHT:
 677                 TRACE("weight");
 678                 break;
 679             case WINED3DDECLUSAGE_NORMAL:
 680                 TRACE("normal%d", semantic->usage_idx);
 681                 break;
 682             case WINED3DDECLUSAGE_PSIZE:
 683                 TRACE("psize");
 684                 break;
 685             case WINED3DDECLUSAGE_COLOR:
 686                 if (semantic->usage_idx == 0) TRACE("color");
 687                 else TRACE("specular%d", (semantic->usage_idx - 1));
 688                 break;
 689             case WINED3DDECLUSAGE_TEXCOORD:
 690                 TRACE("texture%d", semantic->usage_idx);
 691                 break;
 692             case WINED3DDECLUSAGE_TANGENT:
 693                 TRACE("tangent");
 694                 break;
 695             case WINED3DDECLUSAGE_BINORMAL:
 696                 TRACE("binormal");
 697                 break;
 698             case WINED3DDECLUSAGE_TESSFACTOR:
 699                 TRACE("tessfactor");
 700                 break;
 701             case WINED3DDECLUSAGE_POSITIONT:
 702                 TRACE("positionT%d", semantic->usage_idx);
 703                 break;
 704             case WINED3DDECLUSAGE_FOG:
 705                 TRACE("fog");
 706                 break;
 707             case WINED3DDECLUSAGE_DEPTH:
 708                 TRACE("depth");
 709                 break;
 710             case WINED3DDECLUSAGE_SAMPLE:
 711                 TRACE("sample");
 712                 break;
 713             default:
 714                 FIXME("unknown_semantics(0x%08x)", semantic->usage);
 715         }
 716     }
 717 }
 718
 719 static void shader_dump_register(const struct wined3d_shader_register *reg,
 720         const struct wined3d_shader_version *shader_version)
 721 {
 722     static const char * const rastout_reg_names[] = {"oPos", "oFog", "oPts"};
 723     static const char * const misctype_reg_names[] = {"vPos", "vFace"};
 724     UINT offset = reg->idx;
 725
 726     switch (reg->type)
 727     {
 728         case WINED3DSPR_TEMP:
 729             TRACE("r");
 730             break;
 731
 732         case WINED3DSPR_INPUT:
 733             TRACE("v");
 734             break;
 735
 736         case WINED3DSPR_CONST:
 737         case WINED3DSPR_CONST2:
 738         case WINED3DSPR_CONST3:
 739         case WINED3DSPR_CONST4:
 740             TRACE("c");
 741             offset = shader_get_float_offset(reg->type, reg->idx);
 742             break;
 743
 744         case WINED3DSPR_TEXTURE: /* vs: case WINED3DSPR_ADDR */
 745             TRACE("%c", shader_is_pshader_version(shader_version->type) ? 't' : 'a');
 746             break;
 747
 748         case WINED3DSPR_RASTOUT:
 749             TRACE("%s", rastout_reg_names[reg->idx]);
 750             break;
 751
 752         case WINED3DSPR_COLOROUT:
 753             TRACE("oC");
 754             break;
 755
 756         case WINED3DSPR_DEPTHOUT:
 757             TRACE("oDepth");
 758             break;
 759
 760         case WINED3DSPR_ATTROUT:
 761             TRACE("oD");
 762             break;
 763
 764         case WINED3DSPR_TEXCRDOUT:
 765             /* Vertex shaders >= 3.0 use general purpose output registers
 766              * (WINED3DSPR_OUTPUT), which can include an address token */
 767             if (shader_version->major >= 3) TRACE("o");
 768             else TRACE("oT");
 769             break;
 770
 771         case WINED3DSPR_CONSTINT:
 772             TRACE("i");
 773             break;
 774
 775         case WINED3DSPR_CONSTBOOL:
 776             TRACE("b");
 777             break;
 778
 779         case WINED3DSPR_LABEL:
 780             TRACE("l");
 781             break;
 782
 783         case WINED3DSPR_LOOP:
 784             TRACE("aL");
 785             break;
 786
 787         case WINED3DSPR_SAMPLER:
 788             TRACE("s");
 789             break;
 790
 791         case WINED3DSPR_MISCTYPE:
 792             if (reg->idx > 1) FIXME("Unhandled misctype register %d\n", reg->idx);
 793             else TRACE("%s", misctype_reg_names[reg->idx]);
 794             break;
 795
 796         case WINED3DSPR_PREDICATE:
 797             TRACE("p");
 798             break;
 799
 800         case WINED3DSPR_IMMCONST:
 801             TRACE("l");
 802             break;
 803
 804         default:
 805             TRACE("unhandled_rtype(%#x)", reg->type);
 806             break;
 807     }
 808
 809     if (reg->type == WINED3DSPR_IMMCONST)
 810     {
 811         TRACE("(");
 812         switch (reg->immconst_type)
 813         {
 814             case WINED3D_IMMCONST_FLOAT:
 815                 TRACE("%.8e", *(float *)reg->immconst_data);
 816                 break;
 817
 818             case WINED3D_IMMCONST_FLOAT4:
 819                 TRACE("%.8e, %.8e, %.8e, %.8e",
 820                         *(float *)&reg->immconst_data[0], *(float *)&reg->immconst_data[1],
 821                         *(float *)&reg->immconst_data[2], *(float *)&reg->immconst_data[3]);
 822                 break;
 823
 824             default:
 825                 TRACE("<unhandled immconst_type %#x>", reg->immconst_type);
 826                 break;
 827         }
 828         TRACE(")");
 829     }
 830     else if (reg->type != WINED3DSPR_RASTOUT && reg->type != WINED3DSPR_MISCTYPE)
 831     {
 832         if (reg->rel_addr)
 833         {
 834             TRACE("[");
 835             shader_dump_src_param(reg->rel_addr, shader_version);
 836             TRACE(" + ");
 837         }
 838         TRACE("%u", offset);
 839         if (reg->rel_addr) TRACE("]");
 840     }
 841 }
 842
 843 void shader_dump_dst_param(const struct wined3d_shader_dst_param *param,
 844         const struct wined3d_shader_version *shader_version)
 845 {
 846     DWORD write_mask = param->write_mask;
 847
 848     shader_dump_register(&param->reg, shader_version);
 849
 850     if (write_mask != WINED3DSP_WRITEMASK_ALL)
 851     {
 852         static const char *write_mask_chars = "xyzw";
 853
 854         TRACE(".");
 855         if (write_mask & WINED3DSP_WRITEMASK_0) TRACE("%c", write_mask_chars[0]);
 856         if (write_mask & WINED3DSP_WRITEMASK_1) TRACE("%c", write_mask_chars[1]);
 857         if (write_mask & WINED3DSP_WRITEMASK_2) TRACE("%c", write_mask_chars[2]);
 858         if (write_mask & WINED3DSP_WRITEMASK_3) TRACE("%c", write_mask_chars[3]);
 859     }
 860 }
 861
 862 void shader_dump_src_param(const struct wined3d_shader_src_param *param,
 863         const struct wined3d_shader_version *shader_version)
 864 {
 865     DWORD src_modifier = param->modifiers;
 866     DWORD swizzle = param->swizzle;
 867
 868     if (src_modifier == WINED3DSPSM_NEG
 869             || src_modifier == WINED3DSPSM_BIASNEG
 870             || src_modifier == WINED3DSPSM_SIGNNEG
 871             || src_modifier == WINED3DSPSM_X2NEG
 872             || src_modifier == WINED3DSPSM_ABSNEG)
 873         TRACE("-");
 874     else if (src_modifier == WINED3DSPSM_COMP)
 875         TRACE("1-");
 876     else if (src_modifier == WINED3DSPSM_NOT)
 877         TRACE("!");
 878
 879     if (src_modifier == WINED3DSPSM_ABS || src_modifier == WINED3DSPSM_ABSNEG)
 880         TRACE("abs(");
 881
 882     shader_dump_register(&param->reg, shader_version);
 883
 884     if (src_modifier)
 885     {
 886         switch (src_modifier)
 887         {
 888             case WINED3DSPSM_NONE:    break;
 889             case WINED3DSPSM_NEG:     break;
 890             case WINED3DSPSM_NOT:     break;
 891             case WINED3DSPSM_BIAS:    TRACE("_bias"); break;
 892             case WINED3DSPSM_BIASNEG: TRACE("_bias"); break;
 893             case WINED3DSPSM_SIGN:    TRACE("_bx2"); break;
 894             case WINED3DSPSM_SIGNNEG: TRACE("_bx2"); break;
 895             case WINED3DSPSM_COMP:    break;
 896             case WINED3DSPSM_X2:      TRACE("_x2"); break;
 897             case WINED3DSPSM_X2NEG:   TRACE("_x2"); break;
 898             case WINED3DSPSM_DZ:      TRACE("_dz"); break;
 899             case WINED3DSPSM_DW:      TRACE("_dw"); break;
 900             case WINED3DSPSM_ABSNEG:  TRACE(")"); break;
 901             case WINED3DSPSM_ABS:     TRACE(")"); break;
 902             default:
 903                                       TRACE("_unknown_modifier(%#x)", src_modifier);
 904         }
 905     }
 906
 907     if (swizzle != WINED3DSP_NOSWIZZLE)
 908     {
 909         static const char *swizzle_chars = "xyzw";
 910         DWORD swizzle_x = swizzle & 0x03;
 911         DWORD swizzle_y = (swizzle >> 2) & 0x03;
 912         DWORD swizzle_z = (swizzle >> 4) & 0x03;
 913         DWORD swizzle_w = (swizzle >> 6) & 0x03;
 914
 915         if (swizzle_x == swizzle_y
 916                 && swizzle_x == swizzle_z
 917                 && swizzle_x == swizzle_w)
 918         {
 919             TRACE(".%c", swizzle_chars[swizzle_x]);
 920         }
 921         else
 922         {
 923             TRACE(".%c%c%c%c", swizzle_chars[swizzle_x], swizzle_chars[swizzle_y],
 924                     swizzle_chars[swizzle_z], swizzle_chars[swizzle_w]);
 925         }
 926     }
 927 }
 928
 929 /* Shared code in order to generate the bulk of the shader string.
 930  * NOTE: A description of how to parse tokens can be found on msdn */
 931 void shader_generate_main(IWineD3DBaseShader *iface, SHADER_BUFFER *buffer,
 932         const shader_reg_maps *reg_maps, const DWORD *pFunction, void *backend_ctx)
 933 {
 934     IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
 935     IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) This->baseShader.device; /* To access shader backend callbacks */
 936     const SHADER_HANDLER *handler_table = device->shader_backend->shader_instruction_handler_table;
 937     const struct wined3d_shader_frontend *fe = This->baseShader.frontend;
 938     void *fe_data = This->baseShader.frontend_data;
 939     struct wined3d_shader_src_param src_rel_addr[4];
 940     struct wined3d_shader_src_param src_param[4];
 941     struct wined3d_shader_version shader_version;
 942     struct wined3d_shader_src_param dst_rel_addr;
 943     struct wined3d_shader_dst_param dst_param;
 944     struct wined3d_shader_instruction ins;
 945     struct wined3d_shader_context ctx;
 946     const DWORD *pToken = pFunction;
 947     SHADER_HANDLER hw_fct;
 948     DWORD i;
 949
 950     /* Initialize current parsing state */
 951     ctx.shader = iface;
 952     ctx.reg_maps = reg_maps;
 953     ctx.buffer = buffer;
 954     ctx.backend_data = backend_ctx;
 955
 956     ins.ctx = &ctx;
 957     ins.dst = &dst_param;
 958     ins.src = src_param;
 959     This->baseShader.parse_state.current_row = 0;
 960
 961     fe->shader_read_header(fe_data, &pToken, &shader_version);
 962
 963     while (!fe->shader_is_end(fe_data, &pToken))
 964     {
 965         const char *comment;
 966         UINT param_size;
 967
 968         /* Skip comment tokens */
 969         fe->shader_read_comment(&pToken, &comment);
 970         if (comment) continue;
 971
 972         /* Read opcode */
 973         fe->shader_read_opcode(fe_data, &pToken, &ins, &param_size);
 974
 975         /* Unknown opcode and its parameters */
 976         if (ins.handler_idx == WINED3DSIH_TABLE_SIZE)
 977         {
 978             TRACE("Skipping unrecognized instruction.\n");
 979             pToken += param_size;
 980             continue;
 981         }
 982
 983         /* Nothing to do */
 984         if (ins.handler_idx == WINED3DSIH_DCL
 985                 || ins.handler_idx == WINED3DSIH_NOP
 986                 || ins.handler_idx == WINED3DSIH_DEF
 987                 || ins.handler_idx == WINED3DSIH_DEFI
 988                 || ins.handler_idx == WINED3DSIH_DEFB
 989                 || ins.handler_idx == WINED3DSIH_PHASE
 990                 || ins.handler_idx == WINED3DSIH_RET)
 991         {
 992             pToken += param_size;
 993             continue;
 994         }
 995
 996         /* Select handler */
 997         hw_fct = handler_table[ins.handler_idx];
 998
 999         /* Unhandled opcode */
1000         if (!hw_fct)
1001         {
1002             FIXME("Backend can't handle opcode %#x\n", ins.handler_idx);
1003             pToken += param_size;
1004             continue;
1005         }
1006
1007         /* Destination token */
1008         if (ins.dst_count) fe->shader_read_dst_param(fe_data, &pToken, &dst_param, &dst_rel_addr);
1009
1010         /* Predication token */
1011         if (ins.predicate) ins.predicate = *pToken++;
1012
1013         /* Other source tokens */
1014         for (i = 0; i < ins.src_count; ++i)
1015         {
1016             fe->shader_read_src_param(fe_data, &pToken, &src_param[i], &src_rel_addr[i]);
1017         }
1018
1019         /* Call appropriate function for output target */
1020         hw_fct(&ins);
1021
1022         /* Process instruction modifiers for GLSL apps ( _sat, etc. ) */
1023         device->shader_backend->shader_add_instruction_modifiers(&ins);
1024     }
1025 }
1026
1027 static void shader_dump_ins_modifiers(const struct wined3d_shader_dst_param *dst)
1028 {
1029     DWORD mmask = dst->modifiers;
1030
1031     switch (dst->shift)
1032     {
1033         case 0: break;
1034         case 13: TRACE("_d8"); break;
1035         case 14: TRACE("_d4"); break;
1036         case 15: TRACE("_d2"); break;
1037         case 1: TRACE("_x2"); break;
1038         case 2: TRACE("_x4"); break;
1039         case 3: TRACE("_x8"); break;
1040         default: TRACE("_unhandled_shift(%d)", dst->shift); break;
1041     }
1042
1043     if (mmask & WINED3DSPDM_SATURATE)         TRACE("_sat");
1044     if (mmask & WINED3DSPDM_PARTIALPRECISION) TRACE("_pp");
1045     if (mmask & WINED3DSPDM_MSAMPCENTROID)    TRACE("_centroid");
1046
1047     mmask &= ~(WINED3DSPDM_SATURATE | WINED3DSPDM_PARTIALPRECISION | WINED3DSPDM_MSAMPCENTROID);
1048     if (mmask)
1049         FIXME("_unrecognized_modifier(%#x)", mmask);
1050 }
1051
1052 void shader_trace_init(const struct wined3d_shader_frontend *fe, void *fe_data, const DWORD *pFunction)
1053 {
1054     struct wined3d_shader_version shader_version;
1055     const DWORD* pToken = pFunction;
1056     DWORD i;
1057
1058     TRACE("Parsing %p\n", pFunction);
1059
1060     fe->shader_read_header(fe_data, &pToken, &shader_version);
1061
1062     TRACE("%s_%u_%u\n", shader_is_pshader_version(shader_version.type) ? "ps": "vs",
1063             shader_version.major, shader_version.minor);
1064
1065     while (!fe->shader_is_end(fe_data, &pToken))
1066     {
1067         struct wined3d_shader_instruction ins;
1068         const char *comment;
1069         UINT param_size;
1070
1071         /* comment */
1072         fe->shader_read_comment(&pToken, &comment);
1073         if (comment)
1074         {
1075             TRACE("//%s\n", comment);
1076             continue;
1077         }
1078
1079         fe->shader_read_opcode(fe_data, &pToken, &ins, &param_size);
1080         if (ins.handler_idx == WINED3DSIH_TABLE_SIZE)
1081         {
1082             TRACE("Skipping unrecognized instruction.\n");
1083             pToken += param_size;
1084             continue;
1085         }
1086
1087         if (ins.handler_idx == WINED3DSIH_DCL)
1088         {
1089             struct wined3d_shader_semantic semantic;
1090
1091             fe->shader_read_semantic(&pToken, &semantic);
1092
1093             shader_dump_decl_usage(&semantic, &shader_version);
1094             shader_dump_ins_modifiers(&semantic.reg);
1095             TRACE(" ");
1096             shader_dump_dst_param(&semantic.reg, &shader_version);
1097         }
1098         else if (ins.handler_idx == WINED3DSIH_DEF)
1099         {
1100             struct wined3d_shader_dst_param dst;
1101             struct wined3d_shader_src_param rel_addr;
1102
1103             fe->shader_read_dst_param(fe_data, &pToken, &dst, &rel_addr);
1104
1105             TRACE("def c%u = %f, %f, %f, %f", shader_get_float_offset(dst.reg.type, dst.reg.idx),
1106                     *(const float *)(pToken),
1107                     *(const float *)(pToken + 1),
1108                     *(const float *)(pToken + 2),
1109                     *(const float *)(pToken + 3));
1110             pToken += 4;
1111         }
1112         else if (ins.handler_idx == WINED3DSIH_DEFI)
1113         {
1114             struct wined3d_shader_dst_param dst;
1115             struct wined3d_shader_src_param rel_addr;
1116
1117             fe->shader_read_dst_param(fe_data, &pToken, &dst, &rel_addr);
1118
1119             TRACE("defi i%u = %d, %d, %d, %d", dst.reg.idx,
1120                     *(pToken),
1121                     *(pToken + 1),
1122                     *(pToken + 2),
1123                     *(pToken + 3));
1124             pToken += 4;
1125         }
1126         else if (ins.handler_idx == WINED3DSIH_DEFB)
1127         {
1128             struct wined3d_shader_dst_param dst;
1129             struct wined3d_shader_src_param rel_addr;
1130
1131             fe->shader_read_dst_param(fe_data, &pToken, &dst, &rel_addr);
1132
1133             TRACE("defb b%u = %s", dst.reg.idx, *pToken ? "true" : "false");
1134             ++pToken;
1135         }
1136         else
1137         {
1138             struct wined3d_shader_src_param dst_rel_addr, src_rel_addr;
1139             struct wined3d_shader_dst_param dst_param;
1140             struct wined3d_shader_src_param src_param;
1141
1142             if (ins.dst_count)
1143             {
1144                 fe->shader_read_dst_param(fe_data, &pToken, &dst_param, &dst_rel_addr);
1145             }
1146
1147             /* Print out predication source token first - it follows
1148              * the destination token. */
1149             if (ins.predicate)
1150             {
1151                 fe->shader_read_src_param(fe_data, &pToken, &src_param, &src_rel_addr);
1152                 TRACE("(");
1153                 shader_dump_src_param(&src_param, &shader_version);
1154                 TRACE(") ");
1155             }
1156
1157             /* PixWin marks instructions with the coissue flag with a '+' */
1158             if (ins.coissue) TRACE("+");
1159
1160             TRACE("%s", shader_opcode_names[ins.handler_idx]);
1161
1162             if (ins.handler_idx == WINED3DSIH_IFC
1163                     || ins.handler_idx == WINED3DSIH_BREAKC)
1164             {
1165                 switch (ins.flags)
1166                 {
1167                     case COMPARISON_GT: TRACE("_gt"); break;
1168                     case COMPARISON_EQ: TRACE("_eq"); break;
1169                     case COMPARISON_GE: TRACE("_ge"); break;
1170                     case COMPARISON_LT: TRACE("_lt"); break;
1171                     case COMPARISON_NE: TRACE("_ne"); break;
1172                     case COMPARISON_LE: TRACE("_le"); break;
1173                     default: TRACE("_(%u)", ins.flags);
1174                 }
1175             }
1176             else if (ins.handler_idx == WINED3DSIH_TEX
1177                     && shader_version.major >= 2
1178                     && (ins.flags & WINED3DSI_TEXLD_PROJECT))
1179             {
1180                 TRACE("p");
1181             }
1182
1183             /* We already read the destination token, print it. */
1184             if (ins.dst_count)
1185             {
1186                 shader_dump_ins_modifiers(&dst_param);
1187                 TRACE(" ");
1188                 shader_dump_dst_param(&dst_param, &shader_version);
1189             }
1190
1191             /* Other source tokens */
1192             for (i = ins.dst_count; i < (ins.dst_count + ins.src_count); ++i)
1193             {
1194                 fe->shader_read_src_param(fe_data, &pToken, &src_param, &src_rel_addr);
1195                 TRACE(!i ? " " : ", ");
1196                 shader_dump_src_param(&src_param, &shader_version);
1197             }
1198         }
1199         TRACE("\n");
1200     }
1201 }
1202
1203 void shader_cleanup(IWineD3DBaseShader *iface)
1204 {
1205     IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl *)iface;
1206
1207     ((IWineD3DDeviceImpl *)This->baseShader.device)->shader_backend->shader_destroy(iface);
1208     HeapFree(GetProcessHeap(), 0, This->baseShader.reg_maps.constf);
1209     HeapFree(GetProcessHeap(), 0, This->baseShader.function);
1210     shader_delete_constant_list(&This->baseShader.constantsF);
1211     shader_delete_constant_list(&This->baseShader.constantsB);
1212     shader_delete_constant_list(&This->baseShader.constantsI);
1213     list_remove(&This->baseShader.shader_list_entry);
1214
1215     if (This->baseShader.frontend && This->baseShader.frontend_data)
1216     {
1217         This->baseShader.frontend->shader_free(This->baseShader.frontend_data);
1218     }
1219 }
1220
1221 static const SHADER_HANDLER shader_none_instruction_handler_table[WINED3DSIH_TABLE_SIZE] = {0};
1222 static void shader_none_select(IWineD3DDevice *iface, BOOL usePS, BOOL useVS) {}
1223 static void shader_none_select_depth_blt(IWineD3DDevice *iface, enum tex_types tex_type) {}
1224 static void shader_none_deselect_depth_blt(IWineD3DDevice *iface) {}
1225 static void shader_none_update_float_vertex_constants(IWineD3DDevice *iface, UINT start, UINT count) {}
1226 static void shader_none_update_float_pixel_constants(IWineD3DDevice *iface, UINT start, UINT count) {}
1227 static void shader_none_load_constants(IWineD3DDevice *iface, char usePS, char useVS) {}
1228 static void shader_none_load_np2fixup_constants(IWineD3DDevice *iface, char usePS, char useVS) {}
1229 static void shader_none_destroy(IWineD3DBaseShader *iface) {}
1230 static HRESULT shader_none_alloc(IWineD3DDevice *iface) {return WINED3D_OK;}
1231 static void shader_none_free(IWineD3DDevice *iface) {}
1232 static BOOL shader_none_dirty_const(IWineD3DDevice *iface) {return FALSE;}
1233 static GLuint shader_none_generate_pshader(IWineD3DPixelShader *iface,
1234         SHADER_BUFFER *buffer, const struct ps_compile_args *args)
1235 {
1236     FIXME("NONE shader backend asked to generate a pixel shader\n");
1237     return 0;
1238 }
1239 static GLuint shader_none_generate_vshader(IWineD3DVertexShader *iface,
1240         SHADER_BUFFER *buffer, const struct vs_compile_args *args)
1241 {
1242     FIXME("NONE shader backend asked to generate a vertex shader\n");
1243     return 0;
1244 }
1245 static void shader_none_add_instruction_modifiers(const struct wined3d_shader_instruction *ins) {}
1246
1247 #define GLINFO_LOCATION      (*gl_info)
1248 static void shader_none_get_caps(WINED3DDEVTYPE devtype, const WineD3D_GL_Info *gl_info, struct shader_caps *pCaps)
1249 {
1250     /* Set the shader caps to 0 for the none shader backend */
1251     pCaps->VertexShaderVersion  = 0;
1252     pCaps->PixelShaderVersion    = 0;
1253     pCaps->PixelShader1xMaxValue = 0.0;
1254 }
1255 #undef GLINFO_LOCATION
1256 static BOOL shader_none_color_fixup_supported(struct color_fixup_desc fixup)
1257 {
1258     if (TRACE_ON(d3d_shader) && TRACE_ON(d3d))
1259     {
1260         TRACE("Checking support for fixup:\n");
1261         dump_color_fixup_desc(fixup);
1262     }
1263
1264     /* Faked to make some apps happy. */
1265     if (!is_yuv_fixup(fixup))
1266     {
1267         TRACE("[OK]\n");
1268         return TRUE;
1269     }
1270
1271     TRACE("[FAILED]\n");
1272     return FALSE;
1273 }
1274
1275 const shader_backend_t none_shader_backend = {
1276     shader_none_instruction_handler_table,
1277     shader_none_select,
1278     shader_none_select_depth_blt,
1279     shader_none_deselect_depth_blt,
1280     shader_none_update_float_vertex_constants,
1281     shader_none_update_float_pixel_constants,
1282     shader_none_load_constants,
1283     shader_none_load_np2fixup_constants,
1284     shader_none_destroy,
1285     shader_none_alloc,
1286     shader_none_free,
1287     shader_none_dirty_const,
1288     shader_none_generate_pshader,
1289     shader_none_generate_vshader,
1290     shader_none_get_caps,
1291     shader_none_color_fixup_supported,
1292     shader_none_add_instruction_modifiers,
1293 };