2 * shaders implementation
4 * Copyright 2002-2003 Jason Edmeades
5 * Copyright 2002-2003 Raphael Junqueira
6 * Copyright 2005 Oliver Stieber
7 * Copyright 2006 Ivan Gyurdiev
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.
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.
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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
27 #include "wined3d_private.h"
29 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader
);
31 #define GLNAME_REQUIRE_GLSL ((const char *)1)
33 inline static BOOL
shader_is_version_token(DWORD token
) {
34 return shader_is_pshader_version(token
) ||
35 shader_is_vshader_version(token
);
39 SHADER_BUFFER
* buffer
,
40 const char *format
, ...) {
42 char* base
= buffer
->buffer
+ buffer
->bsize
;
46 va_start(args
, format
);
47 rc
= vsnprintf(base
, SHADER_PGMSIZE
- 1 - buffer
->bsize
, format
, args
);
50 if (rc
< 0 || /* C89 */
51 rc
> SHADER_PGMSIZE
- 1 - buffer
->bsize
) { /* C99 */
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;
61 TRACE("GL HW (%u, %u) : %s", buffer
->lineNo
, buffer
->bsize
, base
);
65 const SHADER_OPCODE
* shader_get_opcode(
66 IWineD3DBaseShader
*iface
, const DWORD code
) {
68 IWineD3DBaseShaderImpl
*This
= (IWineD3DBaseShaderImpl
*) iface
;
71 DWORD hex_version
= This
->baseShader
.hex_version
;
72 const SHADER_OPCODE
*shader_ins
= This
->baseShader
.shader_ins
;
74 /** TODO: use dichotomic search */
75 while (NULL
!= shader_ins
[i
].name
) {
76 if (((code
& D3DSI_OPCODE_MASK
) == shader_ins
[i
].opcode
) &&
77 (((hex_version
>= shader_ins
[i
].min_version
) && (hex_version
<= shader_ins
[i
].max_version
)) ||
78 ((shader_ins
[i
].min_version
== 0) && (shader_ins
[i
].max_version
== 0)))) {
79 return &shader_ins
[i
];
83 FIXME("Unsupported opcode %#lx(%ld) masked %#lx, shader version %#lx\n",
84 code
, code
, code
& D3DSI_OPCODE_MASK
, hex_version
);
88 /* Read a parameter opcode from the input stream,
89 * and possibly a relative addressing token.
90 * Return the number of tokens read */
92 IWineD3DBaseShader
* iface
,
97 /* PS >= 3.0 have relative addressing (with token)
98 * VS >= 2.0 have relative addressing (with token)
99 * VS >= 1.0 < 2.0 have relative addressing (without token)
100 * The version check below should work in general */
102 IWineD3DBaseShaderImpl
* This
= (IWineD3DBaseShaderImpl
*) iface
;
103 char rel_token
= D3DSHADER_VERSION_MAJOR(This
->baseShader
.hex_version
) >= 2 &&
104 ((*pToken
& D3DSHADER_ADDRESSMODE_MASK
) == D3DSHADER_ADDRMODE_RELATIVE
);
107 *addr_token
= rel_token
? *(pToken
+ 1): 0;
108 return rel_token
? 2:1;
111 /* Return the number of parameters to skip for an opcode */
112 static inline int shader_skip_opcode(
113 IWineD3DBaseShaderImpl
* This
,
114 const SHADER_OPCODE
* curOpcode
,
115 DWORD opcode_token
) {
117 /* Shaders >= 2.0 may contain address tokens, but fortunately they
118 * have a useful legnth mask - use it here. Shaders 1.0 contain no such tokens */
120 return (D3DSHADER_VERSION_MAJOR(This
->baseShader
.hex_version
) >= 2)?
121 ((opcode_token
& D3DSI_INSTLENGTH_MASK
) >> D3DSI_INSTLENGTH_SHIFT
):
122 curOpcode
->num_params
;
125 /* Read the parameters of an unrecognized opcode from the input stream
126 * Return the number of tokens read.
128 * Note: This function assumes source or destination token format.
129 * It will not work with specially-formatted tokens like DEF or DCL,
130 * but hopefully those would be recognized */
132 int shader_skip_unrecognized(
133 IWineD3DBaseShader
* iface
,
134 const DWORD
* pToken
) {
139 /* TODO: Think of a good name for 0x80000000 and replace it with a constant */
140 while (*pToken
& 0x80000000) {
142 DWORD param
, addr_token
;
143 tokens_read
+= shader_get_param(iface
, pToken
, ¶m
, &addr_token
);
144 pToken
+= tokens_read
;
146 FIXME("Unrecognized opcode param: token=%08lX "
147 "addr_token=%08lX name=", param
, addr_token
);
148 shader_dump_param(iface
, param
, addr_token
, i
);
155 /* Convert floating point offset relative
156 * to a register file to an absolute offset for float constants */
158 unsigned int shader_get_float_offset(const DWORD reg
) {
160 unsigned int regnum
= reg
& D3DSP_REGNUM_MASK
;
161 int regtype
= shader_get_regtype(reg
);
164 case D3DSPR_CONST
: return regnum
;
165 case D3DSPR_CONST2
: return 2048 + regnum
;
166 case D3DSPR_CONST3
: return 4096 + regnum
;
167 case D3DSPR_CONST4
: return 6144 + regnum
;
169 FIXME("Unsupported register type: %d\n", regtype
);
174 static void shader_parse_decl_usage(
175 DWORD
*semantics_map
,
176 DWORD usage_token
, DWORD param
) {
178 unsigned int usage
= (usage_token
& D3DSP_DCL_USAGE_MASK
) >> D3DSP_DCL_USAGE_SHIFT
;
179 unsigned int usage_idx
= (usage_token
& D3DSP_DCL_USAGEINDEX_MASK
) >> D3DSP_DCL_USAGEINDEX_SHIFT
;
180 unsigned int regnum
= param
& D3DSP_REGNUM_MASK
;
183 case D3DDECLUSAGE_POSITION
:
184 if (usage_idx
== 0) { /* tween data */
185 TRACE("Setting position to %d\n", regnum
);
186 semantics_map
[WINED3DSHADERDECLUSAGE_POSITION
] = param
;
188 /* TODO: position indexes go from 0-8!!*/
189 TRACE("Setting position 2 to %d because usage_idx = %d\n", regnum
, usage_idx
);
190 /* robots uses positions up to 8, the position arrays are just packed.*/
192 TRACE("Loaded for position %d (greater than 2)\n", usage_idx
);
194 semantics_map
[WINED3DSHADERDECLUSAGE_POSITION2
+ usage_idx
-1] = param
;
198 case D3DDECLUSAGE_BLENDINDICES
:
199 TRACE("Setting BLENDINDICES to %d\n", regnum
);
200 semantics_map
[WINED3DSHADERDECLUSAGE_BLENDINDICES
] = param
;
201 if (usage_idx
!= 0) FIXME("Extended BLENDINDICES\n");
204 case D3DDECLUSAGE_BLENDWEIGHT
:
205 TRACE("Setting BLENDWEIGHT to %d\n", regnum
);
206 semantics_map
[WINED3DSHADERDECLUSAGE_BLENDWEIGHT
] = param
;
207 if (usage_idx
!= 0) FIXME("Extended blend weights\n");
210 case D3DDECLUSAGE_NORMAL
:
211 if (usage_idx
== 0) { /* tween data */
212 TRACE("Setting normal to %d\n", regnum
);
213 semantics_map
[WINED3DSHADERDECLUSAGE_NORMAL
] = param
;
215 TRACE("Setting normal 2 to %d because usage = %d\n", regnum
, usage_idx
);
216 semantics_map
[WINED3DSHADERDECLUSAGE_NORMAL2
] = param
;
220 case D3DDECLUSAGE_PSIZE
:
221 TRACE("Setting PSIZE to %d\n", regnum
);
222 semantics_map
[WINED3DSHADERDECLUSAGE_PSIZE
] = param
;
223 if (usage_idx
!= 0) FIXME("Extended PSIZE\n");
226 case D3DDECLUSAGE_COLOR
:
227 if (usage_idx
== 0) {
228 TRACE("Setting DIFFUSE to %d\n", regnum
);
229 semantics_map
[WINED3DSHADERDECLUSAGE_DIFFUSE
] = param
;
231 TRACE("Setting SPECULAR to %d\n", regnum
);
232 semantics_map
[WINED3DSHADERDECLUSAGE_SPECULAR
] = param
;
236 case D3DDECLUSAGE_TEXCOORD
:
238 FIXME("Program uses texture coordinate %d but only 0-7 have been "
239 "implemented\n", usage_idx
);
241 TRACE("Setting TEXCOORD %d to %d\n", usage_idx
, regnum
);
242 semantics_map
[WINED3DSHADERDECLUSAGE_TEXCOORD0
+ usage_idx
] = param
;
246 case D3DDECLUSAGE_TANGENT
:
247 TRACE("Setting TANGENT to %d\n", regnum
);
248 semantics_map
[WINED3DSHADERDECLUSAGE_TANGENT
] = param
;
251 case D3DDECLUSAGE_BINORMAL
:
252 TRACE("Setting BINORMAL to %d\n", regnum
);
253 semantics_map
[WINED3DSHADERDECLUSAGE_BINORMAL
] = param
;
256 case D3DDECLUSAGE_TESSFACTOR
:
257 TRACE("Setting TESSFACTOR to %d\n", regnum
);
258 semantics_map
[WINED3DSHADERDECLUSAGE_TESSFACTOR
] = param
;
261 case D3DDECLUSAGE_POSITIONT
:
262 if (usage_idx
== 0) { /* tween data */
263 FIXME("Setting positiont to %d\n", regnum
);
264 semantics_map
[WINED3DSHADERDECLUSAGE_POSITIONT
] = param
;
266 FIXME("Setting positiont 2 to %d because usage = %d\n", regnum
, usage_idx
);
267 semantics_map
[WINED3DSHADERDECLUSAGE_POSITIONT2
] = param
;
268 if (usage_idx
!= 0) FIXME("Extended positiont\n");
272 case D3DDECLUSAGE_FOG
:
273 TRACE("Setting FOG to %d\n", regnum
);
274 semantics_map
[WINED3DSHADERDECLUSAGE_FOG
] = param
;
277 case D3DDECLUSAGE_DEPTH
:
278 TRACE("Setting DEPTH to %d\n", regnum
);
279 semantics_map
[WINED3DSHADERDECLUSAGE_DEPTH
] = param
;
282 case D3DDECLUSAGE_SAMPLE
:
283 TRACE("Setting SAMPLE to %d\n", regnum
);
284 semantics_map
[WINED3DSHADERDECLUSAGE_SAMPLE
] = param
;
288 FIXME("Unrecognised dcl %#x", usage
);
292 /* Note that this does not count the loop register
293 * as an address register. */
295 void shader_get_registers_used(
296 IWineD3DBaseShader
*iface
,
297 shader_reg_maps
* reg_maps
,
298 CONST DWORD
* pToken
) {
300 IWineD3DBaseShaderImpl
* This
= (IWineD3DBaseShaderImpl
*) iface
;
302 /* There are some minor differences between pixel and vertex shaders */
303 char pshader
= shader_is_pshader_version(This
->baseShader
.hex_version
);
308 while (D3DVS_END() != *pToken
) {
309 CONST SHADER_OPCODE
* curOpcode
;
313 if (shader_is_version_token(*pToken
)) {
318 } else if (shader_is_comment(*pToken
)) {
319 DWORD comment_len
= (*pToken
& D3DSI_COMMENTSIZE_MASK
) >> D3DSI_COMMENTSIZE_SHIFT
;
321 pToken
+= comment_len
;
326 opcode_token
= *pToken
++;
327 curOpcode
= shader_get_opcode(iface
, opcode_token
);
329 /* Unhandled opcode, and its parameters */
330 if (NULL
== curOpcode
) {
331 while (*pToken
& 0x80000000)
334 /* Handle declarations */
335 } else if (D3DSIO_DCL
== curOpcode
->opcode
) {
337 DWORD usage
= *pToken
++;
338 DWORD param
= *pToken
++;
339 DWORD regtype
= shader_get_regtype(param
);
340 unsigned int regnum
= param
& D3DSP_REGNUM_MASK
;
342 /* Vshader: mark attributes used
343 Pshader: mark 3.0 input registers used, save token */
344 if (D3DSPR_INPUT
== regtype
) {
347 reg_maps
->attributes
[regnum
] = 1;
349 reg_maps
->packed_input
[regnum
] = 1;
351 shader_parse_decl_usage(reg_maps
->semantics_in
, usage
, param
);
353 /* Vshader: mark 3.0 output registers used, save token */
354 } else if (D3DSPR_OUTPUT
== regtype
) {
355 reg_maps
->packed_output
[regnum
] = 1;
356 shader_parse_decl_usage(reg_maps
->semantics_out
, usage
, param
);
358 /* Save sampler usage token */
359 } else if (D3DSPR_SAMPLER
== regtype
)
360 reg_maps
->samplers
[regnum
] = usage
;
362 /* Skip definitions (for now) */
363 } else if (D3DSIO_DEF
== curOpcode
->opcode
) {
364 pToken
+= curOpcode
->num_params
;
366 /* Set texture, address, temporary registers */
370 /* Declare 1.X samplers implicitly, based on the destination reg. number */
371 if (D3DSHADER_VERSION_MAJOR(This
->baseShader
.hex_version
) == 1 &&
372 (D3DSIO_TEX
== curOpcode
->opcode
||
373 D3DSIO_TEXM3x2TEX
== curOpcode
->opcode
||
374 D3DSIO_TEXM3x3TEX
== curOpcode
->opcode
||
375 D3DSIO_TEXM3x3SPEC
== curOpcode
->opcode
||
376 D3DSIO_TEXM3x3VSPEC
== curOpcode
->opcode
)) {
378 /* Fake sampler usage, only set reserved bit and ttype */
379 DWORD sampler_code
= *pToken
& D3DSP_REGNUM_MASK
;
380 reg_maps
->samplers
[sampler_code
] = (0x1 << 31) | D3DSTT_2D
;
383 /* This will loop over all the registers and try to
384 * make a bitmask of the ones we're interested in.
386 * Relative addressing tokens are ignored, but that's
387 * okay, since we'll catch any address registers when
388 * they are initialized (required by spec) */
390 limit
= (opcode_token
& D3DSHADER_INSTRUCTION_PREDICATED
)?
391 curOpcode
->num_params
+ 1: curOpcode
->num_params
;
393 for (i
= 0; i
< limit
; ++i
) {
395 DWORD param
, addr_token
, reg
, regtype
;
396 pToken
+= shader_get_param(iface
, pToken
, ¶m
, &addr_token
);
398 regtype
= (param
& D3DSP_REGTYPE_MASK
) >> D3DSP_REGTYPE_SHIFT
;
399 reg
= param
& D3DSP_REGNUM_MASK
;
401 if (D3DSPR_TEXTURE
== regtype
) { /* vs: D3DSPR_ADDR */
404 reg_maps
->texcoord
[reg
] = 1;
406 reg_maps
->address
[reg
] = 1;
409 else if (D3DSPR_TEMP
== regtype
)
410 reg_maps
->temporary
[reg
] = 1;
412 else if (D3DSPR_INPUT
== regtype
&& !pshader
)
413 reg_maps
->attributes
[reg
] = 1;
415 else if (D3DSPR_LOOP
== regtype
)
422 static void shader_dump_decl_usage(
426 DWORD regtype
= shader_get_regtype(param
);
429 if (regtype
== D3DSPR_SAMPLER
) {
430 DWORD ttype
= decl
& D3DSP_TEXTURETYPE_MASK
;
433 case D3DSTT_2D
: TRACE("2d"); break;
434 case D3DSTT_CUBE
: TRACE("cube"); break;
435 case D3DSTT_VOLUME
: TRACE("volume"); break;
436 default: TRACE("unknown_ttype(%08lx)", ttype
);
441 DWORD usage
= decl
& D3DSP_DCL_USAGE_MASK
;
442 DWORD idx
= (decl
& D3DSP_DCL_USAGEINDEX_MASK
) >> D3DSP_DCL_USAGEINDEX_SHIFT
;
445 case D3DDECLUSAGE_POSITION
:
446 TRACE("%s%ld", "position", idx
);
448 case D3DDECLUSAGE_BLENDINDICES
:
449 TRACE("%s", "blend");
451 case D3DDECLUSAGE_BLENDWEIGHT
:
452 TRACE("%s", "weight");
454 case D3DDECLUSAGE_NORMAL
:
455 TRACE("%s%ld", "normal", idx
);
457 case D3DDECLUSAGE_PSIZE
:
458 TRACE("%s", "psize");
460 case D3DDECLUSAGE_COLOR
:
462 TRACE("%s", "color");
464 TRACE("%s%ld", "specular", (idx
- 1));
467 case D3DDECLUSAGE_TEXCOORD
:
468 TRACE("%s%ld", "texture", idx
);
470 case D3DDECLUSAGE_TANGENT
:
471 TRACE("%s", "tangent");
473 case D3DDECLUSAGE_BINORMAL
:
474 TRACE("%s", "binormal");
476 case D3DDECLUSAGE_TESSFACTOR
:
477 TRACE("%s", "tessfactor");
479 case D3DDECLUSAGE_POSITIONT
:
480 TRACE("%s%ld", "positionT", idx
);
482 case D3DDECLUSAGE_FOG
:
485 case D3DDECLUSAGE_DEPTH
:
486 TRACE("%s", "depth");
488 case D3DDECLUSAGE_SAMPLE
:
489 TRACE("%s", "sample");
492 FIXME("unknown_semantics(%08lx)", usage
);
497 static void shader_dump_arr_entry(
498 IWineD3DBaseShader
*iface
,
500 const DWORD addr_token
,
505 ((param
& D3DSHADER_ADDRESSMODE_MASK
) == D3DSHADER_ADDRMODE_RELATIVE
);
510 shader_dump_param(iface
, addr_token
, 0, input
);
520 void shader_dump_param(
521 IWineD3DBaseShader
*iface
,
523 const DWORD addr_token
,
526 IWineD3DBaseShaderImpl
* This
= (IWineD3DBaseShaderImpl
*) iface
;
527 static const char* rastout_reg_names
[] = { "oPos", "oFog", "oPts" };
528 char swizzle_reg_chars
[4];
530 DWORD reg
= param
& D3DSP_REGNUM_MASK
;
531 DWORD regtype
= shader_get_regtype(param
);
533 /* There are some minor differences between pixel and vertex shaders */
534 char pshader
= shader_is_pshader_version(This
->baseShader
.hex_version
);
536 /* For one, we'd prefer color components to be shown for pshaders.
537 * FIXME: use the swizzle function for this */
539 swizzle_reg_chars
[0] = pshader
? 'r': 'x';
540 swizzle_reg_chars
[1] = pshader
? 'g': 'y';
541 swizzle_reg_chars
[2] = pshader
? 'b': 'z';
542 swizzle_reg_chars
[3] = pshader
? 'a': 'w';
545 if ( ((param
& D3DSP_SRCMOD_MASK
) == D3DSPSM_NEG
) ||
546 ((param
& D3DSP_SRCMOD_MASK
) == D3DSPSM_BIASNEG
) ||
547 ((param
& D3DSP_SRCMOD_MASK
) == D3DSPSM_SIGNNEG
) ||
548 ((param
& D3DSP_SRCMOD_MASK
) == D3DSPSM_X2NEG
) )
550 else if ((param
& D3DSP_SRCMOD_MASK
) == D3DSPSM_COMP
)
552 else if ((param
& D3DSP_SRCMOD_MASK
) == D3DSPSM_NOT
)
562 shader_dump_arr_entry(iface
, param
, addr_token
, reg
, input
);
569 shader_dump_arr_entry(iface
, param
, addr_token
, shader_get_float_offset(param
), input
);
571 case D3DSPR_TEXTURE
: /* vs: case D3DSPR_ADDR */
572 TRACE("%c%lu", (pshader
? 't':'a'), reg
);
575 TRACE("%s", rastout_reg_names
[reg
]);
577 case D3DSPR_COLOROUT
:
580 case D3DSPR_DEPTHOUT
:
586 case D3DSPR_TEXCRDOUT
:
588 /* Vertex shaders >= 3.0 use general purpose output registers
589 * (D3DSPR_OUTPUT), which can include an address token */
591 if (D3DSHADER_VERSION_MAJOR(This
->baseShader
.hex_version
) >= 3) {
593 shader_dump_arr_entry(iface
, param
, addr_token
, reg
, input
);
598 case D3DSPR_CONSTINT
:
600 shader_dump_arr_entry(iface
, param
, addr_token
, reg
, input
);
602 case D3DSPR_CONSTBOOL
:
604 shader_dump_arr_entry(iface
, param
, addr_token
, reg
, input
);
615 case D3DSPR_PREDICATE
:
619 TRACE("unhandled_rtype(%#lx)", regtype
);
624 /* operand output (for modifiers and shift, see dump_ins_modifiers) */
626 if ((param
& D3DSP_WRITEMASK_ALL
) != D3DSP_WRITEMASK_ALL
) {
628 if (param
& D3DSP_WRITEMASK_0
) TRACE("%c", swizzle_reg_chars
[0]);
629 if (param
& D3DSP_WRITEMASK_1
) TRACE("%c", swizzle_reg_chars
[1]);
630 if (param
& D3DSP_WRITEMASK_2
) TRACE("%c", swizzle_reg_chars
[2]);
631 if (param
& D3DSP_WRITEMASK_3
) TRACE("%c", swizzle_reg_chars
[3]);
636 DWORD swizzle
= (param
& D3DSP_SWIZZLE_MASK
) >> D3DSP_SWIZZLE_SHIFT
;
637 DWORD swizzle_r
= swizzle
& 0x03;
638 DWORD swizzle_g
= (swizzle
>> 2) & 0x03;
639 DWORD swizzle_b
= (swizzle
>> 4) & 0x03;
640 DWORD swizzle_a
= (swizzle
>> 6) & 0x03;
642 if (0 != (param
& D3DSP_SRCMOD_MASK
)) {
643 DWORD mask
= param
& D3DSP_SRCMOD_MASK
;
645 case D3DSPSM_NONE
: break;
646 case D3DSPSM_NEG
: break;
647 case D3DSPSM_NOT
: break;
648 case D3DSPSM_BIAS
: TRACE("_bias"); break;
649 case D3DSPSM_BIASNEG
: TRACE("_bias"); break;
650 case D3DSPSM_SIGN
: TRACE("_bx2"); break;
651 case D3DSPSM_SIGNNEG
: TRACE("_bx2"); break;
652 case D3DSPSM_COMP
: break;
653 case D3DSPSM_X2
: TRACE("_x2"); break;
654 case D3DSPSM_X2NEG
: TRACE("_x2"); break;
655 case D3DSPSM_DZ
: TRACE("_dz"); break;
656 case D3DSPSM_DW
: TRACE("_dw"); break;
658 TRACE("_unknown_modifier(%#lx)", mask
>> D3DSP_SRCMOD_SHIFT
);
663 * swizzle bits fields:
666 if ((D3DVS_NOSWIZZLE
>> D3DVS_SWIZZLE_SHIFT
) != swizzle
) { /* ! D3DVS_NOSWIZZLE == 0xE4 << D3DVS_SWIZZLE_SHIFT */
667 if (swizzle_r
== swizzle_g
&&
668 swizzle_r
== swizzle_b
&&
669 swizzle_r
== swizzle_a
) {
670 TRACE(".%c", swizzle_reg_chars
[swizzle_r
]);
673 swizzle_reg_chars
[swizzle_r
],
674 swizzle_reg_chars
[swizzle_g
],
675 swizzle_reg_chars
[swizzle_b
],
676 swizzle_reg_chars
[swizzle_a
]);
682 /* Generate the variable & register declarations for the ARB_vertex_program output target */
683 void shader_generate_arb_declarations(
684 IWineD3DBaseShader
*iface
,
685 shader_reg_maps
* reg_maps
,
686 SHADER_BUFFER
* buffer
) {
688 IWineD3DBaseShaderImpl
* This
= (IWineD3DBaseShaderImpl
*) iface
;
691 for(i
= 0; i
< This
->baseShader
.limits
.temporary
; i
++) {
692 if (reg_maps
->temporary
[i
])
693 shader_addline(buffer
, "TEMP R%lu;\n", i
);
696 for (i
= 0; i
< This
->baseShader
.limits
.address
; i
++) {
697 if (reg_maps
->address
[i
])
698 shader_addline(buffer
, "ADDRESS A%ld;\n", i
);
701 for(i
= 0; i
< This
->baseShader
.limits
.texcoord
; i
++) {
702 if (reg_maps
->texcoord
[i
])
703 shader_addline(buffer
,"TEMP T%lu;\n", i
);
706 /* Texture coordinate registers must be pre-loaded */
707 for (i
= 0; i
< This
->baseShader
.limits
.texcoord
; i
++) {
708 if (reg_maps
->texcoord
[i
])
709 shader_addline(buffer
, "MOV T%lu, fragment.texcoord[%lu];\n", i
, i
);
712 /* Need to PARAM the environment parameters (constants) so we can use relative addressing */
713 shader_addline(buffer
, "PARAM C[%d] = { program.env[0..%d] };\n",
714 This
->baseShader
.limits
.constant_float
,
715 This
->baseShader
.limits
.constant_float
- 1);
718 /** Generate the variable & register declarations for the GLSL output target */
719 void shader_generate_glsl_declarations(
720 IWineD3DBaseShader
*iface
,
721 shader_reg_maps
* reg_maps
,
722 SHADER_BUFFER
* buffer
) {
724 IWineD3DBaseShaderImpl
* This
= (IWineD3DBaseShaderImpl
*) iface
;
727 /* There are some minor differences between pixel and vertex shaders */
728 char pshader
= shader_is_pshader_version(This
->baseShader
.hex_version
);
730 /* Declare the constants (aka uniforms) */
732 shader_addline(buffer
, "uniform vec4 PC[%u];\n", This
->baseShader
.limits
.constant_float
);
734 shader_addline(buffer
, "uniform vec4 VC[%u];\n", This
->baseShader
.limits
.constant_float
);
736 /* Declare texture samplers */
737 for (i
= 0; i
< This
->baseShader
.limits
.sampler
; i
++) {
738 if (reg_maps
->samplers
[i
]) {
740 const char* prefix
= pshader
? "psampler": "vsampler";
742 DWORD stype
= reg_maps
->samplers
[i
] & D3DSP_TEXTURETYPE_MASK
;
746 shader_addline(buffer
, "uniform sampler2D %s%lu;\n", prefix
, i
);
749 shader_addline(buffer
, "uniform samplerCube %s%lu;\n", prefix
, i
);
752 shader_addline(buffer
, "uniform sampler3D %s%lu;\n", prefix
, i
);
755 shader_addline(buffer
, "uniform unsupported_sampler %s%lu;\n", prefix
, i
);
756 FIXME("Unrecognized sampler type: %#lx\n", stype
);
762 /* Declare address variables */
763 for (i
= 0; i
< This
->baseShader
.limits
.address
; i
++) {
764 if (reg_maps
->address
[i
])
765 shader_addline(buffer
, "ivec4 A%ld;\n", i
);
768 /* Declare texture coordinate temporaries and initialize them */
769 for (i
= 0; i
< This
->baseShader
.limits
.texcoord
; i
++) {
770 if (reg_maps
->texcoord
[i
])
771 shader_addline(buffer
, "vec4 T%lu = gl_TexCoord[%lu];\n", i
, i
);
774 /* Declare input register temporaries */
775 for (i
=0; i
< This
->baseShader
.limits
.packed_input
; i
++) {
776 if (reg_maps
->packed_input
[i
])
777 shader_addline(buffer
, "vec4 IN%lu;\n", i
);
780 /* Declare output register temporaries */
781 for (i
= 0; i
< This
->baseShader
.limits
.packed_output
; i
++) {
782 if (reg_maps
->packed_output
[i
])
783 shader_addline(buffer
, "vec4 OUT%lu;\n", i
);
786 /* Declare temporary variables */
787 for(i
= 0; i
< This
->baseShader
.limits
.temporary
; i
++) {
788 if (reg_maps
->temporary
[i
])
789 shader_addline(buffer
, "vec4 R%lu;\n", i
);
792 /* Declare attributes */
793 for (i
= 0; i
< This
->baseShader
.limits
.attributes
; i
++) {
794 if (reg_maps
->attributes
[i
])
795 shader_addline(buffer
, "attribute vec4 attrib%i;\n", i
);
798 /* Declare loop register aL */
800 shader_addline(buffer
, "int aL;\n");
802 /* Temporary variables for matrix operations */
803 shader_addline(buffer
, "vec4 tmp0;\n");
804 shader_addline(buffer
, "vec4 tmp1;\n");
806 /* Start the main program */
807 shader_addline(buffer
, "void main() {\n");
810 /** Shared code in order to generate the bulk of the shader string.
811 Use the shader_header_fct & shader_footer_fct to add strings
812 that are specific to pixel or vertex functions
813 NOTE: A description of how to parse tokens can be found at:
814 http://msdn.microsoft.com/library/default.asp?url=/library/en-us/graphics/hh/graphics/usermodedisplaydriver_shader_cc8e4e05-f5c3-4ec0-8853-8ce07c1551b2.xml.asp */
815 void shader_generate_main(
816 IWineD3DBaseShader
*iface
,
817 SHADER_BUFFER
* buffer
,
818 shader_reg_maps
* reg_maps
,
819 CONST DWORD
* pFunction
) {
821 IWineD3DBaseShaderImpl
* This
= (IWineD3DBaseShaderImpl
*) iface
;
822 const DWORD
*pToken
= pFunction
;
823 const SHADER_OPCODE
*curOpcode
= NULL
;
824 SHADER_HANDLER hw_fct
= NULL
;
827 SHADER_OPCODE_ARG hw_arg
;
829 /* Initialize current parsing state */
830 hw_arg
.shader
= iface
;
831 hw_arg
.buffer
= buffer
;
832 hw_arg
.reg_maps
= reg_maps
;
833 This
->baseShader
.parse_state
.current_row
= 0;
835 /* Second pass, process opcodes */
836 if (NULL
!= pToken
) {
837 while (D3DPS_END() != *pToken
) {
839 /* Skip version token */
840 if (shader_is_version_token(*pToken
)) {
845 /* Skip comment tokens */
846 if (shader_is_comment(*pToken
)) {
847 DWORD comment_len
= (*pToken
& D3DSI_COMMENTSIZE_MASK
) >> D3DSI_COMMENTSIZE_SHIFT
;
849 TRACE("#%s\n", (char*)pToken
);
850 pToken
+= comment_len
;
855 opcode_token
= *pToken
++;
856 curOpcode
= shader_get_opcode(iface
, opcode_token
);
857 hw_fct
= (curOpcode
== NULL
)? NULL
:
858 (wined3d_settings
.shader_mode
== SHADER_GLSL
)?
859 curOpcode
->hw_glsl_fct
: curOpcode
->hw_fct
;
861 /* Unknown opcode and its parameters */
862 if (NULL
== curOpcode
) {
863 FIXME("Unrecognized opcode: token=%08lX\n", opcode_token
);
864 pToken
+= shader_skip_unrecognized(iface
, pToken
);
867 } else if (D3DSIO_DCL
== curOpcode
->opcode
||
868 D3DSIO_NOP
== curOpcode
->opcode
) {
870 pToken
+= shader_skip_opcode(This
, curOpcode
, opcode_token
);
872 /* If a generator function is set for current shader target, use it */
873 } else if (hw_fct
!= NULL
) {
875 hw_arg
.opcode
= curOpcode
;
877 /* Destination token */
878 if (curOpcode
->dst_token
) {
880 DWORD param
, addr_token
= 0;
881 pToken
+= shader_get_param(iface
, pToken
, ¶m
, &addr_token
);
883 hw_arg
.dst_addr
= addr_token
;
886 /* Predication token */
887 if (opcode_token
& D3DSHADER_INSTRUCTION_PREDICATED
)
888 hw_arg
.predicate
= *pToken
++;
890 /* Other source tokens */
891 for (i
= curOpcode
->dst_token
; i
< curOpcode
->num_params
; i
++) {
893 DWORD param
, addr_token
= 0;
895 /* DEF* instructions have constant src parameters, not registers */
896 if (curOpcode
->opcode
== D3DSIO_DEF
||
897 curOpcode
->opcode
== D3DSIO_DEFI
||
898 curOpcode
->opcode
== D3DSIO_DEFB
) {
902 pToken
+= shader_get_param(iface
, pToken
, ¶m
, &addr_token
);
904 hw_arg
.src
[i
-1] = param
;
905 hw_arg
.src_addr
[i
-1] = addr_token
;
908 /* Call appropriate function for output target */
911 /* Process instruction modifiers for GLSL apps ( _sat, etc. ) */
912 if (wined3d_settings
.shader_mode
== SHADER_GLSL
)
913 shader_glsl_add_instruction_modifiers(&hw_arg
);
915 /* Unhandled opcode */
918 FIXME("Can't handle opcode %s in hwShader\n", curOpcode
->name
);
919 pToken
+= shader_skip_opcode(This
, curOpcode
, opcode_token
);
922 /* TODO: What about result.depth? */
927 void shader_dump_ins_modifiers(const DWORD output
) {
929 DWORD shift
= (output
& D3DSP_DSTSHIFT_MASK
) >> D3DSP_DSTSHIFT_SHIFT
;
930 DWORD mmask
= output
& D3DSP_DSTMOD_MASK
;
934 case 13: TRACE("_d8"); break;
935 case 14: TRACE("_d4"); break;
936 case 15: TRACE("_d2"); break;
937 case 1: TRACE("_x2"); break;
938 case 2: TRACE("_x4"); break;
939 case 3: TRACE("_x8"); break;
940 default: TRACE("_unhandled_shift(%ld)", shift
); break;
943 if (mmask
& D3DSPDM_SATURATE
) TRACE("_sat");
944 if (mmask
& D3DSPDM_PARTIALPRECISION
) TRACE("_pp");
945 if (mmask
& D3DSPDM_MSAMPCENTROID
) TRACE("_centroid");
947 mmask
&= ~(D3DSPDM_SATURATE
| D3DSPDM_PARTIALPRECISION
| D3DSPDM_MSAMPCENTROID
);
949 FIXME("_unrecognized_modifier(%#lx)", mmask
>> D3DSP_DSTMOD_SHIFT
);
952 /** Process the D3DSIO_DEF opcode into an ARB string - creates a local vec4
953 * float constant, and stores it's usage on the regmaps. */
954 void shader_hw_def(SHADER_OPCODE_ARG
* arg
) {
956 DWORD reg
= arg
->dst
& D3DSP_REGNUM_MASK
;
958 shader_addline(arg
->buffer
,
959 "PARAM C%lu = { %f, %f, %f, %f };\n", reg
,
960 *((const float *)(arg
->src
+ 0)),
961 *((const float *)(arg
->src
+ 1)),
962 *((const float *)(arg
->src
+ 2)),
963 *((const float *)(arg
->src
+ 3)) );
965 arg
->reg_maps
->constantsF
[reg
] = 1;
968 /* First pass: trace shader, initialize length and version */
969 void shader_trace_init(
970 IWineD3DBaseShader
*iface
,
971 const DWORD
* pFunction
) {
973 IWineD3DBaseShaderImpl
*This
=(IWineD3DBaseShaderImpl
*)iface
;
975 const DWORD
* pToken
= pFunction
;
976 const SHADER_OPCODE
* curOpcode
= NULL
;
978 unsigned int len
= 0;
981 TRACE("(%p) : Parsing programme\n", This
);
983 if (NULL
!= pToken
) {
984 while (D3DVS_END() != *pToken
) {
985 if (shader_is_version_token(*pToken
)) { /** version */
986 This
->baseShader
.hex_version
= *pToken
;
987 TRACE("%s_%lu_%lu\n", shader_is_pshader_version(This
->baseShader
.hex_version
)? "ps": "vs",
988 D3DSHADER_VERSION_MAJOR(This
->baseShader
.hex_version
),
989 D3DSHADER_VERSION_MINOR(This
->baseShader
.hex_version
));
994 if (shader_is_comment(*pToken
)) { /** comment */
995 DWORD comment_len
= (*pToken
& D3DSI_COMMENTSIZE_MASK
) >> D3DSI_COMMENTSIZE_SHIFT
;
997 TRACE("//%s\n", (char*)pToken
);
998 pToken
+= comment_len
;
999 len
+= comment_len
+ 1;
1002 opcode_token
= *pToken
++;
1003 curOpcode
= shader_get_opcode(iface
, opcode_token
);
1006 if (NULL
== curOpcode
) {
1008 FIXME("Unrecognized opcode: token=%08lX\n", opcode_token
);
1009 tokens_read
= shader_skip_unrecognized(iface
, pToken
);
1010 pToken
+= tokens_read
;
1014 if (curOpcode
->opcode
== D3DSIO_DCL
) {
1016 DWORD usage
= *pToken
;
1017 DWORD param
= *(pToken
+ 1);
1019 shader_dump_decl_usage(usage
, param
);
1020 shader_dump_ins_modifiers(param
);
1022 shader_dump_param(iface
, param
, 0, 0);
1026 } else if (curOpcode
->opcode
== D3DSIO_DEF
) {
1028 unsigned int offset
= shader_get_float_offset(*pToken
);
1030 TRACE("def c%u = %f, %f, %f, %f", offset
,
1031 *(float *)(pToken
+ 1),
1032 *(float *)(pToken
+ 2),
1033 *(float *)(pToken
+ 3),
1034 *(float *)(pToken
+ 4));
1038 } else if (curOpcode
->opcode
== D3DSIO_DEFI
) {
1040 TRACE("defi i%lu = %ld, %ld, %ld, %ld", *pToken
& D3DSP_REGNUM_MASK
,
1041 (long) *(pToken
+ 1),
1042 (long) *(pToken
+ 2),
1043 (long) *(pToken
+ 3),
1044 (long) *(pToken
+ 4));
1049 } else if (curOpcode
->opcode
== D3DSIO_DEFB
) {
1051 TRACE("defb b%lu = %s", *pToken
& D3DSP_REGNUM_MASK
,
1052 *(pToken
+ 1)? "true": "false");
1059 DWORD param
, addr_token
;
1062 /* Print out predication source token first - it follows
1063 * the destination token. */
1064 if (opcode_token
& D3DSHADER_INSTRUCTION_PREDICATED
) {
1066 shader_dump_param(iface
, *(pToken
+ 2), 0, 1);
1070 TRACE("%s", curOpcode
->name
);
1072 /* Destination token */
1073 if (curOpcode
->dst_token
) {
1075 /* Destination token */
1076 tokens_read
= shader_get_param(iface
, pToken
, ¶m
, &addr_token
);
1077 pToken
+= tokens_read
;
1080 shader_dump_ins_modifiers(param
);
1082 shader_dump_param(iface
, param
, addr_token
, 0);
1085 /* Predication token - already printed out, just skip it */
1086 if (opcode_token
& D3DSHADER_INSTRUCTION_PREDICATED
) {
1091 /* Other source tokens */
1092 for (i
= curOpcode
->dst_token
; i
< curOpcode
->num_params
; ++i
) {
1094 tokens_read
= shader_get_param(iface
, pToken
, ¶m
, &addr_token
);
1095 pToken
+= tokens_read
;
1098 TRACE((i
== 0)? " " : ", ");
1099 shader_dump_param(iface
, param
, addr_token
, 1);
1105 This
->baseShader
.functionLength
= (len
+ 1) * sizeof(DWORD
);
1107 This
->baseShader
.functionLength
= 1; /* no Function defined use fixed function vertex processing */
1111 /* TODO: Move other shared code here */