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