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 static inline 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;
60 if (buffer
->newline
) {
61 TRACE("GL HW (%u, %u) : %s", buffer
->lineNo
+ 1, buffer
->bsize
, base
);
62 buffer
->newline
= FALSE
;
68 if (buffer
->buffer
[buffer
->bsize
-1] == '\n') {
70 buffer
->newline
= TRUE
;
75 const SHADER_OPCODE
* shader_get_opcode(
76 IWineD3DBaseShader
*iface
, const DWORD code
) {
78 IWineD3DBaseShaderImpl
*This
= (IWineD3DBaseShaderImpl
*) iface
;
81 DWORD hex_version
= This
->baseShader
.hex_version
;
82 const SHADER_OPCODE
*shader_ins
= This
->baseShader
.shader_ins
;
84 /** TODO: use dichotomic search */
85 while (NULL
!= shader_ins
[i
].name
) {
86 if (((code
& WINED3DSI_OPCODE_MASK
) == shader_ins
[i
].opcode
) &&
87 (((hex_version
>= shader_ins
[i
].min_version
) && (hex_version
<= shader_ins
[i
].max_version
)) ||
88 ((shader_ins
[i
].min_version
== 0) && (shader_ins
[i
].max_version
== 0)))) {
89 return &shader_ins
[i
];
93 FIXME("Unsupported opcode %#x(%d) masked %#x, shader version %#x\n",
94 code
, code
, code
& WINED3DSI_OPCODE_MASK
, hex_version
);
98 /* Read a parameter opcode from the input stream,
99 * and possibly a relative addressing token.
100 * Return the number of tokens read */
101 int shader_get_param(
102 IWineD3DBaseShader
* iface
,
107 /* PS >= 3.0 have relative addressing (with token)
108 * VS >= 2.0 have relative addressing (with token)
109 * VS >= 1.0 < 2.0 have relative addressing (without token)
110 * The version check below should work in general */
112 IWineD3DBaseShaderImpl
* This
= (IWineD3DBaseShaderImpl
*) iface
;
113 char rel_token
= WINED3DSHADER_VERSION_MAJOR(This
->baseShader
.hex_version
) >= 2 &&
114 ((*pToken
& WINED3DSHADER_ADDRESSMODE_MASK
) == WINED3DSHADER_ADDRMODE_RELATIVE
);
117 *addr_token
= rel_token
? *(pToken
+ 1): 0;
118 return rel_token
? 2:1;
121 /* Return the number of parameters to skip for an opcode */
122 static inline int shader_skip_opcode(
123 IWineD3DBaseShaderImpl
* This
,
124 const SHADER_OPCODE
* curOpcode
,
125 DWORD opcode_token
) {
127 /* Shaders >= 2.0 may contain address tokens, but fortunately they
128 * have a useful legnth mask - use it here. Shaders 1.0 contain no such tokens */
130 return (WINED3DSHADER_VERSION_MAJOR(This
->baseShader
.hex_version
) >= 2)?
131 ((opcode_token
& WINED3DSI_INSTLENGTH_MASK
) >> WINED3DSI_INSTLENGTH_SHIFT
):
132 curOpcode
->num_params
;
135 /* Read the parameters of an unrecognized opcode from the input stream
136 * Return the number of tokens read.
138 * Note: This function assumes source or destination token format.
139 * It will not work with specially-formatted tokens like DEF or DCL,
140 * but hopefully those would be recognized */
142 int shader_skip_unrecognized(
143 IWineD3DBaseShader
* iface
,
144 const DWORD
* pToken
) {
149 /* TODO: Think of a good name for 0x80000000 and replace it with a constant */
150 while (*pToken
& 0x80000000) {
152 DWORD param
, addr_token
;
153 tokens_read
+= shader_get_param(iface
, pToken
, ¶m
, &addr_token
);
154 pToken
+= tokens_read
;
156 FIXME("Unrecognized opcode param: token=%08x "
157 "addr_token=%08x name=", param
, addr_token
);
158 shader_dump_param(iface
, param
, addr_token
, i
);
165 /* Convert floating point offset relative
166 * to a register file to an absolute offset for float constants */
168 unsigned int shader_get_float_offset(const DWORD reg
) {
170 unsigned int regnum
= reg
& WINED3DSP_REGNUM_MASK
;
171 int regtype
= shader_get_regtype(reg
);
174 case WINED3DSPR_CONST
: return regnum
;
175 case WINED3DSPR_CONST2
: return 2048 + regnum
;
176 case WINED3DSPR_CONST3
: return 4096 + regnum
;
177 case WINED3DSPR_CONST4
: return 6144 + regnum
;
179 FIXME("Unsupported register type: %d\n", regtype
);
184 /* Note that this does not count the loop register
185 * as an address register. */
187 HRESULT
shader_get_registers_used(
188 IWineD3DBaseShader
*iface
,
189 shader_reg_maps
* reg_maps
,
190 semantic
* semantics_in
,
191 semantic
* semantics_out
,
193 IWineD3DStateBlockImpl
*stateBlock
) {
195 IWineD3DBaseShaderImpl
* This
= (IWineD3DBaseShaderImpl
*) iface
;
196 unsigned int cur_loop_depth
= 0, max_loop_depth
= 0;
198 /* There are some minor differences between pixel and vertex shaders */
199 char pshader
= shader_is_pshader_version(This
->baseShader
.hex_version
);
201 reg_maps
->bumpmat
= -1;
202 reg_maps
->luminanceparams
= -1;
207 while (WINED3DVS_END() != *pToken
) {
208 CONST SHADER_OPCODE
* curOpcode
;
212 if (shader_is_version_token(*pToken
)) {
217 } else if (shader_is_comment(*pToken
)) {
218 DWORD comment_len
= (*pToken
& WINED3DSI_COMMENTSIZE_MASK
) >> WINED3DSI_COMMENTSIZE_SHIFT
;
220 pToken
+= comment_len
;
225 opcode_token
= *pToken
++;
226 curOpcode
= shader_get_opcode(iface
, opcode_token
);
228 /* Unhandled opcode, and its parameters */
229 if (NULL
== curOpcode
) {
230 while (*pToken
& 0x80000000)
233 /* Handle declarations */
234 } else if (WINED3DSIO_DCL
== curOpcode
->opcode
) {
236 DWORD usage
= *pToken
++;
237 DWORD param
= *pToken
++;
238 DWORD regtype
= shader_get_regtype(param
);
239 unsigned int regnum
= param
& WINED3DSP_REGNUM_MASK
;
241 /* Vshader: mark attributes used
242 Pshader: mark 3.0 input registers used, save token */
243 if (WINED3DSPR_INPUT
== regtype
) {
246 reg_maps
->attributes
[regnum
] = 1;
248 reg_maps
->packed_input
[regnum
] = 1;
250 semantics_in
[regnum
].usage
= usage
;
251 semantics_in
[regnum
].reg
= param
;
253 /* Vshader: mark 3.0 output registers used, save token */
254 } else if (WINED3DSPR_OUTPUT
== regtype
) {
255 reg_maps
->packed_output
[regnum
] = 1;
256 semantics_out
[regnum
].usage
= usage
;
257 semantics_out
[regnum
].reg
= param
;
258 if (usage
& (WINED3DDECLUSAGE_FOG
<< WINED3DSP_DCL_USAGE_SHIFT
))
261 /* Save sampler usage token */
262 } else if (WINED3DSPR_SAMPLER
== regtype
)
263 reg_maps
->samplers
[regnum
] = usage
;
265 } else if (WINED3DSIO_DEF
== curOpcode
->opcode
) {
267 local_constant
* lconst
= HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant
));
268 if (!lconst
) return E_OUTOFMEMORY
;
269 lconst
->idx
= *pToken
& WINED3DSP_REGNUM_MASK
;
270 memcpy(&lconst
->value
, pToken
+ 1, 4 * sizeof(DWORD
));
272 /* In pixel shader 1.X shaders, the constants are clamped between [-1;1] */
273 if(WINED3DSHADER_VERSION_MAJOR(This
->baseShader
.hex_version
) == 1 && pshader
) {
274 float *value
= (float *) lconst
->value
;
275 if(value
[0] < -1.0) value
[0] = -1.0;
276 else if(value
[0] > 1.0) value
[0] = 1.0;
277 if(value
[1] < -1.0) value
[1] = -1.0;
278 else if(value
[1] > 1.0) value
[1] = 1.0;
279 if(value
[2] < -1.0) value
[2] = -1.0;
280 else if(value
[2] > 1.0) value
[2] = 1.0;
281 if(value
[3] < -1.0) value
[3] = -1.0;
282 else if(value
[3] > 1.0) value
[3] = 1.0;
285 list_add_head(&This
->baseShader
.constantsF
, &lconst
->entry
);
286 pToken
+= curOpcode
->num_params
;
288 } else if (WINED3DSIO_DEFI
== curOpcode
->opcode
) {
290 local_constant
* lconst
= HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant
));
291 if (!lconst
) return E_OUTOFMEMORY
;
292 lconst
->idx
= *pToken
& WINED3DSP_REGNUM_MASK
;
293 memcpy(&lconst
->value
, pToken
+ 1, 4 * sizeof(DWORD
));
294 list_add_head(&This
->baseShader
.constantsI
, &lconst
->entry
);
295 pToken
+= curOpcode
->num_params
;
297 } else if (WINED3DSIO_DEFB
== curOpcode
->opcode
) {
299 local_constant
* lconst
= HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant
));
300 if (!lconst
) return E_OUTOFMEMORY
;
301 lconst
->idx
= *pToken
& WINED3DSP_REGNUM_MASK
;
302 memcpy(&lconst
->value
, pToken
+ 1, 1 * sizeof(DWORD
));
303 list_add_head(&This
->baseShader
.constantsB
, &lconst
->entry
);
304 pToken
+= curOpcode
->num_params
;
306 /* If there's a loop in the shader */
307 } else if (WINED3DSIO_LOOP
== curOpcode
->opcode
||
308 WINED3DSIO_REP
== curOpcode
->opcode
) {
310 if(cur_loop_depth
> max_loop_depth
)
311 max_loop_depth
= cur_loop_depth
;
312 pToken
+= curOpcode
->num_params
;
314 } else if (WINED3DSIO_ENDLOOP
== curOpcode
->opcode
||
315 WINED3DSIO_ENDREP
== curOpcode
->opcode
) {
318 /* For subroutine prototypes */
319 } else if (WINED3DSIO_LABEL
== curOpcode
->opcode
) {
321 DWORD snum
= *pToken
& WINED3DSP_REGNUM_MASK
;
322 reg_maps
->labels
[snum
] = 1;
323 pToken
+= curOpcode
->num_params
;
325 /* Set texture, address, temporary registers */
329 /* Declare 1.X samplers implicitly, based on the destination reg. number */
330 if (WINED3DSHADER_VERSION_MAJOR(This
->baseShader
.hex_version
) == 1 &&
331 (WINED3DSIO_TEX
== curOpcode
->opcode
||
332 WINED3DSIO_TEXBEM
== curOpcode
->opcode
||
333 WINED3DSIO_TEXBEML
== curOpcode
->opcode
||
334 WINED3DSIO_TEXDP3TEX
== curOpcode
->opcode
||
335 WINED3DSIO_TEXM3x2TEX
== curOpcode
->opcode
||
336 WINED3DSIO_TEXM3x3SPEC
== curOpcode
->opcode
||
337 WINED3DSIO_TEXM3x3TEX
== curOpcode
->opcode
||
338 WINED3DSIO_TEXM3x3VSPEC
== curOpcode
->opcode
||
339 WINED3DSIO_TEXREG2AR
== curOpcode
->opcode
||
340 WINED3DSIO_TEXREG2GB
== curOpcode
->opcode
||
341 WINED3DSIO_TEXREG2RGB
== curOpcode
->opcode
)) {
343 /* Fake sampler usage, only set reserved bit and ttype */
344 DWORD sampler_code
= *pToken
& WINED3DSP_REGNUM_MASK
;
346 if(!stateBlock
->textures
[sampler_code
]) {
347 ERR("No texture bound to sampler %d\n", sampler_code
);
348 reg_maps
->samplers
[sampler_code
] = (0x1 << 31) | WINED3DSTT_2D
;
350 int texType
= IWineD3DBaseTexture_GetTextureDimensions(stateBlock
->textures
[sampler_code
]);
353 reg_maps
->samplers
[sampler_code
] = (0x1 << 31) | WINED3DSTT_2D
;
357 reg_maps
->samplers
[sampler_code
] = (0x1 << 31) | WINED3DSTT_VOLUME
;
360 case GL_TEXTURE_CUBE_MAP_ARB
:
361 reg_maps
->samplers
[sampler_code
] = (0x1 << 31) | WINED3DSTT_CUBE
;
365 ERR("Unexpected gl texture type found: %d\n", texType
);
366 reg_maps
->samplers
[sampler_code
] = (0x1 << 31) | WINED3DSTT_2D
;
370 /* texbem is only valid with < 1.4 pixel shaders */
371 if(WINED3DSIO_TEXBEM
== curOpcode
->opcode
||
372 WINED3DSIO_TEXBEML
== curOpcode
->opcode
) {
373 if(reg_maps
->bumpmat
!= -1 && reg_maps
->bumpmat
!= sampler_code
) {
374 FIXME("Pixel shader uses texbem instruction on more than 1 sampler\n");
376 reg_maps
->bumpmat
= sampler_code
;
377 if(WINED3DSIO_TEXBEML
== curOpcode
->opcode
) {
378 reg_maps
->luminanceparams
= sampler_code
;
383 if(WINED3DSIO_NRM
== curOpcode
->opcode
) {
384 reg_maps
->usesnrm
= 1;
385 } else if(WINED3DSIO_BEM
== curOpcode
->opcode
) {
386 DWORD regnum
= *pToken
& WINED3DSP_REGNUM_MASK
;
387 if(reg_maps
->bumpmat
!= -1 && reg_maps
->bumpmat
!= regnum
) {
388 FIXME("Pixel shader uses bem or texbem instruction on more than 1 sampler\n");
390 reg_maps
->bumpmat
= regnum
;
392 } else if(WINED3DSIO_DSY
== curOpcode
->opcode
) {
393 reg_maps
->usesdsy
= 1;
396 /* This will loop over all the registers and try to
397 * make a bitmask of the ones we're interested in.
399 * Relative addressing tokens are ignored, but that's
400 * okay, since we'll catch any address registers when
401 * they are initialized (required by spec) */
403 limit
= (opcode_token
& WINED3DSHADER_INSTRUCTION_PREDICATED
)?
404 curOpcode
->num_params
+ 1: curOpcode
->num_params
;
406 for (i
= 0; i
< limit
; ++i
) {
408 DWORD param
, addr_token
, reg
, regtype
;
409 pToken
+= shader_get_param(iface
, pToken
, ¶m
, &addr_token
);
411 regtype
= shader_get_regtype(param
);
412 reg
= param
& WINED3DSP_REGNUM_MASK
;
414 if (WINED3DSPR_TEXTURE
== regtype
) { /* vs: WINED3DSPR_ADDR */
417 reg_maps
->texcoord
[reg
] = 1;
419 reg_maps
->address
[reg
] = 1;
422 else if (WINED3DSPR_TEMP
== regtype
)
423 reg_maps
->temporary
[reg
] = 1;
425 else if (WINED3DSPR_INPUT
== regtype
) {
427 reg_maps
->attributes
[reg
] = 1;
429 if(param
& WINED3DSHADER_ADDRMODE_RELATIVE
) {
430 /* If relative addressing is used, we must assume that all registers
431 * are used. Even if it is a construct like v3[aL], we can't assume
432 * that v0, v1 and v2 aren't read because aL can be negative
435 for(i
= 0; i
< MAX_REG_INPUT
; i
++) {
436 ((IWineD3DPixelShaderImpl
*) This
)->input_reg_used
[i
] = TRUE
;
439 ((IWineD3DPixelShaderImpl
*) This
)->input_reg_used
[reg
] = TRUE
;
444 else if (WINED3DSPR_RASTOUT
== regtype
&& reg
== 1)
447 else if (WINED3DSPR_MISCTYPE
== regtype
&& reg
== 0 && pshader
)
450 else if(WINED3DSPR_CONST
== regtype
) {
451 if(param
& WINED3DSHADER_ADDRMODE_RELATIVE
) {
453 if(reg
<= ((IWineD3DVertexShaderImpl
*) This
)->min_rel_offset
) {
454 ((IWineD3DVertexShaderImpl
*) This
)->min_rel_offset
= reg
;
455 } else if(reg
>= ((IWineD3DVertexShaderImpl
*) This
)->max_rel_offset
) {
456 ((IWineD3DVertexShaderImpl
*) This
)->max_rel_offset
= reg
;
459 reg_maps
->usesrelconstF
= TRUE
;
465 reg_maps
->loop_depth
= max_loop_depth
;
470 static void shader_dump_decl_usage(
471 IWineD3DBaseShaderImpl
* This
,
475 DWORD regtype
= shader_get_regtype(param
);
479 if (regtype
== WINED3DSPR_SAMPLER
) {
480 DWORD ttype
= decl
& WINED3DSP_TEXTURETYPE_MASK
;
483 case WINED3DSTT_2D
: TRACE("_2d"); break;
484 case WINED3DSTT_CUBE
: TRACE("_cube"); break;
485 case WINED3DSTT_VOLUME
: TRACE("_volume"); break;
486 default: TRACE("_unknown_ttype(%08x)", ttype
);
491 DWORD usage
= decl
& WINED3DSP_DCL_USAGE_MASK
;
492 DWORD idx
= (decl
& WINED3DSP_DCL_USAGEINDEX_MASK
) >> WINED3DSP_DCL_USAGEINDEX_SHIFT
;
494 /* Pixel shaders 3.0 don't have usage semantics */
495 char pshader
= shader_is_pshader_version(This
->baseShader
.hex_version
);
496 if (pshader
&& This
->baseShader
.hex_version
< WINED3DPS_VERSION(3,0))
502 case WINED3DDECLUSAGE_POSITION
:
503 TRACE("position%d", idx
);
505 case WINED3DDECLUSAGE_BLENDINDICES
:
508 case WINED3DDECLUSAGE_BLENDWEIGHT
:
511 case WINED3DDECLUSAGE_NORMAL
:
512 TRACE("normal%d", idx
);
514 case WINED3DDECLUSAGE_PSIZE
:
517 case WINED3DDECLUSAGE_COLOR
:
521 TRACE("specular%d", (idx
- 1));
524 case WINED3DDECLUSAGE_TEXCOORD
:
525 TRACE("texture%d", idx
);
527 case WINED3DDECLUSAGE_TANGENT
:
530 case WINED3DDECLUSAGE_BINORMAL
:
533 case WINED3DDECLUSAGE_TESSFACTOR
:
536 case WINED3DDECLUSAGE_POSITIONT
:
537 TRACE("positionT%d", idx
);
539 case WINED3DDECLUSAGE_FOG
:
542 case WINED3DDECLUSAGE_DEPTH
:
545 case WINED3DDECLUSAGE_SAMPLE
:
549 FIXME("unknown_semantics(%08x)", usage
);
554 static void shader_dump_arr_entry(
555 IWineD3DBaseShader
*iface
,
557 const DWORD addr_token
,
562 ((param
& WINED3DSHADER_ADDRESSMODE_MASK
) == WINED3DSHADER_ADDRMODE_RELATIVE
);
567 shader_dump_param(iface
, addr_token
, 0, input
);
577 void shader_dump_param(
578 IWineD3DBaseShader
*iface
,
580 const DWORD addr_token
,
583 IWineD3DBaseShaderImpl
* This
= (IWineD3DBaseShaderImpl
*) iface
;
584 static const char * const rastout_reg_names
[] = { "oPos", "oFog", "oPts" };
585 static const char * const misctype_reg_names
[] = { "vPos", "vFace"};
586 char swizzle_reg_chars
[4];
588 DWORD reg
= param
& WINED3DSP_REGNUM_MASK
;
589 DWORD regtype
= shader_get_regtype(param
);
590 DWORD modifier
= param
& WINED3DSP_SRCMOD_MASK
;
592 /* There are some minor differences between pixel and vertex shaders */
593 char pshader
= shader_is_pshader_version(This
->baseShader
.hex_version
);
595 /* For one, we'd prefer color components to be shown for pshaders.
596 * FIXME: use the swizzle function for this */
598 swizzle_reg_chars
[0] = pshader
? 'r': 'x';
599 swizzle_reg_chars
[1] = pshader
? 'g': 'y';
600 swizzle_reg_chars
[2] = pshader
? 'b': 'z';
601 swizzle_reg_chars
[3] = pshader
? 'a': 'w';
604 if ( (modifier
== WINED3DSPSM_NEG
) ||
605 (modifier
== WINED3DSPSM_BIASNEG
) ||
606 (modifier
== WINED3DSPSM_SIGNNEG
) ||
607 (modifier
== WINED3DSPSM_X2NEG
) ||
608 (modifier
== WINED3DSPSM_ABSNEG
) )
610 else if (modifier
== WINED3DSPSM_COMP
)
612 else if (modifier
== WINED3DSPSM_NOT
)
615 if (modifier
== WINED3DSPSM_ABS
|| modifier
== WINED3DSPSM_ABSNEG
)
620 case WINED3DSPR_TEMP
:
623 case WINED3DSPR_INPUT
:
625 shader_dump_arr_entry(iface
, param
, addr_token
, reg
, input
);
627 case WINED3DSPR_CONST
:
628 case WINED3DSPR_CONST2
:
629 case WINED3DSPR_CONST3
:
630 case WINED3DSPR_CONST4
:
632 shader_dump_arr_entry(iface
, param
, addr_token
, shader_get_float_offset(param
), input
);
634 case WINED3DSPR_TEXTURE
: /* vs: case D3DSPR_ADDR */
635 TRACE("%c%u", (pshader
? 't':'a'), reg
);
637 case WINED3DSPR_RASTOUT
:
638 TRACE("%s", rastout_reg_names
[reg
]);
640 case WINED3DSPR_COLOROUT
:
643 case WINED3DSPR_DEPTHOUT
:
646 case WINED3DSPR_ATTROUT
:
649 case WINED3DSPR_TEXCRDOUT
:
651 /* Vertex shaders >= 3.0 use general purpose output registers
652 * (WINED3DSPR_OUTPUT), which can include an address token */
654 if (WINED3DSHADER_VERSION_MAJOR(This
->baseShader
.hex_version
) >= 3) {
656 shader_dump_arr_entry(iface
, param
, addr_token
, reg
, input
);
661 case WINED3DSPR_CONSTINT
:
663 shader_dump_arr_entry(iface
, param
, addr_token
, reg
, input
);
665 case WINED3DSPR_CONSTBOOL
:
667 shader_dump_arr_entry(iface
, param
, addr_token
, reg
, input
);
669 case WINED3DSPR_LABEL
:
672 case WINED3DSPR_LOOP
:
675 case WINED3DSPR_SAMPLER
:
678 case WINED3DSPR_MISCTYPE
:
680 FIXME("Unhandled misctype register %d\n", reg
);
682 TRACE("%s", misctype_reg_names
[reg
]);
685 case WINED3DSPR_PREDICATE
:
689 TRACE("unhandled_rtype(%#x)", regtype
);
694 /* operand output (for modifiers and shift, see dump_ins_modifiers) */
696 if ((param
& WINED3DSP_WRITEMASK_ALL
) != WINED3DSP_WRITEMASK_ALL
) {
698 if (param
& WINED3DSP_WRITEMASK_0
) TRACE("%c", swizzle_reg_chars
[0]);
699 if (param
& WINED3DSP_WRITEMASK_1
) TRACE("%c", swizzle_reg_chars
[1]);
700 if (param
& WINED3DSP_WRITEMASK_2
) TRACE("%c", swizzle_reg_chars
[2]);
701 if (param
& WINED3DSP_WRITEMASK_3
) TRACE("%c", swizzle_reg_chars
[3]);
706 DWORD swizzle
= (param
& WINED3DSP_SWIZZLE_MASK
) >> WINED3DSP_SWIZZLE_SHIFT
;
707 DWORD swizzle_r
= swizzle
& 0x03;
708 DWORD swizzle_g
= (swizzle
>> 2) & 0x03;
709 DWORD swizzle_b
= (swizzle
>> 4) & 0x03;
710 DWORD swizzle_a
= (swizzle
>> 6) & 0x03;
714 case WINED3DSPSM_NONE
: break;
715 case WINED3DSPSM_NEG
: break;
716 case WINED3DSPSM_NOT
: break;
717 case WINED3DSPSM_BIAS
: TRACE("_bias"); break;
718 case WINED3DSPSM_BIASNEG
: TRACE("_bias"); break;
719 case WINED3DSPSM_SIGN
: TRACE("_bx2"); break;
720 case WINED3DSPSM_SIGNNEG
: TRACE("_bx2"); break;
721 case WINED3DSPSM_COMP
: break;
722 case WINED3DSPSM_X2
: TRACE("_x2"); break;
723 case WINED3DSPSM_X2NEG
: TRACE("_x2"); break;
724 case WINED3DSPSM_DZ
: TRACE("_dz"); break;
725 case WINED3DSPSM_DW
: TRACE("_dw"); break;
726 case WINED3DSPSM_ABSNEG
: TRACE(")"); break;
727 case WINED3DSPSM_ABS
: TRACE(")"); break;
729 TRACE("_unknown_modifier(%#x)", modifier
>> WINED3DSP_SRCMOD_SHIFT
);
734 * swizzle bits fields:
737 if ((WINED3DVS_NOSWIZZLE
>> WINED3DVS_SWIZZLE_SHIFT
) != swizzle
) {
738 if (swizzle_r
== swizzle_g
&&
739 swizzle_r
== swizzle_b
&&
740 swizzle_r
== swizzle_a
) {
741 TRACE(".%c", swizzle_reg_chars
[swizzle_r
]);
744 swizzle_reg_chars
[swizzle_r
],
745 swizzle_reg_chars
[swizzle_g
],
746 swizzle_reg_chars
[swizzle_b
],
747 swizzle_reg_chars
[swizzle_a
]);
753 /** Shared code in order to generate the bulk of the shader string.
754 Use the shader_header_fct & shader_footer_fct to add strings
755 that are specific to pixel or vertex functions
756 NOTE: A description of how to parse tokens can be found at:
757 http://msdn.microsoft.com/library/default.asp?url=/library/en-us/graphics/hh/graphics/usermodedisplaydriver_shader_cc8e4e05-f5c3-4ec0-8853-8ce07c1551b2.xml.asp */
758 void shader_generate_main(
759 IWineD3DBaseShader
*iface
,
760 SHADER_BUFFER
* buffer
,
761 shader_reg_maps
* reg_maps
,
762 CONST DWORD
* pFunction
) {
764 IWineD3DBaseShaderImpl
* This
= (IWineD3DBaseShaderImpl
*) iface
;
765 IWineD3DDeviceImpl
*device
= (IWineD3DDeviceImpl
*) This
->baseShader
.device
; /* To access shader backend callbacks */
766 const DWORD
*pToken
= pFunction
;
767 const SHADER_OPCODE
*curOpcode
= NULL
;
768 SHADER_HANDLER hw_fct
= NULL
;
770 SHADER_OPCODE_ARG hw_arg
;
772 /* Initialize current parsing state */
773 hw_arg
.shader
= iface
;
774 hw_arg
.buffer
= buffer
;
775 hw_arg
.reg_maps
= reg_maps
;
776 This
->baseShader
.parse_state
.current_row
= 0;
778 /* Second pass, process opcodes */
779 if (NULL
!= pToken
) {
780 while (WINED3DPS_END() != *pToken
) {
782 /* Skip version token */
783 if (shader_is_version_token(*pToken
)) {
788 /* Skip comment tokens */
789 if (shader_is_comment(*pToken
)) {
790 DWORD comment_len
= (*pToken
& WINED3DSI_COMMENTSIZE_MASK
) >> WINED3DSI_COMMENTSIZE_SHIFT
;
792 TRACE("#%s\n", (const char*)pToken
);
793 pToken
+= comment_len
;
798 hw_arg
.opcode_token
= *pToken
++;
799 curOpcode
= shader_get_opcode(iface
, hw_arg
.opcode_token
);
802 if (curOpcode
== NULL
)
804 else if (This
->baseShader
.shader_mode
== SHADER_GLSL
)
805 hw_fct
= curOpcode
->hw_glsl_fct
;
806 else if (This
->baseShader
.shader_mode
== SHADER_ARB
)
807 hw_fct
= curOpcode
->hw_fct
;
809 /* Unknown opcode and its parameters */
810 if (NULL
== curOpcode
) {
811 FIXME("Unrecognized opcode: token=%08x\n", hw_arg
.opcode_token
);
812 pToken
+= shader_skip_unrecognized(iface
, pToken
);
815 } else if (WINED3DSIO_DCL
== curOpcode
->opcode
||
816 WINED3DSIO_NOP
== curOpcode
->opcode
||
817 WINED3DSIO_DEF
== curOpcode
->opcode
||
818 WINED3DSIO_DEFI
== curOpcode
->opcode
||
819 WINED3DSIO_DEFB
== curOpcode
->opcode
||
820 WINED3DSIO_PHASE
== curOpcode
->opcode
||
821 WINED3DSIO_RET
== curOpcode
->opcode
) {
823 pToken
+= shader_skip_opcode(This
, curOpcode
, hw_arg
.opcode_token
);
825 /* If a generator function is set for current shader target, use it */
826 } else if (hw_fct
!= NULL
) {
828 hw_arg
.opcode
= curOpcode
;
830 /* Destination token */
831 if (curOpcode
->dst_token
) {
833 DWORD param
, addr_token
= 0;
834 pToken
+= shader_get_param(iface
, pToken
, ¶m
, &addr_token
);
836 hw_arg
.dst_addr
= addr_token
;
839 /* Predication token */
840 if (hw_arg
.opcode_token
& WINED3DSHADER_INSTRUCTION_PREDICATED
)
841 hw_arg
.predicate
= *pToken
++;
843 /* Other source tokens */
844 for (i
= 0; i
< (curOpcode
->num_params
- curOpcode
->dst_token
); i
++) {
846 DWORD param
, addr_token
= 0;
847 pToken
+= shader_get_param(iface
, pToken
, ¶m
, &addr_token
);
848 hw_arg
.src
[i
] = param
;
849 hw_arg
.src_addr
[i
] = addr_token
;
852 /* Call appropriate function for output target */
855 /* Add color correction if needed */
856 device
->shader_backend
->shader_color_correction(&hw_arg
);
858 /* Process instruction modifiers for GLSL apps ( _sat, etc. ) */
859 if (This
->baseShader
.shader_mode
== SHADER_GLSL
)
860 shader_glsl_add_instruction_modifiers(&hw_arg
);
862 /* Unhandled opcode */
865 FIXME("Can't handle opcode %s in hwShader\n", curOpcode
->name
);
866 pToken
+= shader_skip_opcode(This
, curOpcode
, hw_arg
.opcode_token
);
869 /* TODO: What about result.depth? */
874 void shader_dump_ins_modifiers(const DWORD output
) {
876 DWORD shift
= (output
& WINED3DSP_DSTSHIFT_MASK
) >> WINED3DSP_DSTSHIFT_SHIFT
;
877 DWORD mmask
= output
& WINED3DSP_DSTMOD_MASK
;
881 case 13: TRACE("_d8"); break;
882 case 14: TRACE("_d4"); break;
883 case 15: TRACE("_d2"); break;
884 case 1: TRACE("_x2"); break;
885 case 2: TRACE("_x4"); break;
886 case 3: TRACE("_x8"); break;
887 default: TRACE("_unhandled_shift(%d)", shift
); break;
890 if (mmask
& WINED3DSPDM_SATURATE
) TRACE("_sat");
891 if (mmask
& WINED3DSPDM_PARTIALPRECISION
) TRACE("_pp");
892 if (mmask
& WINED3DSPDM_MSAMPCENTROID
) TRACE("_centroid");
894 mmask
&= ~(WINED3DSPDM_SATURATE
| WINED3DSPDM_PARTIALPRECISION
| WINED3DSPDM_MSAMPCENTROID
);
896 FIXME("_unrecognized_modifier(%#x)", mmask
>> WINED3DSP_DSTMOD_SHIFT
);
899 /* First pass: trace shader, initialize length and version */
900 void shader_trace_init(
901 IWineD3DBaseShader
*iface
,
902 const DWORD
* pFunction
) {
904 IWineD3DBaseShaderImpl
*This
=(IWineD3DBaseShaderImpl
*)iface
;
906 const DWORD
* pToken
= pFunction
;
907 const SHADER_OPCODE
* curOpcode
= NULL
;
909 unsigned int len
= 0;
912 TRACE("(%p) : Parsing programme\n", This
);
914 if (NULL
!= pToken
) {
915 while (WINED3DVS_END() != *pToken
) {
916 if (shader_is_version_token(*pToken
)) { /** version */
917 This
->baseShader
.hex_version
= *pToken
;
918 TRACE("%s_%u_%u\n", shader_is_pshader_version(This
->baseShader
.hex_version
)? "ps": "vs",
919 WINED3DSHADER_VERSION_MAJOR(This
->baseShader
.hex_version
),
920 WINED3DSHADER_VERSION_MINOR(This
->baseShader
.hex_version
));
925 if (shader_is_comment(*pToken
)) { /** comment */
926 DWORD comment_len
= (*pToken
& WINED3DSI_COMMENTSIZE_MASK
) >> WINED3DSI_COMMENTSIZE_SHIFT
;
928 TRACE("//%s\n", (const char*)pToken
);
929 pToken
+= comment_len
;
930 len
+= comment_len
+ 1;
933 opcode_token
= *pToken
++;
934 curOpcode
= shader_get_opcode(iface
, opcode_token
);
937 if (NULL
== curOpcode
) {
939 FIXME("Unrecognized opcode: token=%08x\n", opcode_token
);
940 tokens_read
= shader_skip_unrecognized(iface
, pToken
);
941 pToken
+= tokens_read
;
945 if (curOpcode
->opcode
== WINED3DSIO_DCL
) {
947 DWORD usage
= *pToken
;
948 DWORD param
= *(pToken
+ 1);
950 shader_dump_decl_usage(This
, usage
, param
);
951 shader_dump_ins_modifiers(param
);
953 shader_dump_param(iface
, param
, 0, 0);
957 } else if (curOpcode
->opcode
== WINED3DSIO_DEF
) {
959 unsigned int offset
= shader_get_float_offset(*pToken
);
961 TRACE("def c%u = %f, %f, %f, %f", offset
,
962 *(const float *)(pToken
+ 1),
963 *(const float *)(pToken
+ 2),
964 *(const float *)(pToken
+ 3),
965 *(const float *)(pToken
+ 4));
969 } else if (curOpcode
->opcode
== WINED3DSIO_DEFI
) {
971 TRACE("defi i%u = %d, %d, %d, %d", *pToken
& WINED3DSP_REGNUM_MASK
,
980 } else if (curOpcode
->opcode
== WINED3DSIO_DEFB
) {
982 TRACE("defb b%u = %s", *pToken
& WINED3DSP_REGNUM_MASK
,
983 *(pToken
+ 1)? "true": "false");
990 DWORD param
, addr_token
;
993 /* Print out predication source token first - it follows
994 * the destination token. */
995 if (opcode_token
& WINED3DSHADER_INSTRUCTION_PREDICATED
) {
997 shader_dump_param(iface
, *(pToken
+ 2), 0, 1);
1000 if (opcode_token
& WINED3DSI_COISSUE
) {
1001 /* PixWin marks instructions with the coissue flag with a '+' */
1005 TRACE("%s", curOpcode
->name
);
1007 if (curOpcode
->opcode
== WINED3DSIO_IFC
||
1008 curOpcode
->opcode
== WINED3DSIO_BREAKC
) {
1010 DWORD op
= (opcode_token
& INST_CONTROLS_MASK
) >> INST_CONTROLS_SHIFT
;
1012 case COMPARISON_GT
: TRACE("_gt"); break;
1013 case COMPARISON_EQ
: TRACE("_eq"); break;
1014 case COMPARISON_GE
: TRACE("_ge"); break;
1015 case COMPARISON_LT
: TRACE("_lt"); break;
1016 case COMPARISON_NE
: TRACE("_ne"); break;
1017 case COMPARISON_LE
: TRACE("_le"); break;
1021 } else if (curOpcode
->opcode
== WINED3DSIO_TEX
&&
1022 This
->baseShader
.hex_version
>= WINED3DPS_VERSION(2,0)) {
1023 if(opcode_token
& WINED3DSI_TEXLD_PROJECT
) TRACE("p");
1026 /* Destination token */
1027 if (curOpcode
->dst_token
) {
1029 /* Destination token */
1030 tokens_read
= shader_get_param(iface
, pToken
, ¶m
, &addr_token
);
1031 pToken
+= tokens_read
;
1034 shader_dump_ins_modifiers(param
);
1036 shader_dump_param(iface
, param
, addr_token
, 0);
1039 /* Predication token - already printed out, just skip it */
1040 if (opcode_token
& WINED3DSHADER_INSTRUCTION_PREDICATED
) {
1045 /* Other source tokens */
1046 for (i
= curOpcode
->dst_token
; i
< curOpcode
->num_params
; ++i
) {
1048 tokens_read
= shader_get_param(iface
, pToken
, ¶m
, &addr_token
);
1049 pToken
+= tokens_read
;
1052 TRACE((i
== 0)? " " : ", ");
1053 shader_dump_param(iface
, param
, addr_token
, 1);
1059 This
->baseShader
.functionLength
= (len
+ 1) * sizeof(DWORD
);
1061 This
->baseShader
.functionLength
= 1; /* no Function defined use fixed function vertex processing */
1065 static void shader_delete_constant_list(
1066 struct list
* clist
) {
1069 struct local_constant
* constant
;
1071 ptr
= list_head(clist
);
1073 constant
= LIST_ENTRY(ptr
, struct local_constant
, entry
);
1074 ptr
= list_next(clist
, ptr
);
1075 HeapFree(GetProcessHeap(), 0, constant
);
1079 static void shader_none_select(IWineD3DDevice
*iface
, BOOL usePS
, BOOL useVS
) {}
1080 static void shader_none_select_depth_blt(IWineD3DDevice
*iface
) {}
1081 static void shader_none_load_constants(IWineD3DDevice
*iface
, char usePS
, char useVS
) {}
1082 static void shader_none_cleanup(IWineD3DDevice
*iface
) {}
1083 static void shader_none_color_correction(SHADER_OPCODE_ARG
* arg
) {}
1084 static void shader_none_destroy(IWineD3DBaseShader
*iface
) {}
1086 const shader_backend_t none_shader_backend
= {
1087 &shader_none_select
,
1088 &shader_none_select_depth_blt
,
1089 &shader_none_load_constants
,
1090 &shader_none_cleanup
,
1091 &shader_none_color_correction
,
1092 &shader_none_destroy
1095 /* *******************************************
1096 IWineD3DPixelShader IUnknown parts follow
1097 ******************************************* */
1098 HRESULT WINAPI
IWineD3DBaseShaderImpl_QueryInterface(IWineD3DBaseShader
*iface
, REFIID riid
, LPVOID
*ppobj
)
1100 IWineD3DBaseShaderImpl
*This
= (IWineD3DBaseShaderImpl
*)iface
;
1101 TRACE("(%p)->(%s,%p)\n",This
,debugstr_guid(riid
),ppobj
);
1102 if (IsEqualGUID(riid
, &IID_IUnknown
)
1103 || IsEqualGUID(riid
, &IID_IWineD3DBase
)
1104 || IsEqualGUID(riid
, &IID_IWineD3DBaseShader
)
1105 || IsEqualGUID(riid
, &IID_IWineD3DPixelShader
)) {
1106 IUnknown_AddRef(iface
);
1111 return E_NOINTERFACE
;
1114 ULONG WINAPI
IWineD3DBaseShaderImpl_AddRef(IWineD3DBaseShader
*iface
) {
1115 IWineD3DPixelShaderImpl
*This
= (IWineD3DPixelShaderImpl
*)iface
;
1116 TRACE("(%p) : AddRef increasing from %d\n", This
, This
->baseShader
.ref
);
1117 return InterlockedIncrement(&This
->baseShader
.ref
);
1120 ULONG WINAPI
IWineD3DBaseShaderImpl_Release(IWineD3DBaseShader
*iface
) {
1121 IWineD3DBaseShaderImpl
*This
= (IWineD3DBaseShaderImpl
*)iface
;
1122 IWineD3DDeviceImpl
*deviceImpl
= (IWineD3DDeviceImpl
*) This
->baseShader
.device
;
1124 TRACE("(%p) : Releasing from %d\n", This
, This
->baseShader
.ref
);
1125 ref
= InterlockedDecrement(&This
->baseShader
.ref
);
1127 deviceImpl
->shader_backend
->shader_destroy(iface
);
1128 HeapFree(GetProcessHeap(), 0, This
->baseShader
.function
);
1129 shader_delete_constant_list(&This
->baseShader
.constantsF
);
1130 shader_delete_constant_list(&This
->baseShader
.constantsB
);
1131 shader_delete_constant_list(&This
->baseShader
.constantsI
);
1132 HeapFree(GetProcessHeap(), 0, This
);