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
9 * Copyright 2007-2008 Stefan Dösinger for CodeWeavers
10 * Copyright 2009 Henri Verbeet for CodeWeavers
12 * This library is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU Lesser General Public
14 * License as published by the Free Software Foundation; either
15 * version 2.1 of the License, or (at your option) any later version.
17 * This library is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * Lesser General Public License for more details.
22 * You should have received a copy of the GNU Lesser General Public
23 * License along with this library; if not, write to the Free Software
24 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
30 #include "wined3d_private.h"
32 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader
);
33 WINE_DECLARE_DEBUG_CHANNEL(d3d
);
36 #define WINED3DSP_DCL_USAGE_SHIFT 0
37 #define WINED3DSP_DCL_USAGE_MASK (0xf << WINED3DSP_DCL_USAGE_SHIFT)
38 #define WINED3DSP_DCL_USAGEINDEX_SHIFT 16
39 #define WINED3DSP_DCL_USAGEINDEX_MASK (0xf << WINED3DSP_DCL_USAGEINDEX_SHIFT)
41 /* DCL sampler type */
42 #define WINED3DSP_TEXTURETYPE_SHIFT 27
43 #define WINED3DSP_TEXTURETYPE_MASK (0xf << WINED3DSP_TEXTURETYPE_SHIFT)
45 /* Opcode-related masks */
46 #define WINED3DSI_OPCODE_MASK 0x0000ffff
48 #define WINED3D_OPCODESPECIFICCONTROL_SHIFT 16
49 #define WINED3D_OPCODESPECIFICCONTROL_MASK (0xff << WINED3D_OPCODESPECIFICCONTROL_SHIFT)
51 #define WINED3DSI_INSTLENGTH_SHIFT 24
52 #define WINED3DSI_INSTLENGTH_MASK (0xf << WINED3DSI_INSTLENGTH_SHIFT)
54 #define WINED3DSI_COISSUE (1 << 30)
56 #define WINED3DSI_COMMENTSIZE_SHIFT 16
57 #define WINED3DSI_COMMENTSIZE_MASK (0x7fff << WINED3DSI_COMMENTSIZE_SHIFT)
59 #define WINED3DSHADER_INSTRUCTION_PREDICATED (1 << 28)
61 /* Register number mask */
62 #define WINED3DSP_REGNUM_MASK 0x000007ff
64 /* Register type masks */
65 #define WINED3DSP_REGTYPE_SHIFT 28
66 #define WINED3DSP_REGTYPE_MASK (0x7 << WINED3DSP_REGTYPE_SHIFT)
67 #define WINED3DSP_REGTYPE_SHIFT2 8
68 #define WINED3DSP_REGTYPE_MASK2 (0x18 << WINED3DSP_REGTYPE_SHIFT2)
70 /* Relative addressing mask */
71 #define WINED3DSHADER_ADDRESSMODE_SHIFT 13
72 #define WINED3DSHADER_ADDRESSMODE_MASK (1 << WINED3DSHADER_ADDRESSMODE_SHIFT)
74 /* Destination modifier mask */
75 #define WINED3DSP_DSTMOD_SHIFT 20
76 #define WINED3DSP_DSTMOD_MASK (0xf << WINED3DSP_DSTMOD_SHIFT)
78 /* Destination shift mask */
79 #define WINED3DSP_DSTSHIFT_SHIFT 24
80 #define WINED3DSP_DSTSHIFT_MASK (0xf << WINED3DSP_DSTSHIFT_SHIFT)
83 #define WINED3DSP_SWIZZLE_SHIFT 16
84 #define WINED3DSP_SWIZZLE_MASK (0xff << WINED3DSP_SWIZZLE_SHIFT)
86 /* Source modifier mask */
87 #define WINED3DSP_SRCMOD_SHIFT 24
88 #define WINED3DSP_SRCMOD_MASK (0xf << WINED3DSP_SRCMOD_SHIFT)
90 typedef enum _WINED3DSHADER_ADDRESSMODE_TYPE
92 WINED3DSHADER_ADDRMODE_ABSOLUTE
= 0 << WINED3DSHADER_ADDRESSMODE_SHIFT
,
93 WINED3DSHADER_ADDRMODE_RELATIVE
= 1 << WINED3DSHADER_ADDRESSMODE_SHIFT
,
94 WINED3DSHADER_ADDRMODE_FORCE_DWORD
= 0x7fffffff,
95 } WINED3DSHADER_ADDRESSMODE_TYPE
;
97 static void shader_dump_src_param(const struct wined3d_shader_src_param
*param
, DWORD shader_version
);
98 static void shader_dump_dst_param(const struct wined3d_shader_dst_param
*param
, DWORD shader_version
);
100 /* Read a parameter opcode from the input stream,
101 * and possibly a relative addressing token.
102 * Return the number of tokens read */
103 static int shader_get_param(const DWORD
*ptr
, DWORD shader_version
, DWORD
*token
, DWORD
*addr_token
)
109 /* PS >= 3.0 have relative addressing (with token)
110 * VS >= 2.0 have relative addressing (with token)
111 * VS >= 1.0 < 2.0 have relative addressing (without token)
112 * The version check below should work in general */
113 if (*ptr
& WINED3DSHADER_ADDRMODE_RELATIVE
)
115 if (WINED3DSHADER_VERSION_MAJOR(shader_version
) < 2)
117 *addr_token
= (1 << 31)
118 | ((WINED3DSPR_ADDR
<< WINED3DSP_REGTYPE_SHIFT2
) & WINED3DSP_REGTYPE_MASK2
)
119 | ((WINED3DSPR_ADDR
<< WINED3DSP_REGTYPE_SHIFT
) & WINED3DSP_REGTYPE_MASK
)
120 | (WINED3DSP_NOSWIZZLE
<< WINED3DSP_SWIZZLE_SHIFT
);
124 *addr_token
= *(ptr
+ 1);
132 static const SHADER_OPCODE
*shader_get_opcode(const SHADER_OPCODE
*opcode_table
, DWORD shader_version
, DWORD code
)
136 while (opcode_table
[i
].handler_idx
!= WINED3DSIH_TABLE_SIZE
)
138 if ((code
& WINED3DSI_OPCODE_MASK
) == opcode_table
[i
].opcode
139 && shader_version
>= opcode_table
[i
].min_version
140 && (!opcode_table
[i
].max_version
|| shader_version
<= opcode_table
[i
].max_version
))
142 return &opcode_table
[i
];
147 FIXME("Unsupported opcode %#x(%d) masked %#x, shader version %#x\n",
148 code
, code
, code
& WINED3DSI_OPCODE_MASK
, shader_version
);
153 /* Return the number of parameters to skip for an opcode */
154 static inline int shader_skip_opcode(const SHADER_OPCODE
*opcode_info
, DWORD opcode_token
, DWORD shader_version
)
156 /* Shaders >= 2.0 may contain address tokens, but fortunately they
157 * have a useful length mask - use it here. Shaders 1.0 contain no such tokens */
158 return (WINED3DSHADER_VERSION_MAJOR(shader_version
) >= 2)
159 ? ((opcode_token
& WINED3DSI_INSTLENGTH_MASK
) >> WINED3DSI_INSTLENGTH_SHIFT
) : opcode_info
->num_params
;
162 static void shader_parse_src_param(DWORD param
, const struct wined3d_shader_src_param
*rel_addr
,
163 struct wined3d_shader_src_param
*src
)
165 src
->register_type
= ((param
& WINED3DSP_REGTYPE_MASK
) >> WINED3DSP_REGTYPE_SHIFT
)
166 | ((param
& WINED3DSP_REGTYPE_MASK2
) >> WINED3DSP_REGTYPE_SHIFT2
);
167 src
->register_idx
= param
& WINED3DSP_REGNUM_MASK
;
168 src
->swizzle
= (param
& WINED3DSP_SWIZZLE_MASK
) >> WINED3DSP_SWIZZLE_SHIFT
;
169 src
->modifiers
= (param
& WINED3DSP_SRCMOD_MASK
) >> WINED3DSP_SRCMOD_SHIFT
;
170 src
->rel_addr
= rel_addr
;
173 static void shader_parse_dst_param(DWORD param
, const struct wined3d_shader_src_param
*rel_addr
,
174 struct wined3d_shader_dst_param
*dst
)
176 dst
->register_type
= ((param
& WINED3DSP_REGTYPE_MASK
) >> WINED3DSP_REGTYPE_SHIFT
)
177 | ((param
& WINED3DSP_REGTYPE_MASK2
) >> WINED3DSP_REGTYPE_SHIFT2
);
178 dst
->register_idx
= param
& WINED3DSP_REGNUM_MASK
;
179 dst
->write_mask
= param
& WINED3DSP_WRITEMASK_ALL
;
180 dst
->modifiers
= (param
& WINED3DSP_DSTMOD_MASK
) >> WINED3DSP_DSTMOD_SHIFT
;
181 dst
->shift
= (param
& WINED3DSP_DSTSHIFT_MASK
) >> WINED3DSP_DSTSHIFT_SHIFT
;
182 dst
->rel_addr
= rel_addr
;
185 /* Read the parameters of an unrecognized opcode from the input stream
186 * Return the number of tokens read.
188 * Note: This function assumes source or destination token format.
189 * It will not work with specially-formatted tokens like DEF or DCL,
190 * but hopefully those would be recognized */
191 static int shader_skip_unrecognized(const DWORD
*ptr
, DWORD shader_version
)
196 /* TODO: Think of a good name for 0x80000000 and replace it with a constant */
197 while (*ptr
& 0x80000000)
199 DWORD token
, addr_token
= 0;
200 struct wined3d_shader_src_param rel_addr
;
202 tokens_read
+= shader_get_param(ptr
, shader_version
, &token
, &addr_token
);
205 FIXME("Unrecognized opcode param: token=0x%08x addr_token=0x%08x name=", token
, addr_token
);
207 if (token
& WINED3DSHADER_ADDRMODE_RELATIVE
) shader_parse_src_param(addr_token
, NULL
, &rel_addr
);
211 struct wined3d_shader_dst_param dst
;
213 shader_parse_dst_param(token
, token
& WINED3DSHADER_ADDRMODE_RELATIVE
? &rel_addr
: NULL
, &dst
);
214 shader_dump_dst_param(&dst
, shader_version
);
218 struct wined3d_shader_src_param src
;
220 shader_parse_src_param(token
, token
& WINED3DSHADER_ADDRMODE_RELATIVE
? &rel_addr
: NULL
, &src
);
221 shader_dump_src_param(&src
, shader_version
);
229 static void shader_sm1_read_opcode(const DWORD
**ptr
, struct wined3d_shader_instruction
*ins
, UINT
*param_size
,
230 const SHADER_OPCODE
*opcode_table
, DWORD shader_version
)
232 const SHADER_OPCODE
*opcode_info
;
235 opcode_token
= *(*ptr
)++;
236 opcode_info
= shader_get_opcode(opcode_table
, shader_version
, opcode_token
);
239 FIXME("Unrecognized opcode: token=0x%08x\n", opcode_token
);
240 ins
->handler_idx
= WINED3DSIH_TABLE_SIZE
;
241 *param_size
= shader_skip_unrecognized(*ptr
, shader_version
);
245 ins
->handler_idx
= opcode_info
->handler_idx
;
246 ins
->flags
= (opcode_token
& WINED3D_OPCODESPECIFICCONTROL_MASK
) >> WINED3D_OPCODESPECIFICCONTROL_SHIFT
;
247 ins
->coissue
= opcode_token
& WINED3DSI_COISSUE
;
248 ins
->predicate
= opcode_token
& WINED3DSHADER_INSTRUCTION_PREDICATED
;
249 ins
->dst_count
= opcode_info
->dst_token
? 1 : 0;
250 ins
->src_count
= opcode_info
->num_params
- opcode_info
->dst_token
;
251 *param_size
= shader_skip_opcode(opcode_info
, opcode_token
, shader_version
);
254 static void shader_sm1_read_src_param(const DWORD
**ptr
, struct wined3d_shader_src_param
*src_param
,
255 struct wined3d_shader_src_param
*src_rel_addr
, DWORD shader_version
)
257 DWORD token
, addr_token
;
259 *ptr
+= shader_get_param(*ptr
, shader_version
, &token
, &addr_token
);
260 if (token
& WINED3DSHADER_ADDRMODE_RELATIVE
)
262 shader_parse_src_param(addr_token
, NULL
, src_rel_addr
);
263 shader_parse_src_param(token
, src_rel_addr
, src_param
);
267 shader_parse_src_param(token
, NULL
, src_param
);
271 static void shader_sm1_read_dst_param(const DWORD
**ptr
, struct wined3d_shader_dst_param
*dst_param
,
272 struct wined3d_shader_src_param
*dst_rel_addr
, DWORD shader_version
)
274 DWORD token
, addr_token
;
276 *ptr
+= shader_get_param(*ptr
, shader_version
, &token
, &addr_token
);
277 if (token
& WINED3DSHADER_ADDRMODE_RELATIVE
)
279 shader_parse_src_param(addr_token
, NULL
, dst_rel_addr
);
280 shader_parse_dst_param(token
, dst_rel_addr
, dst_param
);
284 shader_parse_dst_param(token
, NULL
, dst_param
);
288 static void shader_sm1_read_semantic(const DWORD
**ptr
, struct wined3d_shader_semantic
*semantic
)
290 DWORD usage_token
= *(*ptr
)++;
291 DWORD dst_token
= *(*ptr
)++;
293 semantic
->usage
= (usage_token
& WINED3DSP_DCL_USAGE_MASK
) >> WINED3DSP_DCL_USAGE_SHIFT
;
294 semantic
->usage_idx
= (usage_token
& WINED3DSP_DCL_USAGEINDEX_MASK
) >> WINED3DSP_DCL_USAGEINDEX_SHIFT
;
295 semantic
->sampler_type
= (usage_token
& WINED3DSP_TEXTURETYPE_MASK
) >> WINED3DSP_TEXTURETYPE_SHIFT
;
296 shader_parse_dst_param(dst_token
, NULL
, &semantic
->reg
);
299 static void shader_sm1_read_comment(const DWORD
**ptr
, const char **comment
)
303 if ((token
& WINED3DSI_OPCODE_MASK
) != WINED3DSIO_COMMENT
)
309 *comment
= (const char *)++(*ptr
);
310 *ptr
+= (token
& WINED3DSI_COMMENTSIZE_MASK
) >> WINED3DSI_COMMENTSIZE_SHIFT
;
313 static const char *shader_opcode_names
[] =
315 /* WINED3DSIH_ABS */ "abs",
316 /* WINED3DSIH_ADD */ "add",
317 /* WINED3DSIH_BEM */ "bem",
318 /* WINED3DSIH_BREAK */ "break",
319 /* WINED3DSIH_BREAKC */ "breakc",
320 /* WINED3DSIH_BREAKP */ "breakp",
321 /* WINED3DSIH_CALL */ "call",
322 /* WINED3DSIH_CALLNZ */ "callnz",
323 /* WINED3DSIH_CMP */ "cmp",
324 /* WINED3DSIH_CND */ "cnd",
325 /* WINED3DSIH_CRS */ "crs",
326 /* WINED3DSIH_DCL */ "dcl",
327 /* WINED3DSIH_DEF */ "def",
328 /* WINED3DSIH_DEFB */ "defb",
329 /* WINED3DSIH_DEFI */ "defi",
330 /* WINED3DSIH_DP2ADD */ "dp2add",
331 /* WINED3DSIH_DP3 */ "dp3",
332 /* WINED3DSIH_DP4 */ "dp4",
333 /* WINED3DSIH_DST */ "dst",
334 /* WINED3DSIH_DSX */ "dsx",
335 /* WINED3DSIH_DSY */ "dsy",
336 /* WINED3DSIH_ELSE */ "else",
337 /* WINED3DSIH_ENDIF */ "endif",
338 /* WINED3DSIH_ENDLOOP */ "endloop",
339 /* WINED3DSIH_ENDREP */ "endrep",
340 /* WINED3DSIH_EXP */ "exp",
341 /* WINED3DSIH_EXPP */ "expp",
342 /* WINED3DSIH_FRC */ "frc",
343 /* WINED3DSIH_IF */ "if",
344 /* WINED3DSIH_IFC */ "ifc",
345 /* WINED3DSIH_LABEL */ "label",
346 /* WINED3DSIH_LIT */ "lit",
347 /* WINED3DSIH_LOG */ "log",
348 /* WINED3DSIH_LOGP */ "logp",
349 /* WINED3DSIH_LOOP */ "loop",
350 /* WINED3DSIH_LRP */ "lrp",
351 /* WINED3DSIH_M3x2 */ "m3x2",
352 /* WINED3DSIH_M3x3 */ "m3x3",
353 /* WINED3DSIH_M3x4 */ "m3x4",
354 /* WINED3DSIH_M4x3 */ "m4x3",
355 /* WINED3DSIH_M4x4 */ "m4x4",
356 /* WINED3DSIH_MAD */ "mad",
357 /* WINED3DSIH_MAX */ "max",
358 /* WINED3DSIH_MIN */ "min",
359 /* WINED3DSIH_MOV */ "mov",
360 /* WINED3DSIH_MOVA */ "mova",
361 /* WINED3DSIH_MUL */ "mul",
362 /* WINED3DSIH_NOP */ "nop",
363 /* WINED3DSIH_NRM */ "nrm",
364 /* WINED3DSIH_PHASE */ "phase",
365 /* WINED3DSIH_POW */ "pow",
366 /* WINED3DSIH_RCP */ "rcp",
367 /* WINED3DSIH_REP */ "rep",
368 /* WINED3DSIH_RET */ "ret",
369 /* WINED3DSIH_RSQ */ "rsq",
370 /* WINED3DSIH_SETP */ "setp",
371 /* WINED3DSIH_SGE */ "sge",
372 /* WINED3DSIH_SGN */ "sgn",
373 /* WINED3DSIH_SINCOS */ "sincos",
374 /* WINED3DSIH_SLT */ "slt",
375 /* WINED3DSIH_SUB */ "sub",
376 /* WINED3DSIH_TEX */ "texld",
377 /* WINED3DSIH_TEXBEM */ "texbem",
378 /* WINED3DSIH_TEXBEML */ "texbeml",
379 /* WINED3DSIH_TEXCOORD */ "texcrd",
380 /* WINED3DSIH_TEXDEPTH */ "texdepth",
381 /* WINED3DSIH_TEXDP3 */ "texdp3",
382 /* WINED3DSIH_TEXDP3TEX */ "texdp3tex",
383 /* WINED3DSIH_TEXKILL */ "texkill",
384 /* WINED3DSIH_TEXLDD */ "texldd",
385 /* WINED3DSIH_TEXLDL */ "texldl",
386 /* WINED3DSIH_TEXM3x2DEPTH */ "texm3x2depth",
387 /* WINED3DSIH_TEXM3x2PAD */ "texm3x2pad",
388 /* WINED3DSIH_TEXM3x2TEX */ "texm3x2tex",
389 /* WINED3DSIH_TEXM3x3 */ "texm3x3",
390 /* WINED3DSIH_TEXM3x3DIFF */ "texm3x3diff",
391 /* WINED3DSIH_TEXM3x3PAD */ "texm3x3pad",
392 /* WINED3DSIH_TEXM3x3SPEC */ "texm3x3spec",
393 /* WINED3DSIH_TEXM3x3TEX */ "texm3x3tex",
394 /* WINED3DSIH_TEXM3x3VSPEC */ "texm3x3vspec",
395 /* WINED3DSIH_TEXREG2AR */ "texreg2ar",
396 /* WINED3DSIH_TEXREG2GB */ "texreg2gb",
397 /* WINED3DSIH_TEXREG2RGB */ "texreg2rgb",
400 static inline BOOL
shader_is_version_token(DWORD token
) {
401 return shader_is_pshader_version(token
) ||
402 shader_is_vshader_version(token
);
405 void shader_buffer_init(struct SHADER_BUFFER
*buffer
)
407 buffer
->buffer
= HeapAlloc(GetProcessHeap(), 0, SHADER_PGMSIZE
);
408 buffer
->buffer
[0] = '\0';
411 buffer
->newline
= TRUE
;
414 void shader_buffer_free(struct SHADER_BUFFER
*buffer
)
416 HeapFree(GetProcessHeap(), 0, buffer
->buffer
);
419 int shader_vaddline(SHADER_BUFFER
* buffer
, const char *format
, va_list args
)
421 char* base
= buffer
->buffer
+ buffer
->bsize
;
424 rc
= vsnprintf(base
, SHADER_PGMSIZE
- 1 - buffer
->bsize
, format
, args
);
426 if (rc
< 0 || /* C89 */
427 rc
> SHADER_PGMSIZE
- 1 - buffer
->bsize
) { /* C99 */
429 ERR("The buffer allocated for the shader program string "
430 "is too small at %d bytes.\n", SHADER_PGMSIZE
);
431 buffer
->bsize
= SHADER_PGMSIZE
- 1;
435 if (buffer
->newline
) {
436 TRACE("GL HW (%u, %u) : %s", buffer
->lineNo
+ 1, buffer
->bsize
, base
);
437 buffer
->newline
= FALSE
;
443 if (buffer
->buffer
[buffer
->bsize
-1] == '\n') {
445 buffer
->newline
= TRUE
;
450 int shader_addline(SHADER_BUFFER
* buffer
, const char *format
, ...)
455 va_start(args
, format
);
456 ret
= shader_vaddline(buffer
, format
, args
);
462 void shader_init(struct IWineD3DBaseShaderClass
*shader
,
463 IWineD3DDevice
*device
, const SHADER_OPCODE
*instruction_table
)
466 shader
->device
= device
;
467 shader
->shader_ins
= instruction_table
;
468 list_init(&shader
->linked_programs
);
471 /* Convert floating point offset relative
472 * to a register file to an absolute offset for float constants */
473 static unsigned int shader_get_float_offset(WINED3DSHADER_PARAM_REGISTER_TYPE register_type
, UINT register_idx
)
475 switch (register_type
)
477 case WINED3DSPR_CONST
: return register_idx
;
478 case WINED3DSPR_CONST2
: return 2048 + register_idx
;
479 case WINED3DSPR_CONST3
: return 4096 + register_idx
;
480 case WINED3DSPR_CONST4
: return 6144 + register_idx
;
482 FIXME("Unsupported register type: %d\n", register_type
);
487 static void shader_delete_constant_list(struct list
* clist
) {
490 struct local_constant
* constant
;
492 ptr
= list_head(clist
);
494 constant
= LIST_ENTRY(ptr
, struct local_constant
, entry
);
495 ptr
= list_next(clist
, ptr
);
496 HeapFree(GetProcessHeap(), 0, constant
);
501 static void shader_record_register_usage(IWineD3DBaseShaderImpl
*This
, struct shader_reg_maps
*reg_maps
,
502 DWORD register_type
, UINT register_idx
, BOOL has_rel_addr
, BOOL pshader
)
504 switch (register_type
)
506 case WINED3DSPR_TEXTURE
: /* WINED3DSPR_ADDR */
507 if (pshader
) reg_maps
->texcoord
[register_idx
] = 1;
508 else reg_maps
->address
[register_idx
] = 1;
511 case WINED3DSPR_TEMP
:
512 reg_maps
->temporary
[register_idx
] = 1;
515 case WINED3DSPR_INPUT
:
516 if (!pshader
) reg_maps
->attributes
[register_idx
] = 1;
521 /* If relative addressing is used, we must assume that all registers
522 * are used. Even if it is a construct like v3[aL], we can't assume
523 * that v0, v1 and v2 aren't read because aL can be negative */
525 for (i
= 0; i
< MAX_REG_INPUT
; ++i
)
527 ((IWineD3DPixelShaderImpl
*)This
)->input_reg_used
[i
] = TRUE
;
532 ((IWineD3DPixelShaderImpl
*)This
)->input_reg_used
[register_idx
] = TRUE
;
537 case WINED3DSPR_RASTOUT
:
538 if (register_idx
== 1) reg_maps
->fog
= 1;
541 case WINED3DSPR_MISCTYPE
:
542 if (pshader
&& register_idx
== 0) reg_maps
->vpos
= 1;
545 case WINED3DSPR_CONST
:
550 if (register_idx
<= ((IWineD3DVertexShaderImpl
*)This
)->min_rel_offset
)
551 ((IWineD3DVertexShaderImpl
*)This
)->min_rel_offset
= register_idx
;
552 else if (register_idx
>= ((IWineD3DVertexShaderImpl
*)This
)->max_rel_offset
)
553 ((IWineD3DVertexShaderImpl
*)This
)->max_rel_offset
= register_idx
;
555 reg_maps
->usesrelconstF
= TRUE
;
559 case WINED3DSPR_CONSTINT
:
560 reg_maps
->integer_constants
|= (1 << register_idx
);
563 case WINED3DSPR_CONSTBOOL
:
564 reg_maps
->boolean_constants
|= (1 << register_idx
);
568 TRACE("Not recording register of type %#x and idx %u\n", register_type
, register_idx
);
573 /* Note that this does not count the loop register
574 * as an address register. */
576 HRESULT
shader_get_registers_used(IWineD3DBaseShader
*iface
, struct shader_reg_maps
*reg_maps
,
577 struct wined3d_shader_semantic
*semantics_in
, struct wined3d_shader_semantic
*semantics_out
,
578 const DWORD
*byte_code
)
580 IWineD3DBaseShaderImpl
* This
= (IWineD3DBaseShaderImpl
*) iface
;
581 const SHADER_OPCODE
*shader_ins
= This
->baseShader
.shader_ins
;
582 DWORD shader_version
;
583 unsigned int cur_loop_depth
= 0, max_loop_depth
= 0;
584 const DWORD
* pToken
= byte_code
;
587 /* There are some minor differences between pixel and vertex shaders */
589 memset(reg_maps
, 0, sizeof(*reg_maps
));
591 /* get_registers_used is called on every compile on some 1.x shaders, which can result
592 * in stacking up a collection of local constants. Delete the old constants if existing
594 shader_delete_constant_list(&This
->baseShader
.constantsF
);
595 shader_delete_constant_list(&This
->baseShader
.constantsB
);
596 shader_delete_constant_list(&This
->baseShader
.constantsI
);
598 /* The version token is supposed to be the first token */
599 if (!shader_is_version_token(*pToken
))
601 FIXME("First token is not a version token, invalid shader.\n");
602 return WINED3DERR_INVALIDCALL
;
604 reg_maps
->shader_version
= shader_version
= *pToken
++;
605 pshader
= shader_is_pshader_version(shader_version
);
607 while (WINED3DVS_END() != *pToken
) {
608 struct wined3d_shader_instruction ins
;
613 shader_sm1_read_comment(&pToken
, &comment
);
614 if (comment
) continue;
617 shader_sm1_read_opcode(&pToken
, &ins
, ¶m_size
, shader_ins
, shader_version
);
619 /* Unhandled opcode, and its parameters */
620 if (ins
.handler_idx
== WINED3DSIH_TABLE_SIZE
)
622 TRACE("Skipping unrecognized instruction.\n");
623 pToken
+= param_size
;
627 /* Handle declarations */
628 if (ins
.handler_idx
== WINED3DSIH_DCL
)
630 struct wined3d_shader_semantic semantic
;
632 shader_sm1_read_semantic(&pToken
, &semantic
);
634 switch (semantic
.reg
.register_type
)
636 /* Vshader: mark attributes used
637 * Pshader: mark 3.0 input registers used, save token */
638 case WINED3DSPR_INPUT
:
639 if (!pshader
) reg_maps
->attributes
[semantic
.reg
.register_idx
] = 1;
640 else reg_maps
->packed_input
[semantic
.reg
.register_idx
] = 1;
641 semantics_in
[semantic
.reg
.register_idx
] = semantic
;
644 /* Vshader: mark 3.0 output registers used, save token */
645 case WINED3DSPR_OUTPUT
:
646 reg_maps
->packed_output
[semantic
.reg
.register_idx
] = 1;
647 semantics_out
[semantic
.reg
.register_idx
] = semantic
;
648 if (semantic
.usage
== WINED3DDECLUSAGE_FOG
) reg_maps
->fog
= 1;
651 /* Save sampler usage token */
652 case WINED3DSPR_SAMPLER
:
653 reg_maps
->sampler_type
[semantic
.reg
.register_idx
] = semantic
.sampler_type
;
657 TRACE("Not recording DCL register type %#x.\n", semantic
.reg
.register_type
);
661 else if (ins
.handler_idx
== WINED3DSIH_DEF
)
663 struct wined3d_shader_dst_param dst
;
664 struct wined3d_shader_src_param rel_addr
;
666 local_constant
* lconst
= HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant
));
667 if (!lconst
) return E_OUTOFMEMORY
;
669 shader_sm1_read_dst_param(&pToken
, &dst
, &rel_addr
, shader_version
);
670 lconst
->idx
= dst
.register_idx
;
672 memcpy(lconst
->value
, pToken
, 4 * sizeof(DWORD
));
675 /* In pixel shader 1.X shaders, the constants are clamped between [-1;1] */
676 if (WINED3DSHADER_VERSION_MAJOR(shader_version
) == 1 && pshader
)
678 float *value
= (float *) lconst
->value
;
679 if(value
[0] < -1.0) value
[0] = -1.0;
680 else if(value
[0] > 1.0) value
[0] = 1.0;
681 if(value
[1] < -1.0) value
[1] = -1.0;
682 else if(value
[1] > 1.0) value
[1] = 1.0;
683 if(value
[2] < -1.0) value
[2] = -1.0;
684 else if(value
[2] > 1.0) value
[2] = 1.0;
685 if(value
[3] < -1.0) value
[3] = -1.0;
686 else if(value
[3] > 1.0) value
[3] = 1.0;
689 list_add_head(&This
->baseShader
.constantsF
, &lconst
->entry
);
691 else if (ins
.handler_idx
== WINED3DSIH_DEFI
)
693 struct wined3d_shader_dst_param dst
;
694 struct wined3d_shader_src_param rel_addr
;
696 local_constant
* lconst
= HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant
));
697 if (!lconst
) return E_OUTOFMEMORY
;
699 shader_sm1_read_dst_param(&pToken
, &dst
, &rel_addr
, shader_version
);
700 lconst
->idx
= dst
.register_idx
;
702 memcpy(lconst
->value
, pToken
, 4 * sizeof(DWORD
));
705 list_add_head(&This
->baseShader
.constantsI
, &lconst
->entry
);
707 else if (ins
.handler_idx
== WINED3DSIH_DEFB
)
709 struct wined3d_shader_dst_param dst
;
710 struct wined3d_shader_src_param rel_addr
;
712 local_constant
* lconst
= HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant
));
713 if (!lconst
) return E_OUTOFMEMORY
;
715 shader_sm1_read_dst_param(&pToken
, &dst
, &rel_addr
, shader_version
);
716 lconst
->idx
= dst
.register_idx
;
718 memcpy(lconst
->value
, pToken
, sizeof(DWORD
));
721 list_add_head(&This
->baseShader
.constantsB
, &lconst
->entry
);
723 /* If there's a loop in the shader */
724 else if (ins
.handler_idx
== WINED3DSIH_LOOP
725 || ins
.handler_idx
== WINED3DSIH_REP
)
729 if(ins
.handler_idx
== WINED3DSIH_LOOP
) {
736 if(cur_loop_depth
> max_loop_depth
)
737 max_loop_depth
= cur_loop_depth
;
738 pToken
+= param_size
;
740 /* Rep and Loop always use an integer constant for the control parameters */
741 reg_maps
->integer_constants
|= (1 << (reg
& WINED3DSP_REGNUM_MASK
));
743 else if (ins
.handler_idx
== WINED3DSIH_ENDLOOP
744 || ins
.handler_idx
== WINED3DSIH_ENDREP
)
748 /* For subroutine prototypes */
749 else if (ins
.handler_idx
== WINED3DSIH_LABEL
)
752 DWORD snum
= *pToken
& WINED3DSP_REGNUM_MASK
;
753 reg_maps
->labels
[snum
] = 1;
754 pToken
+= param_size
;
756 /* Set texture, address, temporary registers */
761 /* Declare 1.X samplers implicitly, based on the destination reg. number */
762 if (WINED3DSHADER_VERSION_MAJOR(shader_version
) == 1
763 && pshader
/* Filter different instructions with the same enum values in VS */
764 && (ins
.handler_idx
== WINED3DSIH_TEX
765 || ins
.handler_idx
== WINED3DSIH_TEXBEM
766 || ins
.handler_idx
== WINED3DSIH_TEXBEML
767 || ins
.handler_idx
== WINED3DSIH_TEXDP3TEX
768 || ins
.handler_idx
== WINED3DSIH_TEXM3x2TEX
769 || ins
.handler_idx
== WINED3DSIH_TEXM3x3SPEC
770 || ins
.handler_idx
== WINED3DSIH_TEXM3x3TEX
771 || ins
.handler_idx
== WINED3DSIH_TEXM3x3VSPEC
772 || ins
.handler_idx
== WINED3DSIH_TEXREG2AR
773 || ins
.handler_idx
== WINED3DSIH_TEXREG2GB
774 || ins
.handler_idx
== WINED3DSIH_TEXREG2RGB
))
776 /* Fake sampler usage, only set reserved bit and ttype */
777 DWORD sampler_code
= *pToken
& WINED3DSP_REGNUM_MASK
;
779 TRACE("Setting fake 2D sampler for 1.x pixelshader\n");
780 reg_maps
->sampler_type
[sampler_code
] = WINED3DSTT_2D
;
782 /* texbem is only valid with < 1.4 pixel shaders */
783 if (ins
.handler_idx
== WINED3DSIH_TEXBEM
784 || ins
.handler_idx
== WINED3DSIH_TEXBEML
)
786 reg_maps
->bumpmat
[sampler_code
] = TRUE
;
787 if (ins
.handler_idx
== WINED3DSIH_TEXBEML
)
789 reg_maps
->luminanceparams
[sampler_code
] = TRUE
;
793 if (ins
.handler_idx
== WINED3DSIH_NRM
)
795 reg_maps
->usesnrm
= 1;
797 else if (pshader
&& ins
.handler_idx
== WINED3DSIH_BEM
)
799 DWORD regnum
= *pToken
& WINED3DSP_REGNUM_MASK
;
800 reg_maps
->bumpmat
[regnum
] = TRUE
;
802 else if (ins
.handler_idx
== WINED3DSIH_DSY
)
804 reg_maps
->usesdsy
= 1;
807 /* This will loop over all the registers and try to
808 * make a bitmask of the ones we're interested in.
810 * Relative addressing tokens are ignored, but that's
811 * okay, since we'll catch any address registers when
812 * they are initialized (required by spec) */
816 struct wined3d_shader_dst_param dst_param
;
817 struct wined3d_shader_src_param dst_rel_addr
;
819 shader_sm1_read_dst_param(&pToken
, &dst_param
, &dst_rel_addr
, shader_version
);
821 /* WINED3DSPR_TEXCRDOUT is the same as WINED3DSPR_OUTPUT. _OUTPUT can be > MAX_REG_TEXCRD and
822 * is used in >= 3.0 shaders. Filter 3.0 shaders to prevent overflows, and also filter pixel
823 * shaders because TECRDOUT isn't used in them, but future register types might cause issues */
824 if (!pshader
&& WINED3DSHADER_VERSION_MAJOR(shader_version
) < 3
825 && dst_param
.register_type
== WINED3DSPR_TEXCRDOUT
)
827 reg_maps
->texcoord_mask
[dst_param
.register_type
] |= dst_param
.write_mask
;
831 shader_record_register_usage(This
, reg_maps
, dst_param
.register_type
,
832 dst_param
.register_idx
, !!dst_param
.rel_addr
, pshader
);
836 limit
= ins
.src_count
+ (ins
.predicate
? 1 : 0);
837 for (i
= 0; i
< limit
; ++i
)
839 struct wined3d_shader_src_param src_param
, src_rel_addr
;
841 shader_sm1_read_src_param(&pToken
, &src_param
, &src_rel_addr
, shader_version
);
842 shader_record_register_usage(This
, reg_maps
, src_param
.register_type
,
843 src_param
.register_idx
, !!src_param
.rel_addr
, pshader
);
848 reg_maps
->loop_depth
= max_loop_depth
;
850 This
->baseShader
.functionLength
= ((char *)pToken
- (char *)byte_code
);
855 static void shader_dump_decl_usage(const struct wined3d_shader_semantic
*semantic
, DWORD shader_version
)
859 if (semantic
->reg
.register_type
== WINED3DSPR_SAMPLER
)
861 switch (semantic
->sampler_type
)
863 case WINED3DSTT_2D
: TRACE("_2d"); break;
864 case WINED3DSTT_CUBE
: TRACE("_cube"); break;
865 case WINED3DSTT_VOLUME
: TRACE("_volume"); break;
866 default: TRACE("_unknown_ttype(0x%08x)", semantic
->sampler_type
);
871 /* Pixel shaders 3.0 don't have usage semantics */
872 if (shader_is_pshader_version(shader_version
) && shader_version
< WINED3DPS_VERSION(3,0))
877 switch (semantic
->usage
)
879 case WINED3DDECLUSAGE_POSITION
:
880 TRACE("position%d", semantic
->usage_idx
);
882 case WINED3DDECLUSAGE_BLENDINDICES
:
885 case WINED3DDECLUSAGE_BLENDWEIGHT
:
888 case WINED3DDECLUSAGE_NORMAL
:
889 TRACE("normal%d", semantic
->usage_idx
);
891 case WINED3DDECLUSAGE_PSIZE
:
894 case WINED3DDECLUSAGE_COLOR
:
895 if (semantic
->usage_idx
== 0) TRACE("color");
896 else TRACE("specular%d", (semantic
->usage_idx
- 1));
898 case WINED3DDECLUSAGE_TEXCOORD
:
899 TRACE("texture%d", semantic
->usage_idx
);
901 case WINED3DDECLUSAGE_TANGENT
:
904 case WINED3DDECLUSAGE_BINORMAL
:
907 case WINED3DDECLUSAGE_TESSFACTOR
:
910 case WINED3DDECLUSAGE_POSITIONT
:
911 TRACE("positionT%d", semantic
->usage_idx
);
913 case WINED3DDECLUSAGE_FOG
:
916 case WINED3DDECLUSAGE_DEPTH
:
919 case WINED3DDECLUSAGE_SAMPLE
:
923 FIXME("unknown_semantics(0x%08x)", semantic
->usage
);
928 static void shader_dump_register(WINED3DSHADER_PARAM_REGISTER_TYPE register_type
, UINT register_idx
,
929 const struct wined3d_shader_src_param
*rel_addr
, DWORD shader_version
)
931 static const char * const rastout_reg_names
[] = {"oPos", "oFog", "oPts"};
932 static const char * const misctype_reg_names
[] = {"vPos", "vFace"};
933 UINT offset
= register_idx
;
935 switch (register_type
)
937 case WINED3DSPR_TEMP
:
941 case WINED3DSPR_INPUT
:
945 case WINED3DSPR_CONST
:
946 case WINED3DSPR_CONST2
:
947 case WINED3DSPR_CONST3
:
948 case WINED3DSPR_CONST4
:
950 offset
= shader_get_float_offset(register_type
, register_idx
);
953 case WINED3DSPR_TEXTURE
: /* vs: case WINED3DSPR_ADDR */
954 TRACE("%c", shader_is_pshader_version(shader_version
) ? 't' : 'a');
957 case WINED3DSPR_RASTOUT
:
958 TRACE("%s", rastout_reg_names
[register_idx
]);
961 case WINED3DSPR_COLOROUT
:
965 case WINED3DSPR_DEPTHOUT
:
969 case WINED3DSPR_ATTROUT
:
973 case WINED3DSPR_TEXCRDOUT
:
974 /* Vertex shaders >= 3.0 use general purpose output registers
975 * (WINED3DSPR_OUTPUT), which can include an address token */
976 if (WINED3DSHADER_VERSION_MAJOR(shader_version
) >= 3) TRACE("o");
980 case WINED3DSPR_CONSTINT
:
984 case WINED3DSPR_CONSTBOOL
:
988 case WINED3DSPR_LABEL
:
992 case WINED3DSPR_LOOP
:
996 case WINED3DSPR_SAMPLER
:
1000 case WINED3DSPR_MISCTYPE
:
1001 if (register_idx
> 1) FIXME("Unhandled misctype register %d\n", register_idx
);
1002 else TRACE("%s", misctype_reg_names
[register_idx
]);
1005 case WINED3DSPR_PREDICATE
:
1010 TRACE("unhandled_rtype(%#x)", register_type
);
1014 if (register_type
!= WINED3DSPR_RASTOUT
&& register_type
!= WINED3DSPR_MISCTYPE
)
1019 shader_dump_src_param(rel_addr
, shader_version
);
1022 TRACE("%u", offset
);
1023 if (rel_addr
) TRACE("]");
1027 static void shader_dump_dst_param(const struct wined3d_shader_dst_param
*param
, DWORD shader_version
)
1029 DWORD write_mask
= param
->write_mask
;
1031 shader_dump_register(param
->register_type
, param
->register_idx
, param
->rel_addr
, shader_version
);
1033 if (write_mask
!= WINED3DSP_WRITEMASK_ALL
)
1035 static const char *write_mask_chars
= "xyzw";
1038 if (write_mask
& WINED3DSP_WRITEMASK_0
) TRACE("%c", write_mask_chars
[0]);
1039 if (write_mask
& WINED3DSP_WRITEMASK_1
) TRACE("%c", write_mask_chars
[1]);
1040 if (write_mask
& WINED3DSP_WRITEMASK_2
) TRACE("%c", write_mask_chars
[2]);
1041 if (write_mask
& WINED3DSP_WRITEMASK_3
) TRACE("%c", write_mask_chars
[3]);
1045 static void shader_dump_src_param(const struct wined3d_shader_src_param
*param
, DWORD shader_version
)
1047 DWORD src_modifier
= param
->modifiers
;
1048 DWORD swizzle
= param
->swizzle
;
1050 if (src_modifier
== WINED3DSPSM_NEG
1051 || src_modifier
== WINED3DSPSM_BIASNEG
1052 || src_modifier
== WINED3DSPSM_SIGNNEG
1053 || src_modifier
== WINED3DSPSM_X2NEG
1054 || src_modifier
== WINED3DSPSM_ABSNEG
)
1056 else if (src_modifier
== WINED3DSPSM_COMP
)
1058 else if (src_modifier
== WINED3DSPSM_NOT
)
1061 if (src_modifier
== WINED3DSPSM_ABS
|| src_modifier
== WINED3DSPSM_ABSNEG
)
1064 shader_dump_register(param
->register_type
, param
->register_idx
, param
->rel_addr
, shader_version
);
1068 switch (src_modifier
)
1070 case WINED3DSPSM_NONE
: break;
1071 case WINED3DSPSM_NEG
: break;
1072 case WINED3DSPSM_NOT
: break;
1073 case WINED3DSPSM_BIAS
: TRACE("_bias"); break;
1074 case WINED3DSPSM_BIASNEG
: TRACE("_bias"); break;
1075 case WINED3DSPSM_SIGN
: TRACE("_bx2"); break;
1076 case WINED3DSPSM_SIGNNEG
: TRACE("_bx2"); break;
1077 case WINED3DSPSM_COMP
: break;
1078 case WINED3DSPSM_X2
: TRACE("_x2"); break;
1079 case WINED3DSPSM_X2NEG
: TRACE("_x2"); break;
1080 case WINED3DSPSM_DZ
: TRACE("_dz"); break;
1081 case WINED3DSPSM_DW
: TRACE("_dw"); break;
1082 case WINED3DSPSM_ABSNEG
: TRACE(")"); break;
1083 case WINED3DSPSM_ABS
: TRACE(")"); break;
1085 TRACE("_unknown_modifier(%#x)", src_modifier
);
1089 if (swizzle
!= WINED3DSP_NOSWIZZLE
)
1091 static const char *swizzle_chars
= "xyzw";
1092 DWORD swizzle_x
= swizzle
& 0x03;
1093 DWORD swizzle_y
= (swizzle
>> 2) & 0x03;
1094 DWORD swizzle_z
= (swizzle
>> 4) & 0x03;
1095 DWORD swizzle_w
= (swizzle
>> 6) & 0x03;
1097 if (swizzle_x
== swizzle_y
1098 && swizzle_x
== swizzle_z
1099 && swizzle_x
== swizzle_w
)
1101 TRACE(".%c", swizzle_chars
[swizzle_x
]);
1105 TRACE(".%c%c%c%c", swizzle_chars
[swizzle_x
], swizzle_chars
[swizzle_y
],
1106 swizzle_chars
[swizzle_z
], swizzle_chars
[swizzle_w
]);
1111 /* Shared code in order to generate the bulk of the shader string.
1112 * NOTE: A description of how to parse tokens can be found on msdn */
1113 void shader_generate_main(IWineD3DBaseShader
*iface
, SHADER_BUFFER
* buffer
,
1114 const shader_reg_maps
* reg_maps
, CONST DWORD
* pFunction
)
1116 IWineD3DBaseShaderImpl
* This
= (IWineD3DBaseShaderImpl
*) iface
;
1117 IWineD3DDeviceImpl
*device
= (IWineD3DDeviceImpl
*) This
->baseShader
.device
; /* To access shader backend callbacks */
1118 const SHADER_OPCODE
*opcode_table
= This
->baseShader
.shader_ins
;
1119 const SHADER_HANDLER
*handler_table
= device
->shader_backend
->shader_instruction_handler_table
;
1120 DWORD shader_version
= reg_maps
->shader_version
;
1121 struct wined3d_shader_src_param src_rel_addr
[4];
1122 struct wined3d_shader_src_param src_param
[4];
1123 struct wined3d_shader_src_param dst_rel_addr
;
1124 struct wined3d_shader_dst_param dst_param
;
1125 struct wined3d_shader_instruction ins
;
1126 struct wined3d_shader_context ctx
;
1127 const DWORD
*pToken
= pFunction
;
1128 SHADER_HANDLER hw_fct
;
1131 /* Initialize current parsing state */
1133 ctx
.reg_maps
= reg_maps
;
1134 ctx
.buffer
= buffer
;
1137 ins
.dst
= &dst_param
;
1138 ins
.src
= src_param
;
1139 This
->baseShader
.parse_state
.current_row
= 0;
1141 if (!shader_is_version_token(*pToken
++))
1143 ERR("First token is not a version token, invalid shader.\n");
1147 while (WINED3DPS_END() != *pToken
)
1149 const char *comment
;
1152 /* Skip comment tokens */
1153 shader_sm1_read_comment(&pToken
, &comment
);
1154 if (comment
) continue;
1157 shader_sm1_read_opcode(&pToken
, &ins
, ¶m_size
, opcode_table
, shader_version
);
1159 /* Unknown opcode and its parameters */
1160 if (ins
.handler_idx
== WINED3DSIH_TABLE_SIZE
)
1162 TRACE("Skipping unrecognized instruction.\n");
1163 pToken
+= param_size
;
1168 if (ins
.handler_idx
== WINED3DSIH_DCL
1169 || ins
.handler_idx
== WINED3DSIH_NOP
1170 || ins
.handler_idx
== WINED3DSIH_DEF
1171 || ins
.handler_idx
== WINED3DSIH_DEFI
1172 || ins
.handler_idx
== WINED3DSIH_DEFB
1173 || ins
.handler_idx
== WINED3DSIH_PHASE
1174 || ins
.handler_idx
== WINED3DSIH_RET
)
1176 pToken
+= param_size
;
1180 /* Select handler */
1181 hw_fct
= handler_table
[ins
.handler_idx
];
1183 /* Unhandled opcode */
1186 FIXME("Backend can't handle opcode %#x\n", ins
.handler_idx
);
1187 pToken
+= param_size
;
1191 /* Destination token */
1192 if (ins
.dst_count
) shader_sm1_read_dst_param(&pToken
, &dst_param
, &dst_rel_addr
, shader_version
);
1194 /* Predication token */
1195 if (ins
.predicate
) ins
.predicate
= *pToken
++;
1197 /* Other source tokens */
1198 for (i
= 0; i
< ins
.src_count
; ++i
)
1200 shader_sm1_read_src_param(&pToken
, &src_param
[i
], &src_rel_addr
[i
], shader_version
);
1203 /* Call appropriate function for output target */
1206 /* Process instruction modifiers for GLSL apps ( _sat, etc. ) */
1207 /* FIXME: This should be internal to the shader backend.
1208 * Also, right now this is the only reason "shader_mode" exists. */
1209 if (This
->baseShader
.shader_mode
== SHADER_GLSL
) shader_glsl_add_instruction_modifiers(&ins
);
1213 static void shader_dump_ins_modifiers(const struct wined3d_shader_dst_param
*dst
)
1215 DWORD mmask
= dst
->modifiers
;
1220 case 13: TRACE("_d8"); break;
1221 case 14: TRACE("_d4"); break;
1222 case 15: TRACE("_d2"); break;
1223 case 1: TRACE("_x2"); break;
1224 case 2: TRACE("_x4"); break;
1225 case 3: TRACE("_x8"); break;
1226 default: TRACE("_unhandled_shift(%d)", dst
->shift
); break;
1229 if (mmask
& WINED3DSPDM_SATURATE
) TRACE("_sat");
1230 if (mmask
& WINED3DSPDM_PARTIALPRECISION
) TRACE("_pp");
1231 if (mmask
& WINED3DSPDM_MSAMPCENTROID
) TRACE("_centroid");
1233 mmask
&= ~(WINED3DSPDM_SATURATE
| WINED3DSPDM_PARTIALPRECISION
| WINED3DSPDM_MSAMPCENTROID
);
1235 FIXME("_unrecognized_modifier(%#x)", mmask
);
1238 void shader_trace_init(const DWORD
*pFunction
, const SHADER_OPCODE
*opcode_table
)
1240 const DWORD
* pToken
= pFunction
;
1241 DWORD shader_version
;
1244 TRACE("Parsing %p\n", pFunction
);
1246 /* The version token is supposed to be the first token */
1247 if (!shader_is_version_token(*pToken
))
1249 FIXME("First token is not a version token, invalid shader.\n");
1252 shader_version
= *pToken
++;
1253 TRACE("%s_%u_%u\n", shader_is_pshader_version(shader_version
) ? "ps": "vs",
1254 WINED3DSHADER_VERSION_MAJOR(shader_version
), WINED3DSHADER_VERSION_MINOR(shader_version
));
1256 while (WINED3DVS_END() != *pToken
)
1258 struct wined3d_shader_instruction ins
;
1259 const char *comment
;
1263 shader_sm1_read_comment(&pToken
, &comment
);
1266 TRACE("//%s\n", comment
);
1270 shader_sm1_read_opcode(&pToken
, &ins
, ¶m_size
, opcode_table
, shader_version
);
1271 if (ins
.handler_idx
== WINED3DSIH_TABLE_SIZE
)
1273 TRACE("Skipping unrecognized instruction.\n");
1274 pToken
+= param_size
;
1278 if (ins
.handler_idx
== WINED3DSIH_DCL
)
1280 struct wined3d_shader_semantic semantic
;
1282 shader_sm1_read_semantic(&pToken
, &semantic
);
1284 shader_dump_decl_usage(&semantic
, shader_version
);
1285 shader_dump_ins_modifiers(&semantic
.reg
);
1287 shader_dump_dst_param(&semantic
.reg
, shader_version
);
1289 else if (ins
.handler_idx
== WINED3DSIH_DEF
)
1291 struct wined3d_shader_dst_param dst
;
1292 struct wined3d_shader_src_param rel_addr
;
1294 shader_sm1_read_dst_param(&pToken
, &dst
, &rel_addr
, shader_version
);
1296 TRACE("def c%u = %f, %f, %f, %f", shader_get_float_offset(dst
.register_type
, dst
.register_idx
),
1297 *(const float *)(pToken
),
1298 *(const float *)(pToken
+ 1),
1299 *(const float *)(pToken
+ 2),
1300 *(const float *)(pToken
+ 3));
1303 else if (ins
.handler_idx
== WINED3DSIH_DEFI
)
1305 struct wined3d_shader_dst_param dst
;
1306 struct wined3d_shader_src_param rel_addr
;
1308 shader_sm1_read_dst_param(&pToken
, &dst
, &rel_addr
, shader_version
);
1310 TRACE("defi i%u = %d, %d, %d, %d", dst
.register_idx
,
1317 else if (ins
.handler_idx
== WINED3DSIH_DEFB
)
1319 struct wined3d_shader_dst_param dst
;
1320 struct wined3d_shader_src_param rel_addr
;
1322 shader_sm1_read_dst_param(&pToken
, &dst
, &rel_addr
, shader_version
);
1324 TRACE("defb b%u = %s", dst
.register_idx
, *pToken
? "true" : "false");
1329 struct wined3d_shader_src_param dst_rel_addr
, src_rel_addr
;
1330 struct wined3d_shader_dst_param dst_param
;
1331 struct wined3d_shader_src_param src_param
;
1335 shader_sm1_read_dst_param(&pToken
, &dst_param
, &dst_rel_addr
, shader_version
);
1338 /* Print out predication source token first - it follows
1339 * the destination token. */
1342 shader_sm1_read_src_param(&pToken
, &src_param
, &src_rel_addr
, shader_version
);
1344 shader_dump_src_param(&src_param
, shader_version
);
1348 /* PixWin marks instructions with the coissue flag with a '+' */
1349 if (ins
.coissue
) TRACE("+");
1351 TRACE("%s", shader_opcode_names
[ins
.handler_idx
]);
1353 if (ins
.handler_idx
== WINED3DSIH_IFC
1354 || ins
.handler_idx
== WINED3DSIH_BREAKC
)
1358 case COMPARISON_GT
: TRACE("_gt"); break;
1359 case COMPARISON_EQ
: TRACE("_eq"); break;
1360 case COMPARISON_GE
: TRACE("_ge"); break;
1361 case COMPARISON_LT
: TRACE("_lt"); break;
1362 case COMPARISON_NE
: TRACE("_ne"); break;
1363 case COMPARISON_LE
: TRACE("_le"); break;
1364 default: TRACE("_(%u)", ins
.flags
);
1367 else if (ins
.handler_idx
== WINED3DSIH_TEX
1368 && shader_version
>= WINED3DPS_VERSION(2,0)
1369 && (ins
.flags
& WINED3DSI_TEXLD_PROJECT
))
1374 /* We already read the destination token, print it. */
1377 shader_dump_ins_modifiers(&dst_param
);
1379 shader_dump_dst_param(&dst_param
, shader_version
);
1382 /* Other source tokens */
1383 for (i
= ins
.dst_count
; i
< (ins
.dst_count
+ ins
.src_count
); ++i
)
1385 shader_sm1_read_src_param(&pToken
, &src_param
, &src_rel_addr
, shader_version
);
1386 TRACE(!i
? " " : ", ");
1387 shader_dump_src_param(&src_param
, shader_version
);
1394 void shader_cleanup(IWineD3DBaseShader
*iface
)
1396 IWineD3DBaseShaderImpl
*This
= (IWineD3DBaseShaderImpl
*)iface
;
1398 ((IWineD3DDeviceImpl
*)This
->baseShader
.device
)->shader_backend
->shader_destroy(iface
);
1399 HeapFree(GetProcessHeap(), 0, This
->baseShader
.function
);
1400 shader_delete_constant_list(&This
->baseShader
.constantsF
);
1401 shader_delete_constant_list(&This
->baseShader
.constantsB
);
1402 shader_delete_constant_list(&This
->baseShader
.constantsI
);
1403 list_remove(&This
->baseShader
.shader_list_entry
);
1406 static const SHADER_HANDLER shader_none_instruction_handler_table
[WINED3DSIH_TABLE_SIZE
] = {0};
1407 static void shader_none_select(IWineD3DDevice
*iface
, BOOL usePS
, BOOL useVS
) {}
1408 static void shader_none_select_depth_blt(IWineD3DDevice
*iface
, enum tex_types tex_type
) {}
1409 static void shader_none_deselect_depth_blt(IWineD3DDevice
*iface
) {}
1410 static void shader_none_update_float_vertex_constants(IWineD3DDevice
*iface
, UINT start
, UINT count
) {}
1411 static void shader_none_update_float_pixel_constants(IWineD3DDevice
*iface
, UINT start
, UINT count
) {}
1412 static void shader_none_load_constants(IWineD3DDevice
*iface
, char usePS
, char useVS
) {}
1413 static void shader_none_load_np2fixup_constants(IWineD3DDevice
*iface
, char usePS
, char useVS
) {}
1414 static void shader_none_destroy(IWineD3DBaseShader
*iface
) {}
1415 static HRESULT
shader_none_alloc(IWineD3DDevice
*iface
) {return WINED3D_OK
;}
1416 static void shader_none_free(IWineD3DDevice
*iface
) {}
1417 static BOOL
shader_none_dirty_const(IWineD3DDevice
*iface
) {return FALSE
;}
1418 static GLuint
shader_none_generate_pshader(IWineD3DPixelShader
*iface
, SHADER_BUFFER
*buffer
, const struct ps_compile_args
*args
) {
1419 FIXME("NONE shader backend asked to generate a pixel shader\n");
1422 static GLuint
shader_none_generate_vshader(IWineD3DVertexShader
*iface
, SHADER_BUFFER
*buffer
, const struct vs_compile_args
*args
) {
1423 FIXME("NONE shader backend asked to generate a vertex shader\n");
1427 #define GLINFO_LOCATION (*gl_info)
1428 static void shader_none_get_caps(WINED3DDEVTYPE devtype
, const WineD3D_GL_Info
*gl_info
, struct shader_caps
*pCaps
)
1430 /* Set the shader caps to 0 for the none shader backend */
1431 pCaps
->VertexShaderVersion
= 0;
1432 pCaps
->PixelShaderVersion
= 0;
1433 pCaps
->PixelShader1xMaxValue
= 0.0;
1435 #undef GLINFO_LOCATION
1436 static BOOL
shader_none_color_fixup_supported(struct color_fixup_desc fixup
)
1438 if (TRACE_ON(d3d_shader
) && TRACE_ON(d3d
))
1440 TRACE("Checking support for fixup:\n");
1441 dump_color_fixup_desc(fixup
);
1444 /* Faked to make some apps happy. */
1445 if (!is_yuv_fixup(fixup
))
1451 TRACE("[FAILED]\n");
1455 const shader_backend_t none_shader_backend
= {
1456 shader_none_instruction_handler_table
,
1458 shader_none_select_depth_blt
,
1459 shader_none_deselect_depth_blt
,
1460 shader_none_update_float_vertex_constants
,
1461 shader_none_update_float_pixel_constants
,
1462 shader_none_load_constants
,
1463 shader_none_load_np2fixup_constants
,
1464 shader_none_destroy
,
1467 shader_none_dirty_const
,
1468 shader_none_generate_pshader
,
1469 shader_none_generate_vshader
,
1470 shader_none_get_caps
,
1471 shader_none_color_fixup_supported
,