dlls/wined3d/baseshader.c

   1 /*
   2  * shaders implementation
   3  *
   4  * Copyright 2002-2003 Jason Edmeades
   5  * Copyright 2002-2003 Raphael Junqueira
   6  * Copyright 2005 Oliver Stieber
   7  * Copyright 2006 Ivan Gyurdiev
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  */
  23
  24 #include "config.h"
  25 #include <string.h>
  26 #include <stdio.h>
  27 #include "wined3d_private.h"
  28
  29 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
  30
  31 #define GLNAME_REQUIRE_GLSL  ((const char *)1)
  32
  33 inline static BOOL shader_is_version_token(DWORD token) {
  34     return shader_is_pshader_version(token) ||
  35            shader_is_vshader_version(token);
  36 }
  37
  38 int shader_addline(
  39     SHADER_BUFFER* buffer,
  40     const char *format, ...) {
  41
  42     char* base = buffer->buffer + buffer->bsize;
  43     int rc;
  44
  45     va_list args;
  46     va_start(args, format);
  47     rc = vsnprintf(base, SHADER_PGMSIZE - 1 - buffer->bsize, format, args);
  48     va_end(args);
  49
  50     if (rc < 0 ||                                   /* C89 */
  51         rc > SHADER_PGMSIZE - 1 - buffer->bsize) {  /* C99 */
  52
  53         ERR("The buffer allocated for the shader program string "
  54             "is too small at %d bytes.\n", SHADER_PGMSIZE);
  55         buffer->bsize = SHADER_PGMSIZE - 1;
  56         return -1;
  57     }
  58
  59     buffer->bsize += rc;
  60     buffer->lineNo++;
  61     TRACE("GL HW (%u, %u) : %s", buffer->lineNo, buffer->bsize, base);
  62     return 0;
  63 }
  64
  65 const SHADER_OPCODE* shader_get_opcode(
  66     IWineD3DBaseShader *iface, const DWORD code) {
  67
  68     IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl*) iface;
  69
  70     DWORD i = 0;
  71     DWORD version = This->baseShader.version;
  72     DWORD hex_version = This->baseShader.hex_version;
  73     const SHADER_OPCODE *shader_ins = This->baseShader.shader_ins;
  74
  75     /** TODO: use dichotomic search */
  76     while (NULL != shader_ins[i].name) {
  77         if (((code & D3DSI_OPCODE_MASK) == shader_ins[i].opcode) &&
  78             (((hex_version >= shader_ins[i].min_version) && (hex_version <= shader_ins[i].max_version)) ||
  79             ((shader_ins[i].min_version == 0) && (shader_ins[i].max_version == 0)))) {
  80             return &shader_ins[i];
  81         }
  82         ++i;
  83     }
  84     FIXME("Unsupported opcode %lx(%ld) masked %lx version %ld\n",
  85        code, code, code & D3DSI_OPCODE_MASK, version);
  86     return NULL;
  87 }
  88
  89 /* Read a parameter opcode from the input stream,
  90  * and possibly a relative addressing token.
  91  * Return the number of tokens read */
  92 int shader_get_param(
  93     IWineD3DBaseShader* iface,
  94     const DWORD* pToken,
  95     DWORD* param,
  96     DWORD* addr_token) {
  97
  98     /* PS >= 3.0 have relative addressing (with token)
  99      * VS >= 2.0 have relative addressing (with token)
 100      * VS >= 1.0 < 2.0 have relative addressing (without token)
 101      * The version check below should work in general */
 102
 103     IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
 104     char rel_token = D3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) >= 2 &&
 105         ((*pToken & D3DSHADER_ADDRESSMODE_MASK) == D3DSHADER_ADDRMODE_RELATIVE);
 106
 107     *param = *pToken;
 108     *addr_token = rel_token? *(pToken + 1): 0;
 109     return rel_token? 2:1;
 110 }
 111
 112 /* Return the number of parameters to skip for an opcode */
 113 static inline int shader_skip_opcode(
 114     IWineD3DBaseShaderImpl* This,
 115     const SHADER_OPCODE* curOpcode,
 116     DWORD opcode_token) {
 117
 118    /* Shaders >= 2.0 may contain address tokens, but fortunately they
 119     * have a useful legnth mask - use it here. Shaders 1.0 contain no such tokens */
 120
 121     return (D3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) >= 2)?
 122         ((opcode_token & D3DSI_INSTLENGTH_MASK) >> D3DSI_INSTLENGTH_SHIFT):
 123         curOpcode->num_params;
 124 }
 125
 126 /* Read the parameters of an unrecognized opcode from the input stream
 127  * Return the number of tokens read.
 128  *
 129  * Note: This function assumes source or destination token format.
 130  * It will not work with specially-formatted tokens like DEF or DCL,
 131  * but hopefully those would be recognized */
 132
 133 int shader_skip_unrecognized(
 134     IWineD3DBaseShader* iface,
 135     const DWORD* pToken) {
 136
 137     int tokens_read = 0;
 138     int i = 0;
 139
 140     /* TODO: Think of a good name for 0x80000000 and replace it with a constant */
 141     while (*pToken & 0x80000000) {
 142
 143         DWORD param, addr_token;
 144         tokens_read += shader_get_param(iface, pToken, &param, &addr_token);
 145         pToken += tokens_read;
 146
 147         FIXME("Unrecognized opcode param: token=%08lX "
 148             "addr_token=%08lX name=", param, addr_token);
 149         shader_dump_param(iface, param, i);
 150         FIXME("\n");
 151         ++i;
 152     }
 153     return tokens_read;
 154 }
 155
 156 /* Note: For vertex shaders,
 157  * texUsed = addrUsed, and
 158  * D3DSPR_TEXTURE = D3DSPR_ADDR.
 159  *
 160  * Also note that this does not count the loop register
 161  * as an address register. */
 162
 163 void shader_get_registers_used(
 164     IWineD3DBaseShader *iface,
 165     CONST DWORD* pToken) {
 166
 167     IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
 168     DWORD* tempsUsed = &This->baseShader.temps_used;
 169     DWORD* texUsed = &This->baseShader.textures_used;
 170
 171     if (pToken == NULL)
 172         return;
 173
 174     *tempsUsed = 0;
 175     *texUsed = 0;
 176
 177     while (D3DVS_END() != *pToken) {
 178         CONST SHADER_OPCODE* curOpcode;
 179
 180         /* Skip version */
 181         if (shader_is_version_token(*pToken)) {
 182              ++pToken;
 183              continue;
 184
 185         /* Skip comments */
 186         } else if (shader_is_comment(*pToken)) {
 187              DWORD comment_len = (*pToken & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT;
 188              ++pToken;
 189              pToken += comment_len;
 190              continue;
 191         }
 192
 193         /* Fetch opcode */
 194         curOpcode = shader_get_opcode(iface, *pToken);
 195         ++pToken;
 196
 197         /* Unhandled opcode, and its parameters */
 198         if (NULL == curOpcode) {
 199            while (*pToken & 0x80000000)
 200                ++pToken;
 201            continue;
 202
 203         /* Skip declarations (for now) */
 204         } else if (D3DSIO_DCL == curOpcode->opcode) {
 205             pToken += curOpcode->num_params;
 206             continue;
 207
 208         /* Skip definitions (for now) */
 209         } else if (D3DSIO_DEF == curOpcode->opcode) {
 210             pToken += curOpcode->num_params;
 211             continue;
 212
 213         /* Set texture registers, and temporary registers */
 214         } else {
 215             int i;
 216
 217             for (i = 0; i < curOpcode->num_params; ++i) {
 218
 219                 DWORD param, addr_token, reg, regtype;
 220                 pToken += shader_get_param(iface, pToken, &param, &addr_token);
 221
 222                 regtype = (param & D3DSP_REGTYPE_MASK) >> D3DSP_REGTYPE_SHIFT;
 223                 reg = param & D3DSP_REGNUM_MASK;
 224
 225                 if (D3DSPR_TEXTURE == regtype)
 226                     *texUsed |= (1 << reg);
 227                 if (D3DSPR_TEMP == regtype)
 228                     *tempsUsed |= (1 << reg);
 229              }
 230         }
 231     }
 232 }
 233
 234 void shader_program_dump_decl_usage(
 235     DWORD decl,
 236     DWORD param) {
 237
 238     DWORD regtype = shader_get_regtype(param);
 239     TRACE("dcl_");
 240
 241     if (regtype == D3DSPR_SAMPLER) {
 242         DWORD ttype = decl & D3DSP_TEXTURETYPE_MASK;
 243
 244         switch (ttype) {
 245             case D3DSTT_2D: TRACE("2d"); break;
 246             case D3DSTT_CUBE: TRACE("cube"); break;
 247             case D3DSTT_VOLUME: TRACE("volume"); break;
 248             default: TRACE("unknown_ttype(%08lx)", ttype);
 249        }
 250
 251     } else {
 252
 253         DWORD usage = decl & D3DSP_DCL_USAGE_MASK;
 254         DWORD idx = (decl & D3DSP_DCL_USAGEINDEX_MASK) >> D3DSP_DCL_USAGEINDEX_SHIFT;
 255
 256         switch(usage) {
 257         case D3DDECLUSAGE_POSITION:
 258             TRACE("%s%ld", "position", idx);
 259             break;
 260         case D3DDECLUSAGE_BLENDINDICES:
 261             TRACE("%s", "blend");
 262             break;
 263         case D3DDECLUSAGE_BLENDWEIGHT:
 264             TRACE("%s", "weight");
 265             break;
 266         case D3DDECLUSAGE_NORMAL:
 267             TRACE("%s%ld", "normal", idx);
 268             break;
 269         case D3DDECLUSAGE_PSIZE:
 270             TRACE("%s", "psize");
 271             break;
 272         case D3DDECLUSAGE_COLOR:
 273             if(idx == 0)  {
 274                 TRACE("%s", "color");
 275             } else {
 276                 TRACE("%s%ld", "specular", (idx - 1));
 277             }
 278             break;
 279         case D3DDECLUSAGE_TEXCOORD:
 280             TRACE("%s%ld", "texture", idx);
 281             break;
 282         case D3DDECLUSAGE_TANGENT:
 283             TRACE("%s", "tangent");
 284             break;
 285         case D3DDECLUSAGE_BINORMAL:
 286             TRACE("%s", "binormal");
 287             break;
 288         case D3DDECLUSAGE_TESSFACTOR:
 289             TRACE("%s", "tessfactor");
 290             break;
 291         case D3DDECLUSAGE_POSITIONT:
 292             TRACE("%s%ld", "positionT", idx);
 293             break;
 294         case D3DDECLUSAGE_FOG:
 295             TRACE("%s", "fog");
 296             break;
 297         case D3DDECLUSAGE_DEPTH:
 298             TRACE("%s", "depth");
 299             break;
 300         case D3DDECLUSAGE_SAMPLE:
 301             TRACE("%s", "sample");
 302             break;
 303         default:
 304             FIXME("unknown_semantics(%08lx)", usage);
 305         }
 306     }
 307 }
 308
 309 void shader_dump_param(
 310     IWineD3DBaseShader *iface,
 311     const DWORD param,
 312     int input) {
 313
 314     IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
 315     static const char* rastout_reg_names[] = { "oPos", "oFog", "oPts" };
 316     char swizzle_reg_chars[4];
 317
 318     DWORD reg = param & D3DSP_REGNUM_MASK;
 319     DWORD regtype = shader_get_regtype(param);
 320
 321     /* There are some minor differences between pixel and vertex shaders */
 322     BOOL pshader = shader_is_pshader_version(This->baseShader.hex_version);
 323
 324     /* For one, we'd prefer color components to be shown for pshaders.
 325      * FIXME: use the swizzle function for this */
 326
 327     swizzle_reg_chars[0] = pshader? 'r': 'x';
 328     swizzle_reg_chars[1] = pshader? 'g': 'y';
 329     swizzle_reg_chars[2] = pshader? 'b': 'z';
 330     swizzle_reg_chars[3] = pshader? 'a': 'w';
 331
 332     if (input) {
 333         if ( ((param & D3DSP_SRCMOD_MASK) == D3DSPSM_NEG) ||
 334              ((param & D3DSP_SRCMOD_MASK) == D3DSPSM_BIASNEG) ||
 335              ((param & D3DSP_SRCMOD_MASK) == D3DSPSM_SIGNNEG) ||
 336              ((param & D3DSP_SRCMOD_MASK) == D3DSPSM_X2NEG) )
 337             TRACE("-");
 338         else if ((param & D3DSP_SRCMOD_MASK) == D3DSPSM_COMP)
 339             TRACE("1-");
 340     }
 341
 342     switch (regtype) {
 343         case D3DSPR_TEMP:
 344             TRACE("r%lu", reg);
 345             break;
 346         case D3DSPR_INPUT:
 347             TRACE("v%lu", reg);
 348             break;
 349         case D3DSPR_CONST:
 350             TRACE("c%s%lu", (param & D3DVS_ADDRMODE_RELATIVE) ? "a0.x + " : "", reg);
 351             break;
 352         case D3DSPR_TEXTURE: /* vs: case D3DSPR_ADDR */
 353             TRACE("%c%lu", (pshader? 't':'a'), reg);
 354             break;
 355         case D3DSPR_RASTOUT:
 356             TRACE("%s", rastout_reg_names[reg]);
 357             break;
 358         case D3DSPR_COLOROUT:
 359             TRACE("oC%lu", reg);
 360             break;
 361         case D3DSPR_DEPTHOUT:
 362             TRACE("oDepth");
 363             break;
 364         case D3DSPR_ATTROUT:
 365             TRACE("oD%lu", reg);
 366             break;
 367         case D3DSPR_TEXCRDOUT:
 368             TRACE("oT%lu", reg);
 369             break;
 370         case D3DSPR_CONSTINT:
 371             TRACE("i%s%lu", (param & D3DVS_ADDRMODE_RELATIVE) ? "a0.x + " : "", reg);
 372             break;
 373         case D3DSPR_CONSTBOOL:
 374             TRACE("b%s%lu", (param & D3DVS_ADDRMODE_RELATIVE) ? "a0.x + " : "", reg);
 375             break;
 376         case D3DSPR_LABEL:
 377             TRACE("l%lu", reg);
 378             break;
 379         case D3DSPR_LOOP:
 380             TRACE("aL%s%lu", (param & D3DVS_ADDRMODE_RELATIVE) ? "a0.x + " : "", reg);
 381             break;
 382         case D3DSPR_SAMPLER:
 383             TRACE("s%lu", reg);
 384             break;
 385         default:
 386             TRACE("unhandled_rtype(%lx)", regtype);
 387             break;
 388    }
 389
 390    if (!input) {
 391        /* operand output (for modifiers and shift, see dump_ins_modifiers) */
 392
 393        if ((param & D3DSP_WRITEMASK_ALL) != D3DSP_WRITEMASK_ALL) {
 394            TRACE(".");
 395            if (param & D3DSP_WRITEMASK_0) TRACE("%c", swizzle_reg_chars[0]);
 396            if (param & D3DSP_WRITEMASK_1) TRACE("%c", swizzle_reg_chars[1]);
 397            if (param & D3DSP_WRITEMASK_2) TRACE("%c", swizzle_reg_chars[2]);
 398            if (param & D3DSP_WRITEMASK_3) TRACE("%c", swizzle_reg_chars[3]);
 399        }
 400
 401    } else {
 402         /** operand input */
 403         DWORD swizzle = (param & D3DSP_SWIZZLE_MASK) >> D3DSP_SWIZZLE_SHIFT;
 404         DWORD swizzle_r = swizzle & 0x03;
 405         DWORD swizzle_g = (swizzle >> 2) & 0x03;
 406         DWORD swizzle_b = (swizzle >> 4) & 0x03;
 407         DWORD swizzle_a = (swizzle >> 6) & 0x03;
 408
 409         if (0 != (param & D3DSP_SRCMOD_MASK)) {
 410             DWORD mask = param & D3DSP_SRCMOD_MASK;
 411             /*TRACE("_modifier(0x%08lx) ", mask);*/
 412             switch (mask) {
 413                 case D3DSPSM_NONE:    break;
 414                 case D3DSPSM_NEG:     break;
 415                 case D3DSPSM_BIAS:    TRACE("_bias"); break;
 416                 case D3DSPSM_BIASNEG: TRACE("_bias"); break;
 417                 case D3DSPSM_SIGN:    TRACE("_bx2"); break;
 418                 case D3DSPSM_SIGNNEG: TRACE("_bx2"); break;
 419                 case D3DSPSM_COMP:    break;
 420                 case D3DSPSM_X2:      TRACE("_x2"); break;
 421                 case D3DSPSM_X2NEG:   TRACE("_x2"); break;
 422                 case D3DSPSM_DZ:      TRACE("_dz"); break;
 423                 case D3DSPSM_DW:      TRACE("_dw"); break;
 424                 default:
 425                     TRACE("_unknown(0x%08lx)", mask);
 426             }
 427         }
 428
 429         /**
 430         * swizzle bits fields:
 431         *  RRGGBBAA
 432         */
 433         if ((D3DVS_NOSWIZZLE >> D3DVS_SWIZZLE_SHIFT) != swizzle) { /* ! D3DVS_NOSWIZZLE == 0xE4 << D3DVS_SWIZZLE_SHIFT */
 434             if (swizzle_r == swizzle_g &&
 435                 swizzle_r == swizzle_b &&
 436                 swizzle_r == swizzle_a) {
 437                     TRACE(".%c", swizzle_reg_chars[swizzle_r]);
 438             } else {
 439                 TRACE(".%c%c%c%c",
 440                 swizzle_reg_chars[swizzle_r],
 441                 swizzle_reg_chars[swizzle_g],
 442                 swizzle_reg_chars[swizzle_b],
 443                 swizzle_reg_chars[swizzle_a]);
 444             }
 445         }
 446     }
 447 }
 448
 449 /** Generate the variable & register declarations for the ARB_vertex_program
 450     output target */
 451 void generate_arb_declarations(IWineD3DBaseShader *iface, SHADER_BUFFER* buffer) {
 452
 453     IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
 454     DWORD i;
 455
 456     for(i = 0; i < This->baseShader.limits.temporary; i++) {
 457         if (This->baseShader.temps_used & (1 << i))
 458             shader_addline(buffer, "TEMP R%lu;\n", i);
 459     }
 460
 461     for (i = 0; i < This->baseShader.limits.address; i++) {
 462         if (This->baseShader.textures_used & (1 << i))
 463             shader_addline(buffer, "ADDRESS A%ld;\n", i);
 464     }
 465
 466     for(i = 0; i < This->baseShader.limits.texture; i++) {
 467         if (This->baseShader.textures_used & (1 << i))
 468             shader_addline(buffer,"TEMP T%lu;\n", i);
 469     }
 470
 471     /* Texture coordinate registers must be pre-loaded */
 472     for (i = 0; i < This->baseShader.limits.texture; i++) {
 473     if (This->baseShader.textures_used & (1 << i))
 474         shader_addline(buffer, "MOV T%lu, fragment.texcoord[%lu];\n", i, i);
 475     }
 476 }
 477
 478 /** Generate the variable & register declarations for the GLSL
 479     output target */
 480 void generate_glsl_declarations(IWineD3DBaseShader *iface, SHADER_BUFFER* buffer) {
 481
 482     FIXME("GLSL not fully implemented yet.\n");
 483
 484 }
 485
 486 /** Shared code in order to generate the bulk of the shader string.
 487     Use the shader_header_fct & shader_footer_fct to add strings
 488     that are specific to pixel or vertex functions
 489     NOTE: A description of how to parse tokens can be found at:
 490           http://msdn.microsoft.com/library/default.asp?url=/library/en-us/graphics/hh/graphics/usermodedisplaydriver_shader_cc8e4e05-f5c3-4ec0-8853-8ce07c1551b2.xml.asp */
 491 void generate_base_shader(
 492     IWineD3DBaseShader *iface,
 493     SHADER_BUFFER* buffer,
 494     CONST DWORD* pFunction) {
 495
 496     IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
 497     const DWORD *pToken = pFunction;
 498     const SHADER_OPCODE *curOpcode = NULL;
 499     DWORD opcode_token;
 500     DWORD i;
 501
 502     /* Initialize current parsing state */
 503     This->baseShader.parse_state.current_row = 0;
 504
 505     /* First pass: figure out which temporary and texture registers are used */
 506     shader_get_registers_used(iface, pToken);
 507     TRACE("Texture/Address registers used: %#lx, Temp registers used %#lx\n",
 508           This->baseShader.textures_used, This->baseShader.temps_used);
 509
 510     /* TODO: check register usage against GL/Directx limits, and fail if they're exceeded
 511         nUseAddressRegister < = GL_MAX_PROGRAM_ADDRESS_REGISTERS_AR
 512         nUseTempRegister    <=  GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB
 513     */
 514
 515     /* Pre-declare registers */
 516     if (USING_GLSL)
 517         generate_glsl_declarations(iface, buffer);
 518     else
 519         generate_arb_declarations(iface, buffer);
 520
 521     /* Second pass, process opcodes */
 522     if (NULL != pToken) {
 523         while (D3DPS_END() != *pToken) {
 524
 525             /* Skip version token */
 526             if (shader_is_version_token(*pToken)) {
 527                 ++pToken;
 528                 continue;
 529             }
 530
 531             /* Skip comment tokens */
 532             if (shader_is_comment(*pToken)) {
 533                 DWORD comment_len = (*pToken & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT;
 534                 ++pToken;
 535                 TRACE("#%s\n", (char*)pToken);
 536                 pToken += comment_len;
 537                 continue;
 538             }
 539
 540             /* Read opcode */
 541             opcode_token = *pToken++;
 542             curOpcode = shader_get_opcode(iface, opcode_token);
 543
 544             /* Unknown opcode and its parameters */
 545            if (NULL == curOpcode) {
 546               FIXME("Unrecognized opcode: token=%08lX\n", opcode_token);
 547               pToken += shader_skip_unrecognized(iface, pToken);
 548
 549             /* Using GLSL & no generator function exists */
 550             } else if (USING_GLSL && curOpcode->hw_glsl_fct == NULL) {
 551
 552                 FIXME("Token %s is not yet implemented with GLSL\n", curOpcode->name);
 553                 pToken += shader_skip_opcode(This, curOpcode, opcode_token);
 554
 555             /* Unhandled opcode in ARB */
 556             } else if ( !USING_GLSL && GLNAME_REQUIRE_GLSL == curOpcode->glname) {
 557
 558                 FIXME("Token %s requires greater functionality than "
 559                     "Vertex or Fragment_Program_ARB supports\n", curOpcode->name);
 560                 pToken += shader_skip_opcode(This, curOpcode, opcode_token);
 561
 562             /* If a generator function is set for current shader target, use it */
 563             } else if ((!USING_GLSL && curOpcode->hw_fct != NULL) ||
 564                        (USING_GLSL && curOpcode->hw_glsl_fct != NULL)) {
 565
 566                 SHADER_OPCODE_ARG hw_arg;
 567
 568                 hw_arg.shader = iface;
 569                 hw_arg.opcode = curOpcode;
 570                 hw_arg.buffer = buffer;
 571
 572                 if (curOpcode->num_params > 0) {
 573
 574                     DWORD param, addr_token = 0;
 575
 576                     /* DCL instruction has usage dst parameter, not register */
 577                     if (curOpcode->opcode == D3DSIO_DCL)
 578                         param = *pToken++;
 579                     else
 580                         pToken += shader_get_param(iface, pToken, &param, &addr_token);
 581
 582                     hw_arg.dst = param;
 583                     hw_arg.dst_addr = addr_token;
 584
 585                     for (i = 1; i < curOpcode->num_params; i++) {
 586                         /* DEF* instructions have constant src parameters, not registers */
 587                         if (curOpcode->opcode == D3DSIO_DEF ||
 588                             curOpcode->opcode == D3DSIO_DEFI ||
 589                             curOpcode->opcode == D3DSIO_DEFB) {
 590                             param = *pToken++;
 591
 592                         } else
 593                             pToken += shader_get_param(iface, pToken, &param, &addr_token);
 594
 595                         hw_arg.src[i-1] = param;
 596                         hw_arg.src_addr[i-1] = addr_token;
 597                     }
 598                 }
 599
 600                 /* Call appropriate function for output target */
 601                 if (USING_GLSL)
 602                     curOpcode->hw_glsl_fct(&hw_arg);
 603                 else
 604                     curOpcode->hw_fct(&hw_arg);
 605
 606             } else {
 607
 608                 /* Unless we encounter a no-op command, this opcode is unrecognized */
 609                 if (curOpcode->opcode != D3DSIO_NOP) {
 610                     FIXME("Can't handle opcode %s in hwShader\n", curOpcode->name);
 611                     pToken += shader_skip_opcode(This, curOpcode, opcode_token);
 612                 }
 613             }
 614         }
 615         /* TODO: What about result.depth? */
 616
 617     }
 618 }
 619
 620
 621 void shader_dump_ins_modifiers(const DWORD output) {
 622
 623     DWORD shift = (output & D3DSP_DSTSHIFT_MASK) >> D3DSP_DSTSHIFT_SHIFT;
 624     DWORD mmask = output & D3DSP_DSTMOD_MASK;
 625
 626     switch (shift) {
 627         case 0: break;
 628         case 13: TRACE("_d8"); break;
 629         case 14: TRACE("_d4"); break;
 630         case 15: TRACE("_d2"); break;
 631         case 1: TRACE("_x2"); break;
 632         case 2: TRACE("_x4"); break;
 633         case 3: TRACE("_x8"); break;
 634         default: TRACE("_unhandled_shift(%ld)", shift); break;
 635     }
 636
 637     if (mmask & D3DSPDM_SATURATE)         TRACE("_sat");
 638     if (mmask & D3DSPDM_PARTIALPRECISION) TRACE("_pp");
 639     if (mmask & D3DSPDM_MSAMPCENTROID)    TRACE("_centroid");
 640
 641     mmask &= ~(D3DSPDM_SATURATE | D3DSPDM_PARTIALPRECISION | D3DSPDM_MSAMPCENTROID);
 642     if (mmask)
 643         FIXME("_unrecognized_modifier(%#lx)", mmask >> D3DSP_DSTMOD_SHIFT);
 644 }
 645
 646 /* TODO: Move other shared code here */