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) | WINED3DSTT_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) | WINED3DSTT_CUBE;
314 } else if (D3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) == 1 &&
315 (D3DSIO_TEXDP3TEX == curOpcode->opcode)) {
317 /* 1D Sampler usage */
318 DWORD sampler_code = *pToken & D3DSP_REGNUM_MASK;
319 reg_maps->samplers[sampler_code] = (0x1 << 31) | WINED3DSTT_1D;
322 /* This will loop over all the registers and try to
323 * make a bitmask of the ones we're interested in.
325 * Relative addressing tokens are ignored, but that's
326 * okay, since we'll catch any address registers when
327 * they are initialized (required by spec) */
329 limit = (opcode_token & D3DSHADER_INSTRUCTION_PREDICATED)?
330 curOpcode->num_params + 1: curOpcode->num_params;
332 for (i = 0; i < limit; ++i) {
334 DWORD param, addr_token, reg, regtype;
335 pToken += shader_get_param(iface, pToken, ¶m, &addr_token);
337 regtype = shader_get_regtype(param);
338 reg = param & D3DSP_REGNUM_MASK;
340 if (D3DSPR_TEXTURE == regtype) { /* vs: D3DSPR_ADDR */
343 reg_maps->texcoord[reg] = 1;
345 reg_maps->address[reg] = 1;
348 else if (D3DSPR_TEMP == regtype)
349 reg_maps->temporary[reg] = 1;
351 else if (D3DSPR_INPUT == regtype && !pshader)
352 reg_maps->attributes[reg] = 1;
354 else if (D3DSPR_RASTOUT == regtype && reg == 1)
363 static void shader_dump_decl_usage(
364 IWineD3DBaseShaderImpl* This,
368 DWORD regtype = shader_get_regtype(param);
372 if (regtype == D3DSPR_SAMPLER) {
373 DWORD ttype = decl & WINED3DSP_TEXTURETYPE_MASK;
376 case WINED3DSTT_2D: TRACE("_2d"); break;
377 case WINED3DSTT_CUBE: TRACE("_cube"); break;
378 case WINED3DSTT_VOLUME: TRACE("_volume"); break;
379 default: TRACE("_unknown_ttype(%08lx)", ttype);
384 DWORD usage = decl & D3DSP_DCL_USAGE_MASK;
385 DWORD idx = (decl & D3DSP_DCL_USAGEINDEX_MASK) >> D3DSP_DCL_USAGEINDEX_SHIFT;
387 /* Pixel shaders 3.0 don't have usage semantics */
388 char pshader = shader_is_pshader_version(This->baseShader.hex_version);
389 if (pshader && This->baseShader.hex_version < D3DPS_VERSION(3,0))
395 case D3DDECLUSAGE_POSITION:
396 TRACE("%s%ld", "position", idx);
398 case D3DDECLUSAGE_BLENDINDICES:
399 TRACE("%s", "blend");
401 case D3DDECLUSAGE_BLENDWEIGHT:
402 TRACE("%s", "weight");
404 case D3DDECLUSAGE_NORMAL:
405 TRACE("%s%ld", "normal", idx);
407 case D3DDECLUSAGE_PSIZE:
408 TRACE("%s", "psize");
410 case D3DDECLUSAGE_COLOR:
412 TRACE("%s", "color");
414 TRACE("%s%ld", "specular", (idx - 1));
417 case D3DDECLUSAGE_TEXCOORD:
418 TRACE("%s%ld", "texture", idx);
420 case D3DDECLUSAGE_TANGENT:
421 TRACE("%s", "tangent");
423 case D3DDECLUSAGE_BINORMAL:
424 TRACE("%s", "binormal");
426 case D3DDECLUSAGE_TESSFACTOR:
427 TRACE("%s", "tessfactor");
429 case D3DDECLUSAGE_POSITIONT:
430 TRACE("%s%ld", "positionT", idx);
432 case D3DDECLUSAGE_FOG:
435 case D3DDECLUSAGE_DEPTH:
436 TRACE("%s", "depth");
438 case D3DDECLUSAGE_SAMPLE:
439 TRACE("%s", "sample");
442 FIXME("unknown_semantics(%08lx)", usage);
447 static void shader_dump_arr_entry(
448 IWineD3DBaseShader *iface,
450 const DWORD addr_token,
455 ((param & D3DSHADER_ADDRESSMODE_MASK) == D3DSHADER_ADDRMODE_RELATIVE);
460 shader_dump_param(iface, addr_token, 0, input);
470 void shader_dump_param(
471 IWineD3DBaseShader *iface,
473 const DWORD addr_token,
476 IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
477 static const char* rastout_reg_names[] = { "oPos", "oFog", "oPts" };
478 char swizzle_reg_chars[4];
480 DWORD reg = param & D3DSP_REGNUM_MASK;
481 DWORD regtype = shader_get_regtype(param);
482 DWORD modifier = param & D3DSP_SRCMOD_MASK;
484 /* There are some minor differences between pixel and vertex shaders */
485 char pshader = shader_is_pshader_version(This->baseShader.hex_version);
487 /* For one, we'd prefer color components to be shown for pshaders.
488 * FIXME: use the swizzle function for this */
490 swizzle_reg_chars[0] = pshader? 'r': 'x';
491 swizzle_reg_chars[1] = pshader? 'g': 'y';
492 swizzle_reg_chars[2] = pshader? 'b': 'z';
493 swizzle_reg_chars[3] = pshader? 'a': 'w';
496 if ( (modifier == D3DSPSM_NEG) ||
497 (modifier == D3DSPSM_BIASNEG) ||
498 (modifier == D3DSPSM_SIGNNEG) ||
499 (modifier == D3DSPSM_X2NEG) ||
500 (modifier == D3DSPSM_ABSNEG) )
502 else if (modifier == D3DSPSM_COMP)
504 else if (modifier == D3DSPSM_NOT)
507 if (modifier == D3DSPSM_ABS || modifier == D3DSPSM_ABSNEG)
517 shader_dump_arr_entry(iface, param, addr_token, reg, input);
524 shader_dump_arr_entry(iface, param, addr_token, shader_get_float_offset(param), input);
526 case D3DSPR_TEXTURE: /* vs: case D3DSPR_ADDR */
527 TRACE("%c%lu", (pshader? 't':'a'), reg);
530 TRACE("%s", rastout_reg_names[reg]);
532 case D3DSPR_COLOROUT:
535 case D3DSPR_DEPTHOUT:
541 case D3DSPR_TEXCRDOUT:
543 /* Vertex shaders >= 3.0 use general purpose output registers
544 * (D3DSPR_OUTPUT), which can include an address token */
546 if (D3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) >= 3) {
548 shader_dump_arr_entry(iface, param, addr_token, reg, input);
553 case D3DSPR_CONSTINT:
555 shader_dump_arr_entry(iface, param, addr_token, reg, input);
557 case D3DSPR_CONSTBOOL:
559 shader_dump_arr_entry(iface, param, addr_token, reg, input);
570 case D3DSPR_PREDICATE:
574 TRACE("unhandled_rtype(%#lx)", regtype);
579 /* operand output (for modifiers and shift, see dump_ins_modifiers) */
581 if ((param & D3DSP_WRITEMASK_ALL) != D3DSP_WRITEMASK_ALL) {
583 if (param & D3DSP_WRITEMASK_0) TRACE("%c", swizzle_reg_chars[0]);
584 if (param & D3DSP_WRITEMASK_1) TRACE("%c", swizzle_reg_chars[1]);
585 if (param & D3DSP_WRITEMASK_2) TRACE("%c", swizzle_reg_chars[2]);
586 if (param & D3DSP_WRITEMASK_3) TRACE("%c", swizzle_reg_chars[3]);
591 DWORD swizzle = (param & D3DSP_SWIZZLE_MASK) >> D3DSP_SWIZZLE_SHIFT;
592 DWORD swizzle_r = swizzle & 0x03;
593 DWORD swizzle_g = (swizzle >> 2) & 0x03;
594 DWORD swizzle_b = (swizzle >> 4) & 0x03;
595 DWORD swizzle_a = (swizzle >> 6) & 0x03;
599 case D3DSPSM_NONE: break;
600 case D3DSPSM_NEG: break;
601 case D3DSPSM_NOT: break;
602 case D3DSPSM_BIAS: TRACE("_bias"); break;
603 case D3DSPSM_BIASNEG: TRACE("_bias"); break;
604 case D3DSPSM_SIGN: TRACE("_bx2"); break;
605 case D3DSPSM_SIGNNEG: TRACE("_bx2"); break;
606 case D3DSPSM_COMP: break;
607 case D3DSPSM_X2: TRACE("_x2"); break;
608 case D3DSPSM_X2NEG: TRACE("_x2"); break;
609 case D3DSPSM_DZ: TRACE("_dz"); break;
610 case D3DSPSM_DW: TRACE("_dw"); break;
611 case D3DSPSM_ABSNEG: TRACE(")"); break;
612 case D3DSPSM_ABS: TRACE(")"); break;
614 TRACE("_unknown_modifier(%#lx)", modifier >> D3DSP_SRCMOD_SHIFT);
619 * swizzle bits fields:
622 if ((D3DVS_NOSWIZZLE >> D3DVS_SWIZZLE_SHIFT) != swizzle) { /* ! D3DVS_NOSWIZZLE == 0xE4 << D3DVS_SWIZZLE_SHIFT */
623 if (swizzle_r == swizzle_g &&
624 swizzle_r == swizzle_b &&
625 swizzle_r == swizzle_a) {
626 TRACE(".%c", swizzle_reg_chars[swizzle_r]);
629 swizzle_reg_chars[swizzle_r],
630 swizzle_reg_chars[swizzle_g],
631 swizzle_reg_chars[swizzle_b],
632 swizzle_reg_chars[swizzle_a]);
638 /** Shared code in order to generate the bulk of the shader string.
639 Use the shader_header_fct & shader_footer_fct to add strings
640 that are specific to pixel or vertex functions
641 NOTE: A description of how to parse tokens can be found at:
642 http://msdn.microsoft.com/library/default.asp?url=/library/en-us/graphics/hh/graphics/usermodedisplaydriver_shader_cc8e4e05-f5c3-4ec0-8853-8ce07c1551b2.xml.asp */
643 void shader_generate_main(
644 IWineD3DBaseShader *iface,
645 SHADER_BUFFER* buffer,
646 shader_reg_maps* reg_maps,
647 CONST DWORD* pFunction) {
649 IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
650 const DWORD *pToken = pFunction;
651 const SHADER_OPCODE *curOpcode = NULL;
652 SHADER_HANDLER hw_fct = NULL;
654 SHADER_OPCODE_ARG hw_arg;
656 /* Initialize current parsing state */
657 hw_arg.shader = iface;
658 hw_arg.buffer = buffer;
659 hw_arg.reg_maps = reg_maps;
660 This->baseShader.parse_state.current_row = 0;
662 /* Second pass, process opcodes */
663 if (NULL != pToken) {
664 while (D3DPS_END() != *pToken) {
666 /* Skip version token */
667 if (shader_is_version_token(*pToken)) {
672 /* Skip comment tokens */
673 if (shader_is_comment(*pToken)) {
674 DWORD comment_len = (*pToken & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT;
676 TRACE("#%s\n", (char*)pToken);
677 pToken += comment_len;
682 hw_arg.opcode_token = *pToken++;
683 curOpcode = shader_get_opcode(iface, hw_arg.opcode_token);
686 if (curOpcode == NULL)
688 else if (This->baseShader.shader_mode == SHADER_GLSL)
689 hw_fct = curOpcode->hw_glsl_fct;
690 else if (This->baseShader.shader_mode == SHADER_ARB)
691 hw_fct = curOpcode->hw_fct;
693 /* Unknown opcode and its parameters */
694 if (NULL == curOpcode) {
695 FIXME("Unrecognized opcode: token=%08lX\n", hw_arg.opcode_token);
696 pToken += shader_skip_unrecognized(iface, pToken);
699 } else if (D3DSIO_DCL == curOpcode->opcode ||
700 D3DSIO_NOP == curOpcode->opcode ||
701 D3DSIO_DEF == curOpcode->opcode ||
702 D3DSIO_DEFI == curOpcode->opcode ||
703 D3DSIO_DEFB == curOpcode->opcode ||
704 D3DSIO_PHASE == curOpcode->opcode ||
705 D3DSIO_RET == curOpcode->opcode) {
707 pToken += shader_skip_opcode(This, curOpcode, hw_arg.opcode_token);
709 /* If a generator function is set for current shader target, use it */
710 } else if (hw_fct != NULL) {
712 hw_arg.opcode = curOpcode;
714 /* Destination token */
715 if (curOpcode->dst_token) {
717 DWORD param, addr_token = 0;
718 pToken += shader_get_param(iface, pToken, ¶m, &addr_token);
720 hw_arg.dst_addr = addr_token;
723 /* Predication token */
724 if (hw_arg.opcode_token & D3DSHADER_INSTRUCTION_PREDICATED)
725 hw_arg.predicate = *pToken++;
727 /* Other source tokens */
728 for (i = 0; i < (curOpcode->num_params - curOpcode->dst_token); i++) {
730 DWORD param, addr_token = 0;
731 pToken += shader_get_param(iface, pToken, ¶m, &addr_token);
732 hw_arg.src[i] = param;
733 hw_arg.src_addr[i] = addr_token;
736 /* Call appropriate function for output target */
739 /* Process instruction modifiers for GLSL apps ( _sat, etc. ) */
740 if (This->baseShader.shader_mode == SHADER_GLSL)
741 shader_glsl_add_instruction_modifiers(&hw_arg);
743 /* Unhandled opcode */
746 FIXME("Can't handle opcode %s in hwShader\n", curOpcode->name);
747 pToken += shader_skip_opcode(This, curOpcode, hw_arg.opcode_token);
750 /* TODO: What about result.depth? */
755 void shader_dump_ins_modifiers(const DWORD output) {
757 DWORD shift = (output & D3DSP_DSTSHIFT_MASK) >> D3DSP_DSTSHIFT_SHIFT;
758 DWORD mmask = output & D3DSP_DSTMOD_MASK;
762 case 13: TRACE("_d8"); break;
763 case 14: TRACE("_d4"); break;
764 case 15: TRACE("_d2"); break;
765 case 1: TRACE("_x2"); break;
766 case 2: TRACE("_x4"); break;
767 case 3: TRACE("_x8"); break;
768 default: TRACE("_unhandled_shift(%ld)", shift); break;
771 if (mmask & D3DSPDM_SATURATE) TRACE("_sat");
772 if (mmask & D3DSPDM_PARTIALPRECISION) TRACE("_pp");
773 if (mmask & D3DSPDM_MSAMPCENTROID) TRACE("_centroid");
775 mmask &= ~(D3DSPDM_SATURATE | D3DSPDM_PARTIALPRECISION | D3DSPDM_MSAMPCENTROID);
777 FIXME("_unrecognized_modifier(%#lx)", mmask >> D3DSP_DSTMOD_SHIFT);
780 /* First pass: trace shader, initialize length and version */
781 void shader_trace_init(
782 IWineD3DBaseShader *iface,
783 const DWORD* pFunction) {
785 IWineD3DBaseShaderImpl *This =(IWineD3DBaseShaderImpl *)iface;
787 const DWORD* pToken = pFunction;
788 const SHADER_OPCODE* curOpcode = NULL;
790 unsigned int len = 0;
793 TRACE("(%p) : Parsing programme\n", This);
795 if (NULL != pToken) {
796 while (D3DVS_END() != *pToken) {
797 if (shader_is_version_token(*pToken)) { /** version */
798 This->baseShader.hex_version = *pToken;
799 TRACE("%s_%lu_%lu\n", shader_is_pshader_version(This->baseShader.hex_version)? "ps": "vs",
800 D3DSHADER_VERSION_MAJOR(This->baseShader.hex_version),
801 D3DSHADER_VERSION_MINOR(This->baseShader.hex_version));
806 if (shader_is_comment(*pToken)) { /** comment */
807 DWORD comment_len = (*pToken & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT;
809 TRACE("//%s\n", (char*)pToken);
810 pToken += comment_len;
811 len += comment_len + 1;
814 opcode_token = *pToken++;
815 curOpcode = shader_get_opcode(iface, opcode_token);
818 if (NULL == curOpcode) {
820 FIXME("Unrecognized opcode: token=%08lX\n", opcode_token);
821 tokens_read = shader_skip_unrecognized(iface, pToken);
822 pToken += tokens_read;
826 if (curOpcode->opcode == D3DSIO_DCL) {
828 DWORD usage = *pToken;
829 DWORD param = *(pToken + 1);
831 shader_dump_decl_usage(This, usage, param);
832 shader_dump_ins_modifiers(param);
834 shader_dump_param(iface, param, 0, 0);
838 } else if (curOpcode->opcode == D3DSIO_DEF) {
840 unsigned int offset = shader_get_float_offset(*pToken);
842 TRACE("def c%u = %f, %f, %f, %f", offset,
843 *(float *)(pToken + 1),
844 *(float *)(pToken + 2),
845 *(float *)(pToken + 3),
846 *(float *)(pToken + 4));
850 } else if (curOpcode->opcode == D3DSIO_DEFI) {
852 TRACE("defi i%lu = %ld, %ld, %ld, %ld", *pToken & D3DSP_REGNUM_MASK,
853 (long) *(pToken + 1),
854 (long) *(pToken + 2),
855 (long) *(pToken + 3),
856 (long) *(pToken + 4));
861 } else if (curOpcode->opcode == D3DSIO_DEFB) {
863 TRACE("defb b%lu = %s", *pToken & D3DSP_REGNUM_MASK,
864 *(pToken + 1)? "true": "false");
871 DWORD param, addr_token;
874 /* Print out predication source token first - it follows
875 * the destination token. */
876 if (opcode_token & D3DSHADER_INSTRUCTION_PREDICATED) {
878 shader_dump_param(iface, *(pToken + 2), 0, 1);
882 TRACE("%s", curOpcode->name);
884 if (curOpcode->opcode == D3DSIO_IFC ||
885 curOpcode->opcode == D3DSIO_BREAKC) {
887 DWORD op = (opcode_token & INST_CONTROLS_MASK) >> INST_CONTROLS_SHIFT;
889 case COMPARISON_GT: TRACE("_gt"); break;
890 case COMPARISON_EQ: TRACE("_eq"); break;
891 case COMPARISON_GE: TRACE("_ge"); break;
892 case COMPARISON_LT: TRACE("_lt"); break;
893 case COMPARISON_NE: TRACE("_ne"); break;
894 case COMPARISON_LE: TRACE("_le"); break;
900 /* Destination token */
901 if (curOpcode->dst_token) {
903 /* Destination token */
904 tokens_read = shader_get_param(iface, pToken, ¶m, &addr_token);
905 pToken += tokens_read;
908 shader_dump_ins_modifiers(param);
910 shader_dump_param(iface, param, addr_token, 0);
913 /* Predication token - already printed out, just skip it */
914 if (opcode_token & D3DSHADER_INSTRUCTION_PREDICATED) {
919 /* Other source tokens */
920 for (i = curOpcode->dst_token; i < curOpcode->num_params; ++i) {
922 tokens_read = shader_get_param(iface, pToken, ¶m, &addr_token);
923 pToken += tokens_read;
926 TRACE((i == 0)? " " : ", ");
927 shader_dump_param(iface, param, addr_token, 1);
933 This->baseShader.functionLength = (len + 1) * sizeof(DWORD);
935 This->baseShader.functionLength = 1; /* no Function defined use fixed function vertex processing */
939 void shader_delete_constant_list(
940 struct list* clist) {
943 struct local_constant* constant;
945 ptr = list_head(clist);
947 constant = LIST_ENTRY(ptr, struct local_constant, entry);
948 ptr = list_next(clist, ptr);
949 HeapFree(GetProcessHeap(), 0, constant);