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 void shader_buffer_clear(struct wined3d_shader_buffer *buffer)
 142 {
 143     buffer->buffer[0] = '\0';
 144     buffer->bsize = 0;
 145     buffer->lineNo = 0;
 146     buffer->newline = TRUE;
 147 }
 148
 149 BOOL shader_buffer_init(struct wined3d_shader_buffer *buffer)
 150 {
 151     buffer->buffer = HeapAlloc(GetProcessHeap(), 0, SHADER_PGMSIZE);
 152     if (!buffer->buffer)
 153     {
 154         ERR("Failed to allocate shader buffer memory.\n");
 155         return FALSE;
 156     }
 157
 158     shader_buffer_clear(buffer);
 159     return TRUE;
 160 }
 161
 162 void shader_buffer_free(struct wined3d_shader_buffer *buffer)
 163 {
 164     HeapFree(GetProcessHeap(), 0, buffer->buffer);
 165 }
 166
 167 int shader_vaddline(struct wined3d_shader_buffer *buffer, const char *format, va_list args)
 168 {
 169     char* base = buffer->buffer + buffer->bsize;
 170     int rc;
 171
 172     rc = vsnprintf(base, SHADER_PGMSIZE - 1 - buffer->bsize, format, args);
 173
 174     if (rc < 0 /* C89 */ || (unsigned int)rc > SHADER_PGMSIZE - 1 - buffer->bsize /* C99 */)
 175     {
 176         ERR("The buffer allocated for the shader program string "
 177             "is too small at %d bytes.\n", SHADER_PGMSIZE);
 178         buffer->bsize = SHADER_PGMSIZE - 1;
 179         return -1;
 180     }
 181
 182     if (buffer->newline) {
 183         TRACE("GL HW (%u, %u) : %s", buffer->lineNo + 1, buffer->bsize, base);
 184         buffer->newline = FALSE;
 185     } else {
 186         TRACE("%s", base);
 187     }
 188
 189     buffer->bsize += rc;
 190     if (buffer->buffer[buffer->bsize-1] == '\n') {
 191         buffer->lineNo++;
 192         buffer->newline = TRUE;
 193     }
 194     return 0;
 195 }
 196
 197 int shader_addline(struct wined3d_shader_buffer *buffer, const char *format, ...)
 198 {
 199     int ret;
 200     va_list args;
 201
 202     va_start(args, format);
 203     ret = shader_vaddline(buffer, format, args);
 204     va_end(args);
 205
 206     return ret;
 207 }
 208
 209 void shader_init(struct IWineD3DBaseShaderClass *shader, IWineD3DDevice *device)
 210 {
 211     shader->ref = 1;
 212     shader->device = device;
 213     list_init(&shader->linked_programs);
 214 }
 215
 216 /* Convert floating point offset relative
 217  * to a register file to an absolute offset for float constants */
 218 static unsigned int shader_get_float_offset(WINED3DSHADER_PARAM_REGISTER_TYPE register_type, UINT register_idx)
 219 {
 220     switch (register_type)
 221     {
 222         case WINED3DSPR_CONST: return register_idx;
 223         case WINED3DSPR_CONST2: return 2048 + register_idx;
 224         case WINED3DSPR_CONST3: return 4096 + register_idx;
 225         case WINED3DSPR_CONST4: return 6144 + register_idx;
 226         default:
 227             FIXME("Unsupported register type: %d\n", register_type);
 228             return register_idx;
 229     }
 230 }
 231
 232 static void shader_delete_constant_list(struct list* clist) {
 233
 234     struct list *ptr;
 235     struct local_constant* constant;
 236
 237     ptr = list_head(clist);
 238     while (ptr) {
 239         constant = LIST_ENTRY(ptr, struct local_constant, entry);
 240         ptr = list_next(clist, ptr);
 241         HeapFree(GetProcessHeap(), 0, constant);
 242     }
 243     list_init(clist);
 244 }
 245
 246 static inline void set_bitmap_bit(DWORD *bitmap, DWORD bit)
 247 {
 248     DWORD idx, shift;
 249     idx = bit >> 5;
 250     shift = bit & 0x1f;
 251     bitmap[idx] |= (1 << shift);
 252 }
 253
 254 static void shader_record_register_usage(IWineD3DBaseShaderImpl *This, struct shader_reg_maps *reg_maps,
 255         const struct wined3d_shader_register *reg, enum wined3d_shader_type shader_type)
 256 {
 257     switch (reg->type)
 258     {
 259         case WINED3DSPR_TEXTURE: /* WINED3DSPR_ADDR */
 260             if (shader_type == WINED3D_SHADER_TYPE_PIXEL) reg_maps->texcoord[reg->idx] = 1;
 261             else reg_maps->address[reg->idx] = 1;
 262             break;
 263
 264         case WINED3DSPR_TEMP:
 265             reg_maps->temporary[reg->idx] = 1;
 266             break;
 267
 268         case WINED3DSPR_INPUT:
 269             if (shader_type == WINED3D_SHADER_TYPE_PIXEL)
 270             {
 271                 if (reg->rel_addr)
 272                 {
 273                     /* If relative addressing is used, we must assume that all registers
 274                      * are used. Even if it is a construct like v3[aL], we can't assume
 275                      * that v0, v1 and v2 aren't read because aL can be negative */
 276                     unsigned int i;
 277                     for (i = 0; i < MAX_REG_INPUT; ++i)
 278                     {
 279                         ((IWineD3DPixelShaderImpl *)This)->input_reg_used[i] = TRUE;
 280                     }
 281                 }
 282                 else
 283                 {
 284                     ((IWineD3DPixelShaderImpl *)This)->input_reg_used[reg->idx] = TRUE;
 285                 }
 286             }
 287             else reg_maps->input_registers |= 1 << reg->idx;
 288             break;
 289
 290         case WINED3DSPR_RASTOUT:
 291             if (reg->idx == 1) reg_maps->fog = 1;
 292             break;
 293
 294         case WINED3DSPR_MISCTYPE:
 295             if (shader_type == WINED3D_SHADER_TYPE_PIXEL)
 296             {
 297                 if (reg->idx == 0) reg_maps->vpos = 1;
 298                 else if (reg->idx == 1) reg_maps->usesfacing = 1;
 299             }
 300             break;
 301
 302         case WINED3DSPR_CONST:
 303             if (reg->rel_addr)
 304             {
 305                 if (shader_type != WINED3D_SHADER_TYPE_PIXEL)
 306                 {
 307                     if (reg->idx < ((IWineD3DVertexShaderImpl *)This)->min_rel_offset)
 308                     {
 309                         ((IWineD3DVertexShaderImpl *)This)->min_rel_offset = reg->idx;
 310                     }
 311                     if (reg->idx > ((IWineD3DVertexShaderImpl *)This)->max_rel_offset)
 312                     {
 313                         ((IWineD3DVertexShaderImpl *)This)->max_rel_offset = reg->idx;
 314                     }
 315                 }
 316                 reg_maps->usesrelconstF = TRUE;
 317             }
 318             else
 319             {
 320                 set_bitmap_bit(reg_maps->constf, reg->idx);
 321             }
 322             break;
 323
 324         case WINED3DSPR_CONSTINT:
 325             reg_maps->integer_constants |= (1 << reg->idx);
 326             break;
 327
 328         case WINED3DSPR_CONSTBOOL:
 329             reg_maps->boolean_constants |= (1 << reg->idx);
 330             break;
 331
 332         case WINED3DSPR_COLOROUT:
 333             reg_maps->highest_render_target = max(reg_maps->highest_render_target, reg->idx);
 334             break;
 335
 336         default:
 337             TRACE("Not recording register of type %#x and idx %u\n", reg->type, reg->idx);
 338             break;
 339     }
 340 }
 341
 342 static unsigned int get_instr_extra_regcount(enum WINED3D_SHADER_INSTRUCTION_HANDLER instr, unsigned int param)
 343 {
 344     switch(instr)
 345     {
 346         case WINED3DSIH_M4x4:
 347         case WINED3DSIH_M3x4:
 348             return param == 1 ? 3 : 0;
 349
 350         case WINED3DSIH_M4x3:
 351         case WINED3DSIH_M3x3:
 352             return param == 1 ? 2 : 0;
 353
 354         case WINED3DSIH_M3x2:
 355             return param == 1 ? 1 : 0;
 356
 357         default:
 358             return 0;
 359     }
 360 }
 361
 362 static const char *shader_semantic_name_from_usage(WINED3DDECLUSAGE usage)
 363 {
 364     static const char *semantic_names[] =
 365     {
 366         /* WINED3DDECLUSAGE_POSITION        */ "SV_POSITION",
 367         /* WINED3DDECLUSAGE_BLENDWEIGHT     */ "BLENDWEIGHT",
 368         /* WINED3DDECLUSAGE_BLENDINDICES    */ "BLENDINDICES",
 369         /* WINED3DDECLUSAGE_NORMAL          */ "NORMAL",
 370         /* WINED3DDECLUSAGE_PSIZE           */ "PSIZE",
 371         /* WINED3DDECLUSAGE_TEXCOORD        */ "TEXCOORD",
 372         /* WINED3DDECLUSAGE_TANGENT         */ "TANGENT",
 373         /* WINED3DDECLUSAGE_BINORMAL        */ "BINORMAL",
 374         /* WINED3DDECLUSAGE_TESSFACTOR      */ "TESSFACTOR",
 375         /* WINED3DDECLUSAGE_POSITIONT       */ "POSITIONT",
 376         /* WINED3DDECLUSAGE_COLOR           */ "COLOR",
 377         /* WINED3DDECLUSAGE_FOG             */ "FOG",
 378         /* WINED3DDECLUSAGE_DEPTH           */ "DEPTH",
 379         /* WINED3DDECLUSAGE_SAMPLE          */ "SAMPLE",
 380     };
 381
 382     if (usage >= sizeof(semantic_names) / sizeof(*semantic_names))
 383     {
 384         FIXME("Unrecognized usage %#x\n", usage);
 385         return "UNRECOGNIZED";
 386     }
 387
 388     return semantic_names[usage];
 389 }
 390
 391 BOOL shader_match_semantic(const char *semantic_name, WINED3DDECLUSAGE usage)
 392 {
 393     return !strcmp(semantic_name, shader_semantic_name_from_usage(usage));
 394 }
 395
 396 static void shader_signature_from_semantic(struct wined3d_shader_signature_element *e,
 397         const struct wined3d_shader_semantic *s)
 398 {
 399     e->semantic_name = shader_semantic_name_from_usage(s->usage);
 400     e->semantic_idx = s->usage_idx;
 401     e->sysval_semantic = 0;
 402     e->component_type = 0;
 403     e->register_idx = s->reg.reg.idx;
 404     e->mask = s->reg.write_mask;
 405 }
 406
 407 /* Note that this does not count the loop register
 408  * as an address register. */
 409
 410 HRESULT shader_get_registers_used(IWineD3DBaseShader *iface, const struct wined3d_shader_frontend *fe,
 411         struct shader_reg_maps *reg_maps, struct wined3d_shader_attribute *attributes,
 412         struct wined3d_shader_signature_element *input_signature,
 413         struct wined3d_shader_signature_element *output_signature, const DWORD *byte_code, DWORD constf_size)
 414 {
 415     IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
 416     void *fe_data = This->baseShader.frontend_data;
 417     struct wined3d_shader_version shader_version;
 418     unsigned int cur_loop_depth = 0, max_loop_depth = 0;
 419     const DWORD* pToken = byte_code;
 420
 421     /* There are some minor differences between pixel and vertex shaders */
 422
 423     memset(reg_maps, 0, sizeof(*reg_maps));
 424
 425     /* get_registers_used is called on every compile on some 1.x shaders, which can result
 426      * in stacking up a collection of local constants. Delete the old constants if existing
 427      */
 428     shader_delete_constant_list(&This->baseShader.constantsF);
 429     shader_delete_constant_list(&This->baseShader.constantsB);
 430     shader_delete_constant_list(&This->baseShader.constantsI);
 431
 432     fe->shader_read_header(fe_data, &pToken, &shader_version);
 433     reg_maps->shader_version = shader_version;
 434
 435     reg_maps->constf = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 436                                  sizeof(*reg_maps->constf) * ((constf_size + 31) / 32));
 437     if(!reg_maps->constf) {
 438         ERR("Out of memory\n");
 439         return E_OUTOFMEMORY;
 440     }
 441
 442     while (!fe->shader_is_end(fe_data, &pToken))
 443     {
 444         struct wined3d_shader_instruction ins;
 445         const char *comment;
 446         UINT param_size;
 447
 448         /* Skip comments */
 449         fe->shader_read_comment(&pToken, &comment);
 450         if (comment) continue;
 451
 452         /* Fetch opcode */
 453         fe->shader_read_opcode(fe_data, &pToken, &ins, &param_size);
 454
 455         /* Unhandled opcode, and its parameters */
 456         if (ins.handler_idx == WINED3DSIH_TABLE_SIZE)
 457         {
 458             TRACE("Skipping unrecognized instruction.\n");
 459             pToken += param_size;
 460             continue;
 461         }
 462
 463         /* Handle declarations */
 464         if (ins.handler_idx == WINED3DSIH_DCL)
 465         {
 466             struct wined3d_shader_semantic semantic;
 467
 468             fe->shader_read_semantic(&pToken, &semantic);
 469
 470             switch (semantic.reg.reg.type)
 471             {
 472                 /* Vshader: mark attributes used
 473                  * Pshader: mark 3.0 input registers used, save token */
 474                 case WINED3DSPR_INPUT:
 475                     reg_maps->input_registers |= 1 << semantic.reg.reg.idx;
 476                     if (shader_version.type == WINED3D_SHADER_TYPE_VERTEX)
 477                     {
 478                         attributes[semantic.reg.reg.idx].usage = semantic.usage;
 479                         attributes[semantic.reg.reg.idx].usage_idx = semantic.usage_idx;
 480                     }
 481                     else
 482                     {
 483                         shader_signature_from_semantic(&input_signature[semantic.reg.reg.idx], &semantic);
 484                     }
 485                     break;
 486
 487                 /* Vshader: mark 3.0 output registers used, save token */
 488                 case WINED3DSPR_OUTPUT:
 489                     reg_maps->output_registers |= 1 << semantic.reg.reg.idx;
 490                     shader_signature_from_semantic(&output_signature[semantic.reg.reg.idx], &semantic);
 491                     if (semantic.usage == WINED3DDECLUSAGE_FOG) reg_maps->fog = 1;
 492                     break;
 493
 494                 /* Save sampler usage token */
 495                 case WINED3DSPR_SAMPLER:
 496                     reg_maps->sampler_type[semantic.reg.reg.idx] = semantic.sampler_type;
 497                     break;
 498
 499                 default:
 500                     TRACE("Not recording DCL register type %#x.\n", semantic.reg.reg.type);
 501                     break;
 502             }
 503         }
 504         else if (ins.handler_idx == WINED3DSIH_DEF)
 505         {
 506             struct wined3d_shader_dst_param dst;
 507             struct wined3d_shader_src_param rel_addr;
 508
 509             local_constant* lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant));
 510             if (!lconst) return E_OUTOFMEMORY;
 511
 512             fe->shader_read_dst_param(fe_data, &pToken, &dst, &rel_addr);
 513             lconst->idx = dst.reg.idx;
 514
 515             memcpy(lconst->value, pToken, 4 * sizeof(DWORD));
 516             pToken += 4;
 517
 518             /* In pixel shader 1.X shaders, the constants are clamped between [-1;1] */
 519             if (shader_version.major == 1 && shader_version.type == WINED3D_SHADER_TYPE_PIXEL)
 520             {
 521                 float *value = (float *) lconst->value;
 522                 if (value[0] < -1.0f) value[0] = -1.0f;
 523                 else if (value[0] > 1.0f) value[0] = 1.0f;
 524                 if (value[1] < -1.0f) value[1] = -1.0f;
 525                 else if (value[1] > 1.0f) value[1] = 1.0f;
 526                 if (value[2] < -1.0f) value[2] = -1.0f;
 527                 else if (value[2] > 1.0f) value[2] = 1.0f;
 528                 if (value[3] < -1.0f) value[3] = -1.0f;
 529                 else if (value[3] > 1.0f) value[3] = 1.0f;
 530             }
 531
 532             list_add_head(&This->baseShader.constantsF, &lconst->entry);
 533         }
 534         else if (ins.handler_idx == WINED3DSIH_DEFI)
 535         {
 536             struct wined3d_shader_dst_param dst;
 537             struct wined3d_shader_src_param rel_addr;
 538
 539             local_constant* lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant));
 540             if (!lconst) return E_OUTOFMEMORY;
 541
 542             fe->shader_read_dst_param(fe_data, &pToken, &dst, &rel_addr);
 543             lconst->idx = dst.reg.idx;
 544
 545             memcpy(lconst->value, pToken, 4 * sizeof(DWORD));
 546             pToken += 4;
 547
 548             list_add_head(&This->baseShader.constantsI, &lconst->entry);
 549             reg_maps->local_int_consts |= (1 << dst.reg.idx);
 550         }
 551         else if (ins.handler_idx == WINED3DSIH_DEFB)
 552         {
 553             struct wined3d_shader_dst_param dst;
 554             struct wined3d_shader_src_param rel_addr;
 555
 556             local_constant* lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant));
 557             if (!lconst) return E_OUTOFMEMORY;
 558
 559             fe->shader_read_dst_param(fe_data, &pToken, &dst, &rel_addr);
 560             lconst->idx = dst.reg.idx;
 561
 562             memcpy(lconst->value, pToken, sizeof(DWORD));
 563             ++pToken;
 564
 565             list_add_head(&This->baseShader.constantsB, &lconst->entry);
 566             reg_maps->local_bool_consts |= (1 << dst.reg.idx);
 567         }
 568         /* If there's a loop in the shader */
 569         else if (ins.handler_idx == WINED3DSIH_LOOP
 570                 || ins.handler_idx == WINED3DSIH_REP)
 571         {
 572             struct wined3d_shader_src_param src, rel_addr;
 573
 574             fe->shader_read_src_param(fe_data, &pToken, &src, &rel_addr);
 575
 576             /* Rep and Loop always use an integer constant for the control parameters */
 577             if (ins.handler_idx == WINED3DSIH_REP)
 578             {
 579                 reg_maps->integer_constants |= 1 << src.reg.idx;
 580             }
 581             else
 582             {
 583                 fe->shader_read_src_param(fe_data, &pToken, &src, &rel_addr);
 584                 reg_maps->integer_constants |= 1 << src.reg.idx;
 585             }
 586
 587             cur_loop_depth++;
 588             if(cur_loop_depth > max_loop_depth)
 589                 max_loop_depth = cur_loop_depth;
 590         }
 591         else if (ins.handler_idx == WINED3DSIH_ENDLOOP
 592                 || ins.handler_idx == WINED3DSIH_ENDREP)
 593         {
 594             cur_loop_depth--;
 595         }
 596         /* For subroutine prototypes */
 597         else if (ins.handler_idx == WINED3DSIH_LABEL)
 598         {
 599             struct wined3d_shader_src_param src, rel_addr;
 600
 601             fe->shader_read_src_param(fe_data, &pToken, &src, &rel_addr);
 602             reg_maps->labels[src.reg.idx] = 1;
 603         }
 604         /* Set texture, address, temporary registers */
 605         else
 606         {
 607             int i, limit;
 608             BOOL color0_mov = FALSE;
 609
 610             /* This will loop over all the registers and try to
 611              * make a bitmask of the ones we're interested in.
 612              *
 613              * Relative addressing tokens are ignored, but that's
 614              * okay, since we'll catch any address registers when
 615              * they are initialized (required by spec) */
 616
 617             if (ins.dst_count)
 618             {
 619                 struct wined3d_shader_dst_param dst_param;
 620                 struct wined3d_shader_src_param dst_rel_addr;
 621
 622                 fe->shader_read_dst_param(fe_data, &pToken, &dst_param, &dst_rel_addr);
 623
 624                 shader_record_register_usage(This, reg_maps, &dst_param.reg, shader_version.type);
 625
 626                 /* WINED3DSPR_TEXCRDOUT is the same as WINED3DSPR_OUTPUT. _OUTPUT can be > MAX_REG_TEXCRD and
 627                  * is used in >= 3.0 shaders. Filter 3.0 shaders to prevent overflows, and also filter pixel
 628                  * shaders because TECRDOUT isn't used in them, but future register types might cause issues */
 629                 if (shader_version.type == WINED3D_SHADER_TYPE_VERTEX && shader_version.major < 3
 630                         && dst_param.reg.type == WINED3DSPR_TEXCRDOUT)
 631                 {
 632                     reg_maps->texcoord_mask[dst_param.reg.idx] |= dst_param.write_mask;
 633                 }
 634
 635                 if (shader_version.type == WINED3D_SHADER_TYPE_PIXEL)
 636                 {
 637                     IWineD3DPixelShaderImpl *ps = (IWineD3DPixelShaderImpl *)This;
 638
 639                     if(dst_param.reg.type == WINED3DSPR_COLOROUT && dst_param.reg.idx == 0)
 640                     {
 641                     /* Many 2.0 and 3.0 pixel shaders end with a MOV from a temp register to
 642                      * COLOROUT 0. If we know this in advance, the ARB shader backend can skip
 643                      * the mov and perform the sRGB write correction from the source register.
 644                      *
 645                      * However, if the mov is only partial, we can't do this, and if the write
 646                      * comes from an instruction other than MOV it is hard to do as well. If
 647                      * COLOROUT 0 is overwritten partially later, the marker is dropped again. */
 648
 649                         ps->color0_mov = FALSE;
 650                         if (ins.handler_idx == WINED3DSIH_MOV)
 651                         {
 652                             /* Used later when the source register is read. */
 653                             color0_mov = TRUE;
 654                         }
 655                     }
 656                     /* Also drop the MOV marker if the source register is overwritten prior to the shader
 657                      * end
 658                      */
 659                     else if(dst_param.reg.type == WINED3DSPR_TEMP && dst_param.reg.idx == ps->color0_reg)
 660                     {
 661                         ps->color0_mov = FALSE;
 662                     }
 663                 }
 664
 665                 /* Declare 1.X samplers implicitly, based on the destination reg. number */
 666                 if (shader_version.major == 1
 667                         && (ins.handler_idx == WINED3DSIH_TEX
 668                             || ins.handler_idx == WINED3DSIH_TEXBEM
 669                             || ins.handler_idx == WINED3DSIH_TEXBEML
 670                             || ins.handler_idx == WINED3DSIH_TEXDP3TEX
 671                             || ins.handler_idx == WINED3DSIH_TEXM3x2TEX
 672                             || ins.handler_idx == WINED3DSIH_TEXM3x3SPEC
 673                             || ins.handler_idx == WINED3DSIH_TEXM3x3TEX
 674                             || ins.handler_idx == WINED3DSIH_TEXM3x3VSPEC
 675                             || ins.handler_idx == WINED3DSIH_TEXREG2AR
 676                             || ins.handler_idx == WINED3DSIH_TEXREG2GB
 677                             || ins.handler_idx == WINED3DSIH_TEXREG2RGB))
 678                 {
 679                     /* Fake sampler usage, only set reserved bit and ttype */
 680                     DWORD sampler_code = dst_param.reg.idx;
 681
 682                     TRACE("Setting fake 2D sampler for 1.x pixelshader\n");
 683                     reg_maps->sampler_type[sampler_code] = WINED3DSTT_2D;
 684
 685                     /* texbem is only valid with < 1.4 pixel shaders */
 686                     if (ins.handler_idx == WINED3DSIH_TEXBEM
 687                             || ins.handler_idx == WINED3DSIH_TEXBEML)
 688                     {
 689                         reg_maps->bumpmat[sampler_code] = TRUE;
 690                         if (ins.handler_idx == WINED3DSIH_TEXBEML)
 691                         {
 692                             reg_maps->luminanceparams[sampler_code] = TRUE;
 693                         }
 694                     }
 695                 }
 696                 else if (ins.handler_idx == WINED3DSIH_BEM)
 697                 {
 698                     reg_maps->bumpmat[dst_param.reg.idx] = TRUE;
 699                 }
 700             }
 701
 702             if (ins.handler_idx == WINED3DSIH_NRM)
 703             {
 704                 reg_maps->usesnrm = 1;
 705             }
 706             else if (ins.handler_idx == WINED3DSIH_DSY)
 707             {
 708                 reg_maps->usesdsy = 1;
 709             }
 710             else if (ins.handler_idx == WINED3DSIH_DSX)
 711             {
 712                 reg_maps->usesdsx = 1;
 713             }
 714             else if(ins.handler_idx == WINED3DSIH_TEXLDD)
 715             {
 716                 reg_maps->usestexldd = 1;
 717             }
 718             else if(ins.handler_idx == WINED3DSIH_TEXLDL)
 719             {
 720                 reg_maps->usestexldl = 1;
 721             }
 722             else if(ins.handler_idx == WINED3DSIH_MOVA)
 723             {
 724                 reg_maps->usesmova = 1;
 725             }
 726             else if(ins.handler_idx == WINED3DSIH_IFC)
 727             {
 728                 reg_maps->usesifc = 1;
 729             }
 730             else if(ins.handler_idx == WINED3DSIH_CALL)
 731             {
 732                 reg_maps->usescall = 1;
 733             }
 734
 735             limit = ins.src_count + (ins.predicate ? 1 : 0);
 736             for (i = 0; i < limit; ++i)
 737             {
 738                 struct wined3d_shader_src_param src_param, src_rel_addr;
 739                 unsigned int count;
 740
 741                 fe->shader_read_src_param(fe_data, &pToken, &src_param, &src_rel_addr);
 742                 count = get_instr_extra_regcount(ins.handler_idx, i);
 743
 744                 shader_record_register_usage(This, reg_maps, &src_param.reg, shader_version.type);
 745                 while (count)
 746                 {
 747                     ++src_param.reg.idx;
 748                     shader_record_register_usage(This, reg_maps, &src_param.reg, shader_version.type);
 749                     --count;
 750                 }
 751
 752                 if(color0_mov)
 753                 {
 754                     IWineD3DPixelShaderImpl *ps = (IWineD3DPixelShaderImpl *) This;
 755                     if(src_param.reg.type == WINED3DSPR_TEMP &&
 756                        src_param.swizzle == WINED3DSP_NOSWIZZLE)
 757                     {
 758                         ps->color0_mov = TRUE;
 759                         ps->color0_reg = src_param.reg.idx;
 760                     }
 761                 }
 762             }
 763         }
 764     }
 765     reg_maps->loop_depth = max_loop_depth;
 766
 767     This->baseShader.functionLength = ((const char *)pToken - (const char *)byte_code);
 768
 769     return WINED3D_OK;
 770 }
 771
 772 static void shader_dump_decl_usage(const struct wined3d_shader_semantic *semantic,
 773         const struct wined3d_shader_version *shader_version)
 774 {
 775     TRACE("dcl");
 776
 777     if (semantic->reg.reg.type == WINED3DSPR_SAMPLER)
 778     {
 779         switch (semantic->sampler_type)
 780         {
 781             case WINED3DSTT_2D: TRACE("_2d"); break;
 782             case WINED3DSTT_CUBE: TRACE("_cube"); break;
 783             case WINED3DSTT_VOLUME: TRACE("_volume"); break;
 784             default: TRACE("_unknown_ttype(0x%08x)", semantic->sampler_type);
 785         }
 786     }
 787     else
 788     {
 789         /* Pixel shaders 3.0 don't have usage semantics */
 790         if (shader_version->major < 3 && shader_version->type == WINED3D_SHADER_TYPE_PIXEL)
 791             return;
 792         else
 793             TRACE("_");
 794
 795         switch (semantic->usage)
 796         {
 797             case WINED3DDECLUSAGE_POSITION:
 798                 TRACE("position%d", semantic->usage_idx);
 799                 break;
 800             case WINED3DDECLUSAGE_BLENDINDICES:
 801                 TRACE("blend");
 802                 break;
 803             case WINED3DDECLUSAGE_BLENDWEIGHT:
 804                 TRACE("weight");
 805                 break;
 806             case WINED3DDECLUSAGE_NORMAL:
 807                 TRACE("normal%d", semantic->usage_idx);
 808                 break;
 809             case WINED3DDECLUSAGE_PSIZE:
 810                 TRACE("psize");
 811                 break;
 812             case WINED3DDECLUSAGE_COLOR:
 813                 if (semantic->usage_idx == 0) TRACE("color");
 814                 else TRACE("specular%d", (semantic->usage_idx - 1));
 815                 break;
 816             case WINED3DDECLUSAGE_TEXCOORD:
 817                 TRACE("texture%d", semantic->usage_idx);
 818                 break;
 819             case WINED3DDECLUSAGE_TANGENT:
 820                 TRACE("tangent");
 821                 break;
 822             case WINED3DDECLUSAGE_BINORMAL:
 823                 TRACE("binormal");
 824                 break;
 825             case WINED3DDECLUSAGE_TESSFACTOR:
 826                 TRACE("tessfactor");
 827                 break;
 828             case WINED3DDECLUSAGE_POSITIONT:
 829                 TRACE("positionT%d", semantic->usage_idx);
 830                 break;
 831             case WINED3DDECLUSAGE_FOG:
 832                 TRACE("fog");
 833                 break;
 834             case WINED3DDECLUSAGE_DEPTH:
 835                 TRACE("depth");
 836                 break;
 837             case WINED3DDECLUSAGE_SAMPLE:
 838                 TRACE("sample");
 839                 break;
 840             default:
 841                 FIXME("unknown_semantics(0x%08x)", semantic->usage);
 842         }
 843     }
 844 }
 845
 846 static void shader_dump_register(const struct wined3d_shader_register *reg,
 847         const struct wined3d_shader_version *shader_version)
 848 {
 849     static const char * const rastout_reg_names[] = {"oPos", "oFog", "oPts"};
 850     static const char * const misctype_reg_names[] = {"vPos", "vFace"};
 851     UINT offset = reg->idx;
 852
 853     switch (reg->type)
 854     {
 855         case WINED3DSPR_TEMP:
 856             TRACE("r");
 857             break;
 858
 859         case WINED3DSPR_INPUT:
 860             TRACE("v");
 861             break;
 862
 863         case WINED3DSPR_CONST:
 864         case WINED3DSPR_CONST2:
 865         case WINED3DSPR_CONST3:
 866         case WINED3DSPR_CONST4:
 867             TRACE("c");
 868             offset = shader_get_float_offset(reg->type, reg->idx);
 869             break;
 870
 871         case WINED3DSPR_TEXTURE: /* vs: case WINED3DSPR_ADDR */
 872             TRACE("%c", shader_version->type == WINED3D_SHADER_TYPE_PIXEL ? 't' : 'a');
 873             break;
 874
 875         case WINED3DSPR_RASTOUT:
 876             TRACE("%s", rastout_reg_names[reg->idx]);
 877             break;
 878
 879         case WINED3DSPR_COLOROUT:
 880             TRACE("oC");
 881             break;
 882
 883         case WINED3DSPR_DEPTHOUT:
 884             TRACE("oDepth");
 885             break;
 886
 887         case WINED3DSPR_ATTROUT:
 888             TRACE("oD");
 889             break;
 890
 891         case WINED3DSPR_TEXCRDOUT:
 892             /* Vertex shaders >= 3.0 use general purpose output registers
 893              * (WINED3DSPR_OUTPUT), which can include an address token */
 894             if (shader_version->major >= 3) TRACE("o");
 895             else TRACE("oT");
 896             break;
 897
 898         case WINED3DSPR_CONSTINT:
 899             TRACE("i");
 900             break;
 901
 902         case WINED3DSPR_CONSTBOOL:
 903             TRACE("b");
 904             break;
 905
 906         case WINED3DSPR_LABEL:
 907             TRACE("l");
 908             break;
 909
 910         case WINED3DSPR_LOOP:
 911             TRACE("aL");
 912             break;
 913
 914         case WINED3DSPR_SAMPLER:
 915             TRACE("s");
 916             break;
 917
 918         case WINED3DSPR_MISCTYPE:
 919             if (reg->idx > 1) FIXME("Unhandled misctype register %d\n", reg->idx);
 920             else TRACE("%s", misctype_reg_names[reg->idx]);
 921             break;
 922
 923         case WINED3DSPR_PREDICATE:
 924             TRACE("p");
 925             break;
 926
 927         case WINED3DSPR_IMMCONST:
 928             TRACE("l");
 929             break;
 930
 931         default:
 932             TRACE("unhandled_rtype(%#x)", reg->type);
 933             break;
 934     }
 935
 936     if (reg->type == WINED3DSPR_IMMCONST)
 937     {
 938         TRACE("(");
 939         switch (reg->immconst_type)
 940         {
 941             case WINED3D_IMMCONST_FLOAT:
 942                 TRACE("%.8e", *(const float *)reg->immconst_data);
 943                 break;
 944
 945             case WINED3D_IMMCONST_FLOAT4:
 946                 TRACE("%.8e, %.8e, %.8e, %.8e",
 947                         *(const float *)&reg->immconst_data[0], *(const float *)&reg->immconst_data[1],
 948                         *(const float *)&reg->immconst_data[2], *(const float *)&reg->immconst_data[3]);
 949                 break;
 950
 951             default:
 952                 TRACE("<unhandled immconst_type %#x>", reg->immconst_type);
 953                 break;
 954         }
 955         TRACE(")");
 956     }
 957     else if (reg->type != WINED3DSPR_RASTOUT && reg->type != WINED3DSPR_MISCTYPE)
 958     {
 959         if (reg->rel_addr)
 960         {
 961             TRACE("[");
 962             shader_dump_src_param(reg->rel_addr, shader_version);
 963             TRACE(" + ");
 964         }
 965         TRACE("%u", offset);
 966         if (reg->rel_addr) TRACE("]");
 967     }
 968 }
 969
 970 void shader_dump_dst_param(const struct wined3d_shader_dst_param *param,
 971         const struct wined3d_shader_version *shader_version)
 972 {
 973     DWORD write_mask = param->write_mask;
 974
 975     shader_dump_register(&param->reg, shader_version);
 976
 977     if (write_mask != WINED3DSP_WRITEMASK_ALL)
 978     {
 979         static const char *write_mask_chars = "xyzw";
 980
 981         TRACE(".");
 982         if (write_mask & WINED3DSP_WRITEMASK_0) TRACE("%c", write_mask_chars[0]);
 983         if (write_mask & WINED3DSP_WRITEMASK_1) TRACE("%c", write_mask_chars[1]);
 984         if (write_mask & WINED3DSP_WRITEMASK_2) TRACE("%c", write_mask_chars[2]);
 985         if (write_mask & WINED3DSP_WRITEMASK_3) TRACE("%c", write_mask_chars[3]);
 986     }
 987 }
 988
 989 void shader_dump_src_param(const struct wined3d_shader_src_param *param,
 990         const struct wined3d_shader_version *shader_version)
 991 {
 992     DWORD src_modifier = param->modifiers;
 993     DWORD swizzle = param->swizzle;
 994
 995     if (src_modifier == WINED3DSPSM_NEG
 996             || src_modifier == WINED3DSPSM_BIASNEG
 997             || src_modifier == WINED3DSPSM_SIGNNEG
 998             || src_modifier == WINED3DSPSM_X2NEG
 999             || src_modifier == WINED3DSPSM_ABSNEG)
1000         TRACE("-");
1001     else if (src_modifier == WINED3DSPSM_COMP)
1002         TRACE("1-");
1003     else if (src_modifier == WINED3DSPSM_NOT)
1004         TRACE("!");
1005
1006     if (src_modifier == WINED3DSPSM_ABS || src_modifier == WINED3DSPSM_ABSNEG)
1007         TRACE("abs(");
1008
1009     shader_dump_register(&param->reg, shader_version);
1010
1011     if (src_modifier)
1012     {
1013         switch (src_modifier)
1014         {
1015             case WINED3DSPSM_NONE:    break;
1016             case WINED3DSPSM_NEG:     break;
1017             case WINED3DSPSM_NOT:     break;
1018             case WINED3DSPSM_BIAS:    TRACE("_bias"); break;
1019             case WINED3DSPSM_BIASNEG: TRACE("_bias"); break;
1020             case WINED3DSPSM_SIGN:    TRACE("_bx2"); break;
1021             case WINED3DSPSM_SIGNNEG: TRACE("_bx2"); break;
1022             case WINED3DSPSM_COMP:    break;
1023             case WINED3DSPSM_X2:      TRACE("_x2"); break;
1024             case WINED3DSPSM_X2NEG:   TRACE("_x2"); break;
1025             case WINED3DSPSM_DZ:      TRACE("_dz"); break;
1026             case WINED3DSPSM_DW:      TRACE("_dw"); break;
1027             case WINED3DSPSM_ABSNEG:  TRACE(")"); break;
1028             case WINED3DSPSM_ABS:     TRACE(")"); break;
1029             default:
1030                                       TRACE("_unknown_modifier(%#x)", src_modifier);
1031         }
1032     }
1033
1034     if (swizzle != WINED3DSP_NOSWIZZLE)
1035     {
1036         static const char *swizzle_chars = "xyzw";
1037         DWORD swizzle_x = swizzle & 0x03;
1038         DWORD swizzle_y = (swizzle >> 2) & 0x03;
1039         DWORD swizzle_z = (swizzle >> 4) & 0x03;
1040         DWORD swizzle_w = (swizzle >> 6) & 0x03;
1041
1042         if (swizzle_x == swizzle_y
1043                 && swizzle_x == swizzle_z
1044                 && swizzle_x == swizzle_w)
1045         {
1046             TRACE(".%c", swizzle_chars[swizzle_x]);
1047         }
1048         else
1049         {
1050             TRACE(".%c%c%c%c", swizzle_chars[swizzle_x], swizzle_chars[swizzle_y],
1051                     swizzle_chars[swizzle_z], swizzle_chars[swizzle_w]);
1052         }
1053     }
1054 }
1055
1056 /* Shared code in order to generate the bulk of the shader string.
1057  * NOTE: A description of how to parse tokens can be found on msdn */
1058 void shader_generate_main(IWineD3DBaseShader *iface, struct wined3d_shader_buffer *buffer,
1059         const shader_reg_maps *reg_maps, const DWORD *pFunction, void *backend_ctx)
1060 {
1061     IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
1062     IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) This->baseShader.device; /* To access shader backend callbacks */
1063     const struct wined3d_shader_frontend *fe = This->baseShader.frontend;
1064     void *fe_data = This->baseShader.frontend_data;
1065     struct wined3d_shader_src_param src_rel_addr[4];
1066     struct wined3d_shader_src_param src_param[4];
1067     struct wined3d_shader_version shader_version;
1068     struct wined3d_shader_src_param dst_rel_addr;
1069     struct wined3d_shader_dst_param dst_param;
1070     struct wined3d_shader_instruction ins;
1071     struct wined3d_shader_context ctx;
1072     const DWORD *pToken = pFunction;
1073     DWORD i;
1074
1075     /* Initialize current parsing state */
1076     ctx.shader = iface;
1077     ctx.reg_maps = reg_maps;
1078     ctx.buffer = buffer;
1079     ctx.backend_data = backend_ctx;
1080
1081     ins.ctx = &ctx;
1082     ins.dst = &dst_param;
1083     ins.src = src_param;
1084     This->baseShader.parse_state.current_row = 0;
1085
1086     fe->shader_read_header(fe_data, &pToken, &shader_version);
1087
1088     while (!fe->shader_is_end(fe_data, &pToken))
1089     {
1090         const char *comment;
1091         UINT param_size;
1092
1093         /* Skip comment tokens */
1094         fe->shader_read_comment(&pToken, &comment);
1095         if (comment) continue;
1096
1097         /* Read opcode */
1098         fe->shader_read_opcode(fe_data, &pToken, &ins, &param_size);
1099
1100         /* Unknown opcode and its parameters */
1101         if (ins.handler_idx == WINED3DSIH_TABLE_SIZE)
1102         {
1103             TRACE("Skipping unrecognized instruction.\n");
1104             pToken += param_size;
1105             continue;
1106         }
1107
1108         /* Nothing to do */
1109         if (ins.handler_idx == WINED3DSIH_DCL
1110                 || ins.handler_idx == WINED3DSIH_NOP
1111                 || ins.handler_idx == WINED3DSIH_DEF
1112                 || ins.handler_idx == WINED3DSIH_DEFI
1113                 || ins.handler_idx == WINED3DSIH_DEFB
1114                 || ins.handler_idx == WINED3DSIH_PHASE)
1115         {
1116             pToken += param_size;
1117             continue;
1118         }
1119
1120         /* Destination token */
1121         if (ins.dst_count) fe->shader_read_dst_param(fe_data, &pToken, &dst_param, &dst_rel_addr);
1122
1123         /* Predication token */
1124         if (ins.predicate) ins.predicate = *pToken++;
1125
1126         /* Other source tokens */
1127         for (i = 0; i < ins.src_count; ++i)
1128         {
1129             fe->shader_read_src_param(fe_data, &pToken, &src_param[i], &src_rel_addr[i]);
1130         }
1131
1132         /* Call appropriate function for output target */
1133         device->shader_backend->shader_handle_instruction(&ins);
1134     }
1135 }
1136
1137 static void shader_dump_ins_modifiers(const struct wined3d_shader_dst_param *dst)
1138 {
1139     DWORD mmask = dst->modifiers;
1140
1141     switch (dst->shift)
1142     {
1143         case 0: break;
1144         case 13: TRACE("_d8"); break;
1145         case 14: TRACE("_d4"); break;
1146         case 15: TRACE("_d2"); break;
1147         case 1: TRACE("_x2"); break;
1148         case 2: TRACE("_x4"); break;
1149         case 3: TRACE("_x8"); break;
1150         default: TRACE("_unhandled_shift(%d)", dst->shift); break;
1151     }
1152
1153     if (mmask & WINED3DSPDM_SATURATE)         TRACE("_sat");
1154     if (mmask & WINED3DSPDM_PARTIALPRECISION) TRACE("_pp");
1155     if (mmask & WINED3DSPDM_MSAMPCENTROID)    TRACE("_centroid");
1156
1157     mmask &= ~(WINED3DSPDM_SATURATE | WINED3DSPDM_PARTIALPRECISION | WINED3DSPDM_MSAMPCENTROID);
1158     if (mmask)
1159         FIXME("_unrecognized_modifier(%#x)", mmask);
1160 }
1161
1162 void shader_trace_init(const struct wined3d_shader_frontend *fe, void *fe_data, const DWORD *pFunction)
1163 {
1164     struct wined3d_shader_version shader_version;
1165     const DWORD* pToken = pFunction;
1166     const char *type_prefix;
1167     DWORD i;
1168
1169     TRACE("Parsing %p\n", pFunction);
1170
1171     fe->shader_read_header(fe_data, &pToken, &shader_version);
1172
1173     switch (shader_version.type)
1174     {
1175         case WINED3D_SHADER_TYPE_VERTEX:
1176             type_prefix = "vs";
1177             break;
1178
1179         case WINED3D_SHADER_TYPE_GEOMETRY:
1180             type_prefix = "gs";
1181             break;
1182
1183         case WINED3D_SHADER_TYPE_PIXEL:
1184             type_prefix = "ps";
1185             break;
1186
1187         default:
1188             FIXME("Unhandled shader type %#x.\n", shader_version.type);
1189             type_prefix = "unknown";
1190             break;
1191     }
1192
1193     TRACE("%s_%u_%u\n", type_prefix, shader_version.major, shader_version.minor);
1194
1195     while (!fe->shader_is_end(fe_data, &pToken))
1196     {
1197         struct wined3d_shader_instruction ins;
1198         const char *comment;
1199         UINT param_size;
1200
1201         /* comment */
1202         fe->shader_read_comment(&pToken, &comment);
1203         if (comment)
1204         {
1205             TRACE("//%s\n", comment);
1206             continue;
1207         }
1208
1209         fe->shader_read_opcode(fe_data, &pToken, &ins, &param_size);
1210         if (ins.handler_idx == WINED3DSIH_TABLE_SIZE)
1211         {
1212             TRACE("Skipping unrecognized instruction.\n");
1213             pToken += param_size;
1214             continue;
1215         }
1216
1217         if (ins.handler_idx == WINED3DSIH_DCL)
1218         {
1219             struct wined3d_shader_semantic semantic;
1220
1221             fe->shader_read_semantic(&pToken, &semantic);
1222
1223             shader_dump_decl_usage(&semantic, &shader_version);
1224             shader_dump_ins_modifiers(&semantic.reg);
1225             TRACE(" ");
1226             shader_dump_dst_param(&semantic.reg, &shader_version);
1227         }
1228         else if (ins.handler_idx == WINED3DSIH_DEF)
1229         {
1230             struct wined3d_shader_dst_param dst;
1231             struct wined3d_shader_src_param rel_addr;
1232
1233             fe->shader_read_dst_param(fe_data, &pToken, &dst, &rel_addr);
1234
1235             TRACE("def c%u = %f, %f, %f, %f", shader_get_float_offset(dst.reg.type, dst.reg.idx),
1236                     *(const float *)(pToken),
1237                     *(const float *)(pToken + 1),
1238                     *(const float *)(pToken + 2),
1239                     *(const float *)(pToken + 3));
1240             pToken += 4;
1241         }
1242         else if (ins.handler_idx == WINED3DSIH_DEFI)
1243         {
1244             struct wined3d_shader_dst_param dst;
1245             struct wined3d_shader_src_param rel_addr;
1246
1247             fe->shader_read_dst_param(fe_data, &pToken, &dst, &rel_addr);
1248
1249             TRACE("defi i%u = %d, %d, %d, %d", dst.reg.idx,
1250                     *(pToken),
1251                     *(pToken + 1),
1252                     *(pToken + 2),
1253                     *(pToken + 3));
1254             pToken += 4;
1255         }
1256         else if (ins.handler_idx == WINED3DSIH_DEFB)
1257         {
1258             struct wined3d_shader_dst_param dst;
1259             struct wined3d_shader_src_param rel_addr;
1260
1261             fe->shader_read_dst_param(fe_data, &pToken, &dst, &rel_addr);
1262
1263             TRACE("defb b%u = %s", dst.reg.idx, *pToken ? "true" : "false");
1264             ++pToken;
1265         }
1266         else
1267         {
1268             struct wined3d_shader_src_param dst_rel_addr, src_rel_addr;
1269             struct wined3d_shader_dst_param dst_param;
1270             struct wined3d_shader_src_param src_param;
1271
1272             if (ins.dst_count)
1273             {
1274                 fe->shader_read_dst_param(fe_data, &pToken, &dst_param, &dst_rel_addr);
1275             }
1276
1277             /* Print out predication source token first - it follows
1278              * the destination token. */
1279             if (ins.predicate)
1280             {
1281                 fe->shader_read_src_param(fe_data, &pToken, &src_param, &src_rel_addr);
1282                 TRACE("(");
1283                 shader_dump_src_param(&src_param, &shader_version);
1284                 TRACE(") ");
1285             }
1286
1287             /* PixWin marks instructions with the coissue flag with a '+' */
1288             if (ins.coissue) TRACE("+");
1289
1290             TRACE("%s", shader_opcode_names[ins.handler_idx]);
1291
1292             if (ins.handler_idx == WINED3DSIH_IFC
1293                     || ins.handler_idx == WINED3DSIH_BREAKC)
1294             {
1295                 switch (ins.flags)
1296                 {
1297                     case COMPARISON_GT: TRACE("_gt"); break;
1298                     case COMPARISON_EQ: TRACE("_eq"); break;
1299                     case COMPARISON_GE: TRACE("_ge"); break;
1300                     case COMPARISON_LT: TRACE("_lt"); break;
1301                     case COMPARISON_NE: TRACE("_ne"); break;
1302                     case COMPARISON_LE: TRACE("_le"); break;
1303                     default: TRACE("_(%u)", ins.flags);
1304                 }
1305             }
1306             else if (ins.handler_idx == WINED3DSIH_TEX
1307                     && shader_version.major >= 2
1308                     && (ins.flags & WINED3DSI_TEXLD_PROJECT))
1309             {
1310                 TRACE("p");
1311             }
1312
1313             /* We already read the destination token, print it. */
1314             if (ins.dst_count)
1315             {
1316                 shader_dump_ins_modifiers(&dst_param);
1317                 TRACE(" ");
1318                 shader_dump_dst_param(&dst_param, &shader_version);
1319             }
1320
1321             /* Other source tokens */
1322             for (i = ins.dst_count; i < (ins.dst_count + ins.src_count); ++i)
1323             {
1324                 fe->shader_read_src_param(fe_data, &pToken, &src_param, &src_rel_addr);
1325                 TRACE(!i ? " " : ", ");
1326                 shader_dump_src_param(&src_param, &shader_version);
1327             }
1328         }
1329         TRACE("\n");
1330     }
1331 }
1332
1333 void shader_cleanup(IWineD3DBaseShader *iface)
1334 {
1335     IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl *)iface;
1336
1337     ((IWineD3DDeviceImpl *)This->baseShader.device)->shader_backend->shader_destroy(iface);
1338     HeapFree(GetProcessHeap(), 0, This->baseShader.reg_maps.constf);
1339     HeapFree(GetProcessHeap(), 0, This->baseShader.function);
1340     shader_delete_constant_list(&This->baseShader.constantsF);
1341     shader_delete_constant_list(&This->baseShader.constantsB);
1342     shader_delete_constant_list(&This->baseShader.constantsI);
1343     list_remove(&This->baseShader.shader_list_entry);
1344
1345     if (This->baseShader.frontend && This->baseShader.frontend_data)
1346     {
1347         This->baseShader.frontend->shader_free(This->baseShader.frontend_data);
1348     }
1349 }
1350
1351 static void shader_none_handle_instruction(const struct wined3d_shader_instruction *ins) {}
1352 static void shader_none_select(IWineD3DDevice *iface, BOOL usePS, BOOL useVS) {}
1353 static void shader_none_select_depth_blt(IWineD3DDevice *iface, enum tex_types tex_type) {}
1354 static void shader_none_deselect_depth_blt(IWineD3DDevice *iface) {}
1355 static void shader_none_update_float_vertex_constants(IWineD3DDevice *iface, UINT start, UINT count) {}
1356 static void shader_none_update_float_pixel_constants(IWineD3DDevice *iface, UINT start, UINT count) {}
1357 static void shader_none_load_constants(IWineD3DDevice *iface, char usePS, char useVS) {}
1358 static void shader_none_load_np2fixup_constants(IWineD3DDevice *iface, char usePS, char useVS) {}
1359 static void shader_none_destroy(IWineD3DBaseShader *iface) {}
1360 static HRESULT shader_none_alloc(IWineD3DDevice *iface) {return WINED3D_OK;}
1361 static void shader_none_free(IWineD3DDevice *iface) {}
1362 static BOOL shader_none_dirty_const(IWineD3DDevice *iface) {return FALSE;}
1363
1364 #define GLINFO_LOCATION      (*gl_info)
1365 static void shader_none_get_caps(WINED3DDEVTYPE devtype, const WineD3D_GL_Info *gl_info, struct shader_caps *pCaps)
1366 {
1367     /* Set the shader caps to 0 for the none shader backend */
1368     pCaps->VertexShaderVersion  = 0;
1369     pCaps->PixelShaderVersion    = 0;
1370     pCaps->PixelShader1xMaxValue = 0.0f;
1371 }
1372 #undef GLINFO_LOCATION
1373 static BOOL shader_none_color_fixup_supported(struct color_fixup_desc fixup)
1374 {
1375     if (TRACE_ON(d3d_shader) && TRACE_ON(d3d))
1376     {
1377         TRACE("Checking support for fixup:\n");
1378         dump_color_fixup_desc(fixup);
1379     }
1380
1381     /* Faked to make some apps happy. */
1382     if (!is_yuv_fixup(fixup))
1383     {
1384         TRACE("[OK]\n");
1385         return TRUE;
1386     }
1387
1388     TRACE("[FAILED]\n");
1389     return FALSE;
1390 }
1391
1392 const shader_backend_t none_shader_backend = {
1393     shader_none_handle_instruction,
1394     shader_none_select,
1395     shader_none_select_depth_blt,
1396     shader_none_deselect_depth_blt,
1397     shader_none_update_float_vertex_constants,
1398     shader_none_update_float_pixel_constants,
1399     shader_none_load_constants,
1400     shader_none_load_np2fixup_constants,
1401     shader_none_destroy,
1402     shader_none_alloc,
1403     shader_none_free,
1404     shader_none_dirty_const,
1405     shader_none_get_caps,
1406     shader_none_color_fixup_supported,
1407 };