2 * shaders implementation
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
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
28 #include "wined3d_private.h"
30 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
32 #define GLNAME_REQUIRE_GLSL ((const char *)1)
34 inline static BOOL shader_is_version_token(DWORD token) {
35 return shader_is_pshader_version(token) ||
36 shader_is_vshader_version(token);
40 SHADER_BUFFER* buffer,
41 const char *format, ...) {
43 char* base = buffer->buffer + buffer->bsize;
47 va_start(args, format);
48 rc = vsnprintf(base, SHADER_PGMSIZE - 1 - buffer->bsize, format, args);
51 if (rc < 0 || /* C89 */
52 rc > SHADER_PGMSIZE - 1 - buffer->bsize) { /* C99 */
54 ERR("The buffer allocated for the shader program string "
55 "is too small at %d bytes.\n", SHADER_PGMSIZE);
56 buffer->bsize = SHADER_PGMSIZE - 1;
62 TRACE("GL HW (%u, %u) : %s", buffer->lineNo, buffer->bsize, base);
66 const SHADER_OPCODE* shader_get_opcode(
67 IWineD3DBaseShader *iface, const DWORD code) {
69 IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl*) iface;
72 DWORD hex_version = This->baseShader.hex_version;
73 const SHADER_OPCODE *shader_ins = This->baseShader.shader_ins;
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];
84 FIXME("Unsupported opcode %#lx(%ld) masked %#lx, shader version %#lx\n",
85 code, code, code & D3DSI_OPCODE_MASK, hex_version);
89 /* Read a parameter opcode from the input stream,
90 * and possibly a relative addressing token.
91 * Return the number of tokens read */
93 IWineD3DBaseShader* iface,
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 */
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);
108 *addr_token = rel_token? *(pToken + 1): 0;
109 return rel_token? 2:1;
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) {
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 */
121 return (D3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) >= 2)?
122 ((opcode_token & D3DSI_INSTLENGTH_MASK) >> D3DSI_INSTLENGTH_SHIFT):
123 curOpcode->num_params;
126 /* Read the parameters of an unrecognized opcode from the input stream
127 * Return the number of tokens read.
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 */
133 int shader_skip_unrecognized(
134 IWineD3DBaseShader* iface,
135 const DWORD* pToken) {
140 /* TODO: Think of a good name for 0x80000000 and replace it with a constant */
141 while (*pToken & 0x80000000) {
143 DWORD param, addr_token;
144 tokens_read += shader_get_param(iface, pToken, ¶m, &addr_token);
145 pToken += tokens_read;
147 FIXME("Unrecognized opcode param: token=%08lX "
148 "addr_token=%08lX name=", param, addr_token);
149 shader_dump_param(iface, param, addr_token, i);
156 /* Convert floating point offset relative
157 * to a register file to an absolute offset for float constants */
159 unsigned int shader_get_float_offset(const DWORD reg) {
161 unsigned int regnum = reg & D3DSP_REGNUM_MASK;
162 int regtype = shader_get_regtype(reg);
165 case D3DSPR_CONST: return regnum;
166 case D3DSPR_CONST2: return 2048 + regnum;
167 case D3DSPR_CONST3: return 4096 + regnum;
168 case D3DSPR_CONST4: return 6144 + regnum;
170 FIXME("Unsupported register type: %d\n", regtype);
175 /* Note that this does not count the loop register
176 * as an address register. */
178 HRESULT shader_get_registers_used(
179 IWineD3DBaseShader *iface,
180 shader_reg_maps* reg_maps,
181 semantic* semantics_in,
182 semantic* semantics_out,
183 CONST DWORD* pToken) {
185 IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
187 /* There are some minor differences between pixel and vertex shaders */
188 char pshader = shader_is_pshader_version(This->baseShader.hex_version);
193 while (D3DVS_END() != *pToken) {
194 CONST SHADER_OPCODE* curOpcode;
198 if (shader_is_version_token(*pToken)) {
203 } else if (shader_is_comment(*pToken)) {
204 DWORD comment_len = (*pToken & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT;
206 pToken += comment_len;
211 opcode_token = *pToken++;
212 curOpcode = shader_get_opcode(iface, opcode_token);
214 /* Unhandled opcode, and its parameters */
215 if (NULL == curOpcode) {
216 while (*pToken & 0x80000000)
219 /* Handle declarations */
220 } else if (D3DSIO_DCL == curOpcode->opcode) {
222 DWORD usage = *pToken++;
223 DWORD param = *pToken++;
224 DWORD regtype = shader_get_regtype(param);
225 unsigned int regnum = param & D3DSP_REGNUM_MASK;
227 /* Vshader: mark attributes used
228 Pshader: mark 3.0 input registers used, save token */
229 if (D3DSPR_INPUT == regtype) {
232 reg_maps->attributes[regnum] = 1;
234 reg_maps->packed_input[regnum] = 1;
236 semantics_in[regnum].usage = usage;
237 semantics_in[regnum].reg = param;
239 /* Vshader: mark 3.0 output registers used, save token */
240 } else if (D3DSPR_OUTPUT == regtype) {
241 reg_maps->packed_output[regnum] = 1;
242 semantics_out[regnum].usage = usage;
243 semantics_out[regnum].reg = param;
245 /* Save sampler usage token */
246 } else if (D3DSPR_SAMPLER == regtype)
247 reg_maps->samplers[regnum] = usage;
249 } else if (D3DSIO_DEF == curOpcode->opcode) {
251 local_constant* lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant));
252 if (!lconst) return E_OUTOFMEMORY;
253 lconst->idx = *pToken & D3DSP_REGNUM_MASK;
254 memcpy(&lconst->value, pToken + 1, 4 * sizeof(DWORD));
255 list_add_head(&This->baseShader.constantsF, &lconst->entry);
256 pToken += curOpcode->num_params;
258 } else if (D3DSIO_DEFI == curOpcode->opcode) {
260 local_constant* lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant));
261 if (!lconst) return E_OUTOFMEMORY;
262 lconst->idx = *pToken & D3DSP_REGNUM_MASK;
263 memcpy(&lconst->value, pToken + 1, 4 * sizeof(DWORD));
264 list_add_head(&This->baseShader.constantsI, &lconst->entry);
265 pToken += curOpcode->num_params;
267 } else if (D3DSIO_DEFB == curOpcode->opcode) {
269 local_constant* lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant));
270 if (!lconst) return E_OUTOFMEMORY;
271 lconst->idx = *pToken & D3DSP_REGNUM_MASK;
272 memcpy(&lconst->value, pToken + 1, 1 * sizeof(DWORD));
273 list_add_head(&This->baseShader.constantsB, &lconst->entry);
274 pToken += curOpcode->num_params;
276 /* If there's a loop in the shader */
277 } else if (D3DSIO_LOOP == curOpcode->opcode ||
278 D3DSIO_REP == curOpcode->opcode) {
280 pToken += curOpcode->num_params;
282 /* For subroutine prototypes */
283 } else if (D3DSIO_LABEL == curOpcode->opcode) {
285 DWORD snum = *pToken & D3DSP_REGNUM_MASK;
286 reg_maps->labels[snum] = 1;
287 pToken += curOpcode->num_params;
289 /* Set texture, address, temporary registers */
293 /* Declare 1.X samplers implicitly, based on the destination reg. number */
294 if (D3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) == 1 &&
295 (D3DSIO_TEX == curOpcode->opcode ||
296 D3DSIO_TEXBEM == curOpcode->opcode ||
297 D3DSIO_TEXM3x2TEX == curOpcode->opcode ||
298 D3DSIO_TEXM3x3TEX == curOpcode->opcode)) {
300 /* Fake sampler usage, only set reserved bit and ttype */
301 DWORD sampler_code = *pToken & D3DSP_REGNUM_MASK;
302 reg_maps->samplers[sampler_code] = (0x1 << 31) | D3DSTT_2D;
304 } else if (D3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) == 1 &&
305 (D3DSIO_TEXM3x3SPEC == curOpcode->opcode ||
306 D3DSIO_TEXM3x3VSPEC == curOpcode->opcode)) {
308 /* 3D sampler usage, only set reserved bit and ttype
309 * FIXME: This could be either Cube or Volume, but we wouldn't know unless
310 * we waited to generate the shader until the textures were all bound.
311 * For now, use Cube textures because they are more common. */
312 DWORD sampler_code = *pToken & D3DSP_REGNUM_MASK;
313 reg_maps->samplers[sampler_code] = (0x1 << 31) | D3DSTT_CUBE;
316 /* This will loop over all the registers and try to
317 * make a bitmask of the ones we're interested in.
319 * Relative addressing tokens are ignored, but that's
320 * okay, since we'll catch any address registers when
321 * they are initialized (required by spec) */
323 limit = (opcode_token & D3DSHADER_INSTRUCTION_PREDICATED)?
324 curOpcode->num_params + 1: curOpcode->num_params;
326 for (i = 0; i < limit; ++i) {
328 DWORD param, addr_token, reg, regtype;
329 pToken += shader_get_param(iface, pToken, ¶m, &addr_token);
331 regtype = shader_get_regtype(param);
332 reg = param & D3DSP_REGNUM_MASK;
334 if (D3DSPR_TEXTURE == regtype) { /* vs: D3DSPR_ADDR */
337 reg_maps->texcoord[reg] = 1;
339 reg_maps->address[reg] = 1;
342 else if (D3DSPR_TEMP == regtype)
343 reg_maps->temporary[reg] = 1;
345 else if (D3DSPR_INPUT == regtype && !pshader)
346 reg_maps->attributes[reg] = 1;
348 else if (D3DSPR_RASTOUT == regtype && reg == 1)
357 static void shader_dump_decl_usage(
358 IWineD3DBaseShaderImpl* This,
362 DWORD regtype = shader_get_regtype(param);
366 if (regtype == D3DSPR_SAMPLER) {
367 DWORD ttype = decl & D3DSP_TEXTURETYPE_MASK;
370 case D3DSTT_2D: TRACE("_2d"); break;
371 case D3DSTT_CUBE: TRACE("_cube"); break;
372 case D3DSTT_VOLUME: TRACE("_volume"); break;
373 default: TRACE("_unknown_ttype(%08lx)", ttype);
378 DWORD usage = decl & D3DSP_DCL_USAGE_MASK;
379 DWORD idx = (decl & D3DSP_DCL_USAGEINDEX_MASK) >> D3DSP_DCL_USAGEINDEX_SHIFT;
381 /* Pixel shaders 3.0 don't have usage semantics */
382 char pshader = shader_is_pshader_version(This->baseShader.hex_version);
383 if (pshader && This->baseShader.hex_version < D3DPS_VERSION(3,0))
389 case D3DDECLUSAGE_POSITION:
390 TRACE("%s%ld", "position", idx);
392 case D3DDECLUSAGE_BLENDINDICES:
393 TRACE("%s", "blend");
395 case D3DDECLUSAGE_BLENDWEIGHT:
396 TRACE("%s", "weight");
398 case D3DDECLUSAGE_NORMAL:
399 TRACE("%s%ld", "normal", idx);
401 case D3DDECLUSAGE_PSIZE:
402 TRACE("%s", "psize");
404 case D3DDECLUSAGE_COLOR:
406 TRACE("%s", "color");
408 TRACE("%s%ld", "specular", (idx - 1));
411 case D3DDECLUSAGE_TEXCOORD:
412 TRACE("%s%ld", "texture", idx);
414 case D3DDECLUSAGE_TANGENT:
415 TRACE("%s", "tangent");
417 case D3DDECLUSAGE_BINORMAL:
418 TRACE("%s", "binormal");
420 case D3DDECLUSAGE_TESSFACTOR:
421 TRACE("%s", "tessfactor");
423 case D3DDECLUSAGE_POSITIONT:
424 TRACE("%s%ld", "positionT", idx);
426 case D3DDECLUSAGE_FOG:
429 case D3DDECLUSAGE_DEPTH:
430 TRACE("%s", "depth");
432 case D3DDECLUSAGE_SAMPLE:
433 TRACE("%s", "sample");
436 FIXME("unknown_semantics(%08lx)", usage);
441 static void shader_dump_arr_entry(
442 IWineD3DBaseShader *iface,
444 const DWORD addr_token,
449 ((param & D3DSHADER_ADDRESSMODE_MASK) == D3DSHADER_ADDRMODE_RELATIVE);
454 shader_dump_param(iface, addr_token, 0, input);
464 void shader_dump_param(
465 IWineD3DBaseShader *iface,
467 const DWORD addr_token,
470 IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
471 static const char* rastout_reg_names[] = { "oPos", "oFog", "oPts" };
472 char swizzle_reg_chars[4];
474 DWORD reg = param & D3DSP_REGNUM_MASK;
475 DWORD regtype = shader_get_regtype(param);
476 DWORD modifier = param & D3DSP_SRCMOD_MASK;
478 /* There are some minor differences between pixel and vertex shaders */
479 char pshader = shader_is_pshader_version(This->baseShader.hex_version);
481 /* For one, we'd prefer color components to be shown for pshaders.
482 * FIXME: use the swizzle function for this */
484 swizzle_reg_chars[0] = pshader? 'r': 'x';
485 swizzle_reg_chars[1] = pshader? 'g': 'y';
486 swizzle_reg_chars[2] = pshader? 'b': 'z';
487 swizzle_reg_chars[3] = pshader? 'a': 'w';
490 if ( (modifier == D3DSPSM_NEG) ||
491 (modifier == D3DSPSM_BIASNEG) ||
492 (modifier == D3DSPSM_SIGNNEG) ||
493 (modifier == D3DSPSM_X2NEG) ||
494 (modifier == D3DSPSM_ABSNEG) )
496 else if (modifier == D3DSPSM_COMP)
498 else if (modifier == D3DSPSM_NOT)
501 if (modifier == D3DSPSM_ABS || modifier == D3DSPSM_ABSNEG)
511 shader_dump_arr_entry(iface, param, addr_token, reg, input);
518 shader_dump_arr_entry(iface, param, addr_token, shader_get_float_offset(param), input);
520 case D3DSPR_TEXTURE: /* vs: case D3DSPR_ADDR */
521 TRACE("%c%lu", (pshader? 't':'a'), reg);
524 TRACE("%s", rastout_reg_names[reg]);
526 case D3DSPR_COLOROUT:
529 case D3DSPR_DEPTHOUT:
535 case D3DSPR_TEXCRDOUT:
537 /* Vertex shaders >= 3.0 use general purpose output registers
538 * (D3DSPR_OUTPUT), which can include an address token */
540 if (D3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) >= 3) {
542 shader_dump_arr_entry(iface, param, addr_token, reg, input);
547 case D3DSPR_CONSTINT:
549 shader_dump_arr_entry(iface, param, addr_token, reg, input);
551 case D3DSPR_CONSTBOOL:
553 shader_dump_arr_entry(iface, param, addr_token, reg, input);
564 case D3DSPR_PREDICATE:
568 TRACE("unhandled_rtype(%#lx)", regtype);
573 /* operand output (for modifiers and shift, see dump_ins_modifiers) */
575 if ((param & D3DSP_WRITEMASK_ALL) != D3DSP_WRITEMASK_ALL) {
577 if (param & D3DSP_WRITEMASK_0) TRACE("%c", swizzle_reg_chars[0]);
578 if (param & D3DSP_WRITEMASK_1) TRACE("%c", swizzle_reg_chars[1]);
579 if (param & D3DSP_WRITEMASK_2) TRACE("%c", swizzle_reg_chars[2]);
580 if (param & D3DSP_WRITEMASK_3) TRACE("%c", swizzle_reg_chars[3]);
585 DWORD swizzle = (param & D3DSP_SWIZZLE_MASK) >> D3DSP_SWIZZLE_SHIFT;
586 DWORD swizzle_r = swizzle & 0x03;
587 DWORD swizzle_g = (swizzle >> 2) & 0x03;
588 DWORD swizzle_b = (swizzle >> 4) & 0x03;
589 DWORD swizzle_a = (swizzle >> 6) & 0x03;
593 case D3DSPSM_NONE: break;
594 case D3DSPSM_NEG: break;
595 case D3DSPSM_NOT: break;
596 case D3DSPSM_BIAS: TRACE("_bias"); break;
597 case D3DSPSM_BIASNEG: TRACE("_bias"); break;
598 case D3DSPSM_SIGN: TRACE("_bx2"); break;
599 case D3DSPSM_SIGNNEG: TRACE("_bx2"); break;
600 case D3DSPSM_COMP: break;
601 case D3DSPSM_X2: TRACE("_x2"); break;
602 case D3DSPSM_X2NEG: TRACE("_x2"); break;
603 case D3DSPSM_DZ: TRACE("_dz"); break;
604 case D3DSPSM_DW: TRACE("_dw"); break;
605 case D3DSPSM_ABSNEG: TRACE(")"); break;
606 case D3DSPSM_ABS: TRACE(")"); break;
608 TRACE("_unknown_modifier(%#lx)", modifier >> D3DSP_SRCMOD_SHIFT);
613 * swizzle bits fields:
616 if ((D3DVS_NOSWIZZLE >> D3DVS_SWIZZLE_SHIFT) != swizzle) { /* ! D3DVS_NOSWIZZLE == 0xE4 << D3DVS_SWIZZLE_SHIFT */
617 if (swizzle_r == swizzle_g &&
618 swizzle_r == swizzle_b &&
619 swizzle_r == swizzle_a) {
620 TRACE(".%c", swizzle_reg_chars[swizzle_r]);
623 swizzle_reg_chars[swizzle_r],
624 swizzle_reg_chars[swizzle_g],
625 swizzle_reg_chars[swizzle_b],
626 swizzle_reg_chars[swizzle_a]);
632 /** Shared code in order to generate the bulk of the shader string.
633 Use the shader_header_fct & shader_footer_fct to add strings
634 that are specific to pixel or vertex functions
635 NOTE: A description of how to parse tokens can be found at:
636 http://msdn.microsoft.com/library/default.asp?url=/library/en-us/graphics/hh/graphics/usermodedisplaydriver_shader_cc8e4e05-f5c3-4ec0-8853-8ce07c1551b2.xml.asp */
637 void shader_generate_main(
638 IWineD3DBaseShader *iface,
639 SHADER_BUFFER* buffer,
640 shader_reg_maps* reg_maps,
641 CONST DWORD* pFunction) {
643 IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
644 const DWORD *pToken = pFunction;
645 const SHADER_OPCODE *curOpcode = NULL;
646 SHADER_HANDLER hw_fct = NULL;
648 SHADER_OPCODE_ARG hw_arg;
650 /* Initialize current parsing state */
651 hw_arg.shader = iface;
652 hw_arg.buffer = buffer;
653 hw_arg.reg_maps = reg_maps;
654 This->baseShader.parse_state.current_row = 0;
656 /* Second pass, process opcodes */
657 if (NULL != pToken) {
658 while (D3DPS_END() != *pToken) {
660 /* Skip version token */
661 if (shader_is_version_token(*pToken)) {
666 /* Skip comment tokens */
667 if (shader_is_comment(*pToken)) {
668 DWORD comment_len = (*pToken & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT;
670 TRACE("#%s\n", (char*)pToken);
671 pToken += comment_len;
676 hw_arg.opcode_token = *pToken++;
677 curOpcode = shader_get_opcode(iface, hw_arg.opcode_token);
680 if (curOpcode == NULL)
682 else if (This->baseShader.shader_mode == SHADER_GLSL)
683 hw_fct = curOpcode->hw_glsl_fct;
684 else if (This->baseShader.shader_mode == SHADER_ARB)
685 hw_fct = curOpcode->hw_fct;
687 /* Unknown opcode and its parameters */
688 if (NULL == curOpcode) {
689 FIXME("Unrecognized opcode: token=%08lX\n", hw_arg.opcode_token);
690 pToken += shader_skip_unrecognized(iface, pToken);
693 } else if (D3DSIO_DCL == curOpcode->opcode ||
694 D3DSIO_NOP == curOpcode->opcode ||
695 D3DSIO_DEF == curOpcode->opcode ||
696 D3DSIO_DEFI == curOpcode->opcode ||
697 D3DSIO_DEFB == curOpcode->opcode ||
698 D3DSIO_RET == curOpcode->opcode) {
700 pToken += shader_skip_opcode(This, curOpcode, hw_arg.opcode_token);
702 /* If a generator function is set for current shader target, use it */
703 } else if (hw_fct != NULL) {
705 hw_arg.opcode = curOpcode;
707 /* Destination token */
708 if (curOpcode->dst_token) {
710 DWORD param, addr_token = 0;
711 pToken += shader_get_param(iface, pToken, ¶m, &addr_token);
713 hw_arg.dst_addr = addr_token;
716 /* Predication token */
717 if (hw_arg.opcode_token & D3DSHADER_INSTRUCTION_PREDICATED)
718 hw_arg.predicate = *pToken++;
720 /* Other source tokens */
721 for (i = 0; i < (curOpcode->num_params - curOpcode->dst_token); i++) {
723 DWORD param, addr_token = 0;
724 pToken += shader_get_param(iface, pToken, ¶m, &addr_token);
725 hw_arg.src[i] = param;
726 hw_arg.src_addr[i] = addr_token;
729 /* Call appropriate function for output target */
732 /* Process instruction modifiers for GLSL apps ( _sat, etc. ) */
733 if (This->baseShader.shader_mode == SHADER_GLSL)
734 shader_glsl_add_instruction_modifiers(&hw_arg);
736 /* Unhandled opcode */
739 FIXME("Can't handle opcode %s in hwShader\n", curOpcode->name);
740 pToken += shader_skip_opcode(This, curOpcode, hw_arg.opcode_token);
743 /* TODO: What about result.depth? */
748 void shader_dump_ins_modifiers(const DWORD output) {
750 DWORD shift = (output & D3DSP_DSTSHIFT_MASK) >> D3DSP_DSTSHIFT_SHIFT;
751 DWORD mmask = output & D3DSP_DSTMOD_MASK;
755 case 13: TRACE("_d8"); break;
756 case 14: TRACE("_d4"); break;
757 case 15: TRACE("_d2"); break;
758 case 1: TRACE("_x2"); break;
759 case 2: TRACE("_x4"); break;
760 case 3: TRACE("_x8"); break;
761 default: TRACE("_unhandled_shift(%ld)", shift); break;
764 if (mmask & D3DSPDM_SATURATE) TRACE("_sat");
765 if (mmask & D3DSPDM_PARTIALPRECISION) TRACE("_pp");
766 if (mmask & D3DSPDM_MSAMPCENTROID) TRACE("_centroid");
768 mmask &= ~(D3DSPDM_SATURATE | D3DSPDM_PARTIALPRECISION | D3DSPDM_MSAMPCENTROID);
770 FIXME("_unrecognized_modifier(%#lx)", mmask >> D3DSP_DSTMOD_SHIFT);
773 /* First pass: trace shader, initialize length and version */
774 void shader_trace_init(
775 IWineD3DBaseShader *iface,
776 const DWORD* pFunction) {
778 IWineD3DBaseShaderImpl *This =(IWineD3DBaseShaderImpl *)iface;
780 const DWORD* pToken = pFunction;
781 const SHADER_OPCODE* curOpcode = NULL;
783 unsigned int len = 0;
786 TRACE("(%p) : Parsing programme\n", This);
788 if (NULL != pToken) {
789 while (D3DVS_END() != *pToken) {
790 if (shader_is_version_token(*pToken)) { /** version */
791 This->baseShader.hex_version = *pToken;
792 TRACE("%s_%lu_%lu\n", shader_is_pshader_version(This->baseShader.hex_version)? "ps": "vs",
793 D3DSHADER_VERSION_MAJOR(This->baseShader.hex_version),
794 D3DSHADER_VERSION_MINOR(This->baseShader.hex_version));
799 if (shader_is_comment(*pToken)) { /** comment */
800 DWORD comment_len = (*pToken & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT;
802 TRACE("//%s\n", (char*)pToken);
803 pToken += comment_len;
804 len += comment_len + 1;
807 opcode_token = *pToken++;
808 curOpcode = shader_get_opcode(iface, opcode_token);
811 if (NULL == curOpcode) {
813 FIXME("Unrecognized opcode: token=%08lX\n", opcode_token);
814 tokens_read = shader_skip_unrecognized(iface, pToken);
815 pToken += tokens_read;
819 if (curOpcode->opcode == D3DSIO_DCL) {
821 DWORD usage = *pToken;
822 DWORD param = *(pToken + 1);
824 shader_dump_decl_usage(This, usage, param);
825 shader_dump_ins_modifiers(param);
827 shader_dump_param(iface, param, 0, 0);
831 } else if (curOpcode->opcode == D3DSIO_DEF) {
833 unsigned int offset = shader_get_float_offset(*pToken);
835 TRACE("def c%u = %f, %f, %f, %f", offset,
836 *(float *)(pToken + 1),
837 *(float *)(pToken + 2),
838 *(float *)(pToken + 3),
839 *(float *)(pToken + 4));
843 } else if (curOpcode->opcode == D3DSIO_DEFI) {
845 TRACE("defi i%lu = %ld, %ld, %ld, %ld", *pToken & D3DSP_REGNUM_MASK,
846 (long) *(pToken + 1),
847 (long) *(pToken + 2),
848 (long) *(pToken + 3),
849 (long) *(pToken + 4));
854 } else if (curOpcode->opcode == D3DSIO_DEFB) {
856 TRACE("defb b%lu = %s", *pToken & D3DSP_REGNUM_MASK,
857 *(pToken + 1)? "true": "false");
864 DWORD param, addr_token;
867 /* Print out predication source token first - it follows
868 * the destination token. */
869 if (opcode_token & D3DSHADER_INSTRUCTION_PREDICATED) {
871 shader_dump_param(iface, *(pToken + 2), 0, 1);
875 TRACE("%s", curOpcode->name);
877 if (curOpcode->opcode == D3DSIO_IFC ||
878 curOpcode->opcode == D3DSIO_BREAKC) {
880 DWORD op = (opcode_token & INST_CONTROLS_MASK) >> INST_CONTROLS_SHIFT;
882 case COMPARISON_GT: TRACE("_gt"); break;
883 case COMPARISON_EQ: TRACE("_eq"); break;
884 case COMPARISON_GE: TRACE("_ge"); break;
885 case COMPARISON_LT: TRACE("_lt"); break;
886 case COMPARISON_NE: TRACE("_ne"); break;
887 case COMPARISON_LE: TRACE("_le"); break;
893 /* Destination token */
894 if (curOpcode->dst_token) {
896 /* Destination token */
897 tokens_read = shader_get_param(iface, pToken, ¶m, &addr_token);
898 pToken += tokens_read;
901 shader_dump_ins_modifiers(param);
903 shader_dump_param(iface, param, addr_token, 0);
906 /* Predication token - already printed out, just skip it */
907 if (opcode_token & D3DSHADER_INSTRUCTION_PREDICATED) {
912 /* Other source tokens */
913 for (i = curOpcode->dst_token; i < curOpcode->num_params; ++i) {
915 tokens_read = shader_get_param(iface, pToken, ¶m, &addr_token);
916 pToken += tokens_read;
919 TRACE((i == 0)? " " : ", ");
920 shader_dump_param(iface, param, addr_token, 1);
926 This->baseShader.functionLength = (len + 1) * sizeof(DWORD);
928 This->baseShader.functionLength = 1; /* no Function defined use fixed function vertex processing */
932 void shader_delete_constant_list(
933 struct list* clist) {
936 struct local_constant* constant;
938 ptr = list_head(clist);
940 constant = LIST_ENTRY(ptr, struct local_constant, entry);
941 ptr = list_next(clist, ptr);
942 HeapFree(GetProcessHeap(), 0, constant);