?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wined3d: Introduce helper function to get shader type from byte code.
[wine.git] / dlls / wined3d / shader.c
blob8934c4f5d6d382d403b9f3734b3e2c190b488348
1 /*
2 * Copyright 2002-2003 Jason Edmeades
3 * Copyright 2002-2003 Raphael Junqueira
4 * Copyright 2004 Christian Costa
5 * Copyright 2005 Oliver Stieber
6 * Copyright 2006 Ivan Gyurdiev
7 * Copyright 2007-2008, 2013 Stefan Dösinger for CodeWeavers
8 * Copyright 2009-2011 Henri Verbeet for CodeWeavers
9 *
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.
14 *
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.
19 *
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
23 */
24
25 #include "config.h"
26 #include "wine/port.h"
27
28 #include <stdio.h>
29 #include <string.h>
30
31 #include "wined3d_private.h"
32
33 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
34
35 /* pow, mul_high, sub_high, mul_low */
36 const float wined3d_srgb_const0[] = {0.41666f, 1.055f, 0.055f, 12.92f};
37 /* cmp */
38 const float wined3d_srgb_const1[] = {0.0031308f, 0.0f, 0.0f, 0.0f};
39
40 static const char * const shader_opcode_names[] =
41 {
42 /* WINED3DSIH_ABS */ "abs",
43 /* WINED3DSIH_ADD */ "add",
44 /* WINED3DSIH_AND */ "and",
45 /* WINED3DSIH_ATOMIC_AND */ "atomic_and",
46 /* WINED3DSIH_ATOMIC_CMP_STORE */ "atomic_cmp_store",
47 /* WINED3DSIH_ATOMIC_IADD */ "atomic_iadd",
48 /* WINED3DSIH_ATOMIC_IMAX */ "atomic_imax",
49 /* WINED3DSIH_ATOMIC_IMIN */ "atomic_imin",
50 /* WINED3DSIH_ATOMIC_OR */ "atomic_or",
51 /* WINED3DSIH_ATOMIC_UMAX */ "atomic_umax",
52 /* WINED3DSIH_ATOMIC_UMIN */ "atomic_umin",
53 /* WINED3DSIH_ATOMIC_XOR */ "atomic_xor",
54 /* WINED3DSIH_BEM */ "bem",
55 /* WINED3DSIH_BFI */ "bfi",
56 /* WINED3DSIH_BFREV */ "bfrev",
57 /* WINED3DSIH_BREAK */ "break",
58 /* WINED3DSIH_BREAKC */ "breakc",
59 /* WINED3DSIH_BREAKP */ "breakp",
60 /* WINED3DSIH_BUFINFO */ "bufinfo",
61 /* WINED3DSIH_CALL */ "call",
62 /* WINED3DSIH_CALLNZ */ "callnz",
63 /* WINED3DSIH_CASE */ "case",
64 /* WINED3DSIH_CMP */ "cmp",
65 /* WINED3DSIH_CND */ "cnd",
66 /* WINED3DSIH_CONTINUE */ "continue",
67 /* WINED3DSIH_CONTINUEP */ "continuec",
68 /* WINED3DSIH_COUNTBITS */ "countbits",
69 /* WINED3DSIH_CRS */ "crs",
70 /* WINED3DSIH_CUT */ "cut",
71 /* WINED3DSIH_CUT_STREAM */ "cut_stream",
72 /* WINED3DSIH_DCL */ "dcl",
73 /* WINED3DSIH_DCL_CONSTANT_BUFFER */ "dcl_constantBuffer",
74 /* WINED3DSIH_DCL_FUNCTION_BODY */ "dcl_function_body",
75 /* WINED3DSIH_DCL_FUNCTION_TABLE */ "dcl_function_table",
76 /* WINED3DSIH_DCL_GLOBAL_FLAGS */ "dcl_globalFlags",
77 /* WINED3DSIH_DCL_GS_INSTANCES */ "dcl_gs_instances",
78 /* WINED3DSIH_DCL_HS_FORK_PHASE_INSTANCE_COUNT */ "dcl_hs_fork_phase_instance_count",
79 /* WINED3DSIH_DCL_HS_JOIN_PHASE_INSTANCE_COUNT */ "dcl_hs_join_phase_instance_count",
80 /* WINED3DSIH_DCL_HS_MAX_TESSFACTOR */ "dcl_hs_max_tessfactor",
81 /* WINED3DSIH_DCL_IMMEDIATE_CONSTANT_BUFFER */ "dcl_immediateConstantBuffer",
82 /* WINED3DSIH_DCL_INDEX_RANGE */ "dcl_index_range",
83 /* WINED3DSIH_DCL_INDEXABLE_TEMP */ "dcl_indexableTemp",
84 /* WINED3DSIH_DCL_INPUT */ "dcl_input",
85 /* WINED3DSIH_DCL_INPUT_CONTROL_POINT_COUNT */ "dcl_input_control_point_count",
86 /* WINED3DSIH_DCL_INPUT_PRIMITIVE */ "dcl_inputPrimitive",
87 /* WINED3DSIH_DCL_INPUT_PS */ "dcl_input_ps",
88 /* WINED3DSIH_DCL_INPUT_PS_SGV */ "dcl_input_ps_sgv",
89 /* WINED3DSIH_DCL_INPUT_PS_SIV */ "dcl_input_ps_siv",
90 /* WINED3DSIH_DCL_INPUT_SGV */ "dcl_input_sgv",
91 /* WINED3DSIH_DCL_INPUT_SIV */ "dcl_input_siv",
92 /* WINED3DSIH_DCL_INTERFACE */ "dcl_interface",
93 /* WINED3DSIH_DCL_OUTPUT */ "dcl_output",
94 /* WINED3DSIH_DCL_OUTPUT_CONTROL_POINT_COUNT */ "dcl_output_control_point_count",
95 /* WINED3DSIH_DCL_OUTPUT_SIV */ "dcl_output_siv",
96 /* WINED3DSIH_DCL_OUTPUT_TOPOLOGY */ "dcl_outputTopology",
97 /* WINED3DSIH_DCL_RESOURCE_RAW */ "dcl_resource_raw",
98 /* WINED3DSIH_DCL_RESOURCE_STRUCTURED */ "dcl_resource_structured",
99 /* WINED3DSIH_DCL_SAMPLER */ "dcl_sampler",
100 /* WINED3DSIH_DCL_STREAM */ "dcl_stream",
101 /* WINED3DSIH_DCL_TEMPS */ "dcl_temps",
102 /* WINED3DSIH_DCL_TESSELLATOR_DOMAIN */ "dcl_tessellator_domain",
103 /* WINED3DSIH_DCL_TESSELLATOR_OUTPUT_PRIMITIVE */ "dcl_tessellator_output_primitive",
104 /* WINED3DSIH_DCL_TESSELLATOR_PARTITIONING */ "dcl_tessellator_partitioning",
105 /* WINED3DSIH_DCL_TGSM_RAW */ "dcl_tgsm_raw",
106 /* WINED3DSIH_DCL_TGSM_STRUCTURED */ "dcl_tgsm_structured",
107 /* WINED3DSIH_DCL_THREAD_GROUP */ "dcl_thread_group",
108 /* WINED3DSIH_DCL_UAV_RAW */ "dcl_uav_raw",
109 /* WINED3DSIH_DCL_UAV_STRUCTURED */ "dcl_uav_structured",
110 /* WINED3DSIH_DCL_UAV_TYPED */ "dcl_uav_typed",
111 /* WINED3DSIH_DCL_VERTICES_OUT */ "dcl_maxOutputVertexCount",
112 /* WINED3DSIH_DEF */ "def",
113 /* WINED3DSIH_DEFAULT */ "default",
114 /* WINED3DSIH_DEFB */ "defb",
115 /* WINED3DSIH_DEFI */ "defi",
116 /* WINED3DSIH_DIV */ "div",
117 /* WINED3DSIH_DP2 */ "dp2",
118 /* WINED3DSIH_DP2ADD */ "dp2add",
119 /* WINED3DSIH_DP3 */ "dp3",
120 /* WINED3DSIH_DP4 */ "dp4",
121 /* WINED3DSIH_DST */ "dst",
122 /* WINED3DSIH_DSX */ "dsx",
123 /* WINED3DSIH_DSX_COARSE */ "deriv_rtx_coarse",
124 /* WINED3DSIH_DSX_FINE */ "deriv_rtx_fine",
125 /* WINED3DSIH_DSY */ "dsy",
126 /* WINED3DSIH_DSY_COARSE */ "deriv_rty_coarse",
127 /* WINED3DSIH_DSY_FINE */ "deriv_rty_fine",
128 /* WINED3DSIH_EVAL_SAMPLE_INDEX */ "eval_sample_index",
129 /* WINED3DSIH_ELSE */ "else",
130 /* WINED3DSIH_EMIT */ "emit",
131 /* WINED3DSIH_EMIT_STREAM */ "emit_stream",
132 /* WINED3DSIH_ENDIF */ "endif",
133 /* WINED3DSIH_ENDLOOP */ "endloop",
134 /* WINED3DSIH_ENDREP */ "endrep",
135 /* WINED3DSIH_ENDSWITCH */ "endswitch",
136 /* WINED3DSIH_EQ */ "eq",
137 /* WINED3DSIH_EXP */ "exp",
138 /* WINED3DSIH_EXPP */ "expp",
139 /* WINED3DSIH_F16TOF32 */ "f16tof32",
140 /* WINED3DSIH_F32TOF16 */ "f32tof16",
141 /* WINED3DSIH_FCALL */ "fcall",
142 /* WINED3DSIH_FIRSTBIT_HI */ "firstbit_hi",
143 /* WINED3DSIH_FIRSTBIT_LO */ "firstbit_lo",
144 /* WINED3DSIH_FIRSTBIT_SHI */ "firstbit_shi",
145 /* WINED3DSIH_FRC */ "frc",
146 /* WINED3DSIH_FTOI */ "ftoi",
147 /* WINED3DSIH_FTOU */ "ftou",
148 /* WINED3DSIH_GATHER4 */ "gather4",
149 /* WINED3DSIH_GATHER4_C */ "gather4_c",
150 /* WINED3DSIH_GATHER4_PO */ "gather4_po",
151 /* WINED3DSIH_GATHER4_PO_C */ "gather4_po_c",
152 /* WINED3DSIH_GE */ "ge",
153 /* WINED3DSIH_HS_CONTROL_POINT_PHASE */ "hs_control_point_phase",
154 /* WINED3DSIH_HS_DECLS */ "hs_decls",
155 /* WINED3DSIH_HS_FORK_PHASE */ "hs_fork_phase",
156 /* WINED3DSIH_HS_JOIN_PHASE */ "hs_join_phase",
157 /* WINED3DSIH_IADD */ "iadd",
158 /* WINED3DSIH_IBFE */ "ibfe",
159 /* WINED3DSIH_IEQ */ "ieq",
160 /* WINED3DSIH_IF */ "if",
161 /* WINED3DSIH_IFC */ "ifc",
162 /* WINED3DSIH_IGE */ "ige",
163 /* WINED3DSIH_ILT */ "ilt",
164 /* WINED3DSIH_IMAD */ "imad",
165 /* WINED3DSIH_IMAX */ "imax",
166 /* WINED3DSIH_IMIN */ "imin",
167 /* WINED3DSIH_IMM_ATOMIC_ALLOC */ "imm_atomic_alloc",
168 /* WINED3DSIH_IMM_ATOMIC_AND */ "imm_atomic_and",
169 /* WINED3DSIH_IMM_ATOMIC_CMP_EXCH */ "imm_atomic_cmp_exch",
170 /* WINED3DSIH_IMM_ATOMIC_CONSUME */ "imm_atomic_consume",
171 /* WINED3DSIH_IMM_ATOMIC_EXCH */ "imm_atomic_exch",
172 /* WINED3DSIH_IMM_ATOMIC_IADD */ "imm_atomic_iadd",
173 /* WINED3DSIH_IMM_ATOMIC_IMAX */ "imm_atomic_imax",
174 /* WINED3DSIH_IMM_ATOMIC_IMIN */ "imm_atomic_imin",
175 /* WINED3DSIH_IMM_ATOMIC_OR */ "imm_atomic_or",
176 /* WINED3DSIH_IMM_ATOMIC_UMAX */ "imm_atomic_umax",
177 /* WINED3DSIH_IMM_ATOMIC_UMIN */ "imm_atomic_umin",
178 /* WINED3DSIH_IMM_ATOMIC_XOR */ "imm_atomic_xor",
179 /* WINED3DSIH_IMUL */ "imul",
180 /* WINED3DSIH_INE */ "ine",
181 /* WINED3DSIH_INEG */ "ineg",
182 /* WINED3DSIH_ISHL */ "ishl",
183 /* WINED3DSIH_ISHR */ "ishr",
184 /* WINED3DSIH_ITOF */ "itof",
185 /* WINED3DSIH_LABEL */ "label",
186 /* WINED3DSIH_LD */ "ld",
187 /* WINED3DSIH_LD2DMS */ "ld2dms",
188 /* WINED3DSIH_LD_RAW */ "ld_raw",
189 /* WINED3DSIH_LD_STRUCTURED */ "ld_structured",
190 /* WINED3DSIH_LD_UAV_TYPED */ "ld_uav_typed",
191 /* WINED3DSIH_LIT */ "lit",
192 /* WINED3DSIH_LOD */ "lod",
193 /* WINED3DSIH_LOG */ "log",
194 /* WINED3DSIH_LOGP */ "logp",
195 /* WINED3DSIH_LOOP */ "loop",
196 /* WINED3DSIH_LRP */ "lrp",
197 /* WINED3DSIH_LT */ "lt",
198 /* WINED3DSIH_M3x2 */ "m3x2",
199 /* WINED3DSIH_M3x3 */ "m3x3",
200 /* WINED3DSIH_M3x4 */ "m3x4",
201 /* WINED3DSIH_M4x3 */ "m4x3",
202 /* WINED3DSIH_M4x4 */ "m4x4",
203 /* WINED3DSIH_MAD */ "mad",
204 /* WINED3DSIH_MAX */ "max",
205 /* WINED3DSIH_MIN */ "min",
206 /* WINED3DSIH_MOV */ "mov",
207 /* WINED3DSIH_MOVA */ "mova",
208 /* WINED3DSIH_MOVC */ "movc",
209 /* WINED3DSIH_MUL */ "mul",
210 /* WINED3DSIH_NE */ "ne",
211 /* WINED3DSIH_NOP */ "nop",
212 /* WINED3DSIH_NOT */ "not",
213 /* WINED3DSIH_NRM */ "nrm",
214 /* WINED3DSIH_OR */ "or",
215 /* WINED3DSIH_PHASE */ "phase",
216 /* WINED3DSIH_POW */ "pow",
217 /* WINED3DSIH_RCP */ "rcp",
218 /* WINED3DSIH_REP */ "rep",
219 /* WINED3DSIH_RESINFO */ "resinfo",
220 /* WINED3DSIH_RET */ "ret",
221 /* WINED3DSIH_RETP */ "retp",
222 /* WINED3DSIH_ROUND_NE */ "round_ne",
223 /* WINED3DSIH_ROUND_NI */ "round_ni",
224 /* WINED3DSIH_ROUND_PI */ "round_pi",
225 /* WINED3DSIH_ROUND_Z */ "round_z",
226 /* WINED3DSIH_RSQ */ "rsq",
227 /* WINED3DSIH_SAMPLE */ "sample",
228 /* WINED3DSIH_SAMPLE_B */ "sample_b",
229 /* WINED3DSIH_SAMPLE_C */ "sample_c",
230 /* WINED3DSIH_SAMPLE_C_LZ */ "sample_c_lz",
231 /* WINED3DSIH_SAMPLE_GRAD */ "sample_d",
232 /* WINED3DSIH_SAMPLE_INFO */ "sample_info",
233 /* WINED3DSIH_SAMPLE_LOD */ "sample_l",
234 /* WINED3DSIH_SAMPLE_POS */ "sample_pos",
235 /* WINED3DSIH_SETP */ "setp",
236 /* WINED3DSIH_SGE */ "sge",
237 /* WINED3DSIH_SGN */ "sgn",
238 /* WINED3DSIH_SINCOS */ "sincos",
239 /* WINED3DSIH_SLT */ "slt",
240 /* WINED3DSIH_SQRT */ "sqrt",
241 /* WINED3DSIH_STORE_RAW */ "store_raw",
242 /* WINED3DSIH_STORE_STRUCTURED */ "store_structured",
243 /* WINED3DSIH_STORE_UAV_TYPED */ "store_uav_typed",
244 /* WINED3DSIH_SUB */ "sub",
245 /* WINED3DSIH_SWAPC */ "swapc",
246 /* WINED3DSIH_SWITCH */ "switch",
247 /* WINED3DSIH_SYNC */ "sync",
248 /* WINED3DSIH_TEX */ "texld",
249 /* WINED3DSIH_TEXBEM */ "texbem",
250 /* WINED3DSIH_TEXBEML */ "texbeml",
251 /* WINED3DSIH_TEXCOORD */ "texcrd",
252 /* WINED3DSIH_TEXDEPTH */ "texdepth",
253 /* WINED3DSIH_TEXDP3 */ "texdp3",
254 /* WINED3DSIH_TEXDP3TEX */ "texdp3tex",
255 /* WINED3DSIH_TEXKILL */ "texkill",
256 /* WINED3DSIH_TEXLDD */ "texldd",
257 /* WINED3DSIH_TEXLDL */ "texldl",
258 /* WINED3DSIH_TEXM3x2DEPTH */ "texm3x2depth",
259 /* WINED3DSIH_TEXM3x2PAD */ "texm3x2pad",
260 /* WINED3DSIH_TEXM3x2TEX */ "texm3x2tex",
261 /* WINED3DSIH_TEXM3x3 */ "texm3x3",
262 /* WINED3DSIH_TEXM3x3DIFF */ "texm3x3diff",
263 /* WINED3DSIH_TEXM3x3PAD */ "texm3x3pad",
264 /* WINED3DSIH_TEXM3x3SPEC */ "texm3x3spec",
265 /* WINED3DSIH_TEXM3x3TEX */ "texm3x3tex",
266 /* WINED3DSIH_TEXM3x3VSPEC */ "texm3x3vspec",
267 /* WINED3DSIH_TEXREG2AR */ "texreg2ar",
268 /* WINED3DSIH_TEXREG2GB */ "texreg2gb",
269 /* WINED3DSIH_TEXREG2RGB */ "texreg2rgb",
270 /* WINED3DSIH_UBFE */ "ubfe",
271 /* WINED3DSIH_UDIV */ "udiv",
272 /* WINED3DSIH_UGE */ "uge",
273 /* WINED3DSIH_ULT */ "ult",
274 /* WINED3DSIH_UMAX */ "umax",
275 /* WINED3DSIH_UMIN */ "umin",
276 /* WINED3DSIH_UMUL */ "umul",
277 /* WINED3DSIH_USHR */ "ushr",
278 /* WINED3DSIH_UTOF */ "utof",
279 /* WINED3DSIH_XOR */ "xor",
280 };
281
282 static const char * const semantic_names[] =
283 {
284 /* WINED3D_DECL_USAGE_POSITION */ "SV_POSITION",
285 /* WINED3D_DECL_USAGE_BLEND_WEIGHT */ "BLENDWEIGHT",
286 /* WINED3D_DECL_USAGE_BLEND_INDICES */ "BLENDINDICES",
287 /* WINED3D_DECL_USAGE_NORMAL */ "NORMAL",
288 /* WINED3D_DECL_USAGE_PSIZE */ "PSIZE",
289 /* WINED3D_DECL_USAGE_TEXCOORD */ "TEXCOORD",
290 /* WINED3D_DECL_USAGE_TANGENT */ "TANGENT",
291 /* WINED3D_DECL_USAGE_BINORMAL */ "BINORMAL",
292 /* WINED3D_DECL_USAGE_TESS_FACTOR */ "TESSFACTOR",
293 /* WINED3D_DECL_USAGE_POSITIONT */ "POSITIONT",
294 /* WINED3D_DECL_USAGE_COLOR */ "COLOR",
295 /* WINED3D_DECL_USAGE_FOG */ "FOG",
296 /* WINED3D_DECL_USAGE_DEPTH */ "DEPTH",
297 /* WINED3D_DECL_USAGE_SAMPLE */ "SAMPLE",
298 };
299
300 static const struct
301 {
302 enum wined3d_shader_input_sysval_semantic sysval_semantic;
303 const char *sysval_name;
304 }
305 shader_input_sysval_semantic_names[] =
306 {
307 {WINED3D_SIV_POSITION, "position"},
308 {WINED3D_SIV_CLIP_DISTANCE, "clip_distance"},
309 {WINED3D_SIV_CULL_DISTANCE, "cull_distance"},
310 {WINED3D_SIV_RENDER_TARGET_ARRAY_INDEX, "render_target_array_index"},
311 {WINED3D_SIV_VIEWPORT_ARRAY_INDEX, "viewport_array_index"},
312 {WINED3D_SIV_VERTEX_ID, "vertex_id"},
313 {WINED3D_SIV_INSTANCE_ID, "instance_id"},
314 {WINED3D_SIV_PRIMITIVE_ID, "primitive_id"},
315 {WINED3D_SIV_IS_FRONT_FACE, "is_front_face"},
316 {WINED3D_SIV_SAMPLE_INDEX, "sample_index"},
317 {WINED3D_SIV_QUAD_U0_TESS_FACTOR, "finalQuadUeq0EdgeTessFactor"},
318 {WINED3D_SIV_QUAD_V0_TESS_FACTOR, "finalQuadVeq0EdgeTessFactor"},
319 {WINED3D_SIV_QUAD_U1_TESS_FACTOR, "finalQuadUeq1EdgeTessFactor"},
320 {WINED3D_SIV_QUAD_V1_TESS_FACTOR, "finalQuadVeq1EdgeTessFactor"},
321 {WINED3D_SIV_QUAD_U_INNER_TESS_FACTOR, "finalQuadUInsideTessFactor"},
322 {WINED3D_SIV_QUAD_V_INNER_TESS_FACTOR, "finalQuadVInsideTessFactor"},
323 {WINED3D_SIV_TRIANGLE_U_TESS_FACTOR, "finalTriUeq0EdgeTessFactor"},
324 {WINED3D_SIV_TRIANGLE_V_TESS_FACTOR, "finalTriVeq0EdgeTessFactor"},
325 {WINED3D_SIV_TRIANGLE_W_TESS_FACTOR, "finalTriWeq0EdgeTessFactor"},
326 {WINED3D_SIV_TRIANGLE_INNER_TESS_FACTOR, "finalTriInsideTessFactor"},
327 {WINED3D_SIV_LINE_DETAIL_TESS_FACTOR, "finalLineDetailTessFactor"},
328 {WINED3D_SIV_LINE_DENSITY_TESS_FACTOR, "finalLineDensityTessFactor"},
329 };
330
331 static void shader_dump_src_param(struct wined3d_string_buffer *buffer,
332 const struct wined3d_shader_src_param *param, const struct wined3d_shader_version *shader_version);
333
334 const char *debug_d3dshaderinstructionhandler(enum WINED3D_SHADER_INSTRUCTION_HANDLER handler_idx)
335 {
336 if (handler_idx >= ARRAY_SIZE(shader_opcode_names))
337 return wine_dbg_sprintf("UNRECOGNIZED(%#x)", handler_idx);
338
339 return shader_opcode_names[handler_idx];
340 }
341
342 static const char *shader_semantic_name_from_usage(enum wined3d_decl_usage usage)
343 {
344 if (usage >= ARRAY_SIZE(semantic_names))
345 {
346 FIXME("Unrecognized usage %#x.\n", usage);
347 return "UNRECOGNIZED";
348 }
349
350 return semantic_names[usage];
351 }
352
353 static enum wined3d_decl_usage shader_usage_from_semantic_name(const char *name)
354 {
355 unsigned int i;
356
357 for (i = 0; i < ARRAY_SIZE(semantic_names); ++i)
358 {
359 if (!strcmp(name, semantic_names[i]))
360 return i;
361 }
362
363 return ~0U;
364 }
365
366 static enum wined3d_sysval_semantic shader_sysval_semantic_from_usage(enum wined3d_decl_usage usage)
367 {
368 switch (usage)
369 {
370 case WINED3D_DECL_USAGE_POSITION:
371 return WINED3D_SV_POSITION;
372 default:
373 return 0;
374 }
375 }
376
377 BOOL shader_match_semantic(const char *semantic_name, enum wined3d_decl_usage usage)
378 {
379 return !strcmp(semantic_name, shader_semantic_name_from_usage(usage));
380 }
381
382 static void shader_signature_from_semantic(struct wined3d_shader_signature_element *e,
383 const struct wined3d_shader_semantic *s)
384 {
385 e->semantic_name = shader_semantic_name_from_usage(s->usage);
386 e->semantic_idx = s->usage_idx;
387 e->stream_idx = 0;
388 e->sysval_semantic = shader_sysval_semantic_from_usage(s->usage);
389 e->component_type = WINED3D_TYPE_FLOAT;
390 e->register_idx = s->reg.reg.idx[0].offset;
391 e->mask = s->reg.write_mask;
392 }
393
394 static void shader_signature_from_usage(struct wined3d_shader_signature_element *e,
395 enum wined3d_decl_usage usage, UINT usage_idx, UINT reg_idx, DWORD write_mask)
396 {
397 e->semantic_name = shader_semantic_name_from_usage(usage);
398 e->semantic_idx = usage_idx;
399 e->stream_idx = 0;
400 e->sysval_semantic = shader_sysval_semantic_from_usage(usage);
401 e->component_type = WINED3D_TYPE_FLOAT;
402 e->register_idx = reg_idx;
403 e->mask = write_mask;
404 }
405
406 static const struct wined3d_shader_frontend *shader_select_frontend(enum wined3d_shader_byte_code_format format)
407 {
408 switch (format)
409 {
410 case WINED3D_SHADER_BYTE_CODE_FORMAT_SM1:
411 return &sm1_shader_frontend;
412
413 case WINED3D_SHADER_BYTE_CODE_FORMAT_SM4:
414 return &sm4_shader_frontend;
415
416 default:
417 WARN("Invalid byte code format %#x specified.\n", format);
418 return NULL;
419 }
420 }
421
422 static enum wined3d_shader_type shader_get_shader_type(const struct wined3d_shader_desc *desc)
423 {
424 if (desc->format == WINED3D_SHADER_BYTE_CODE_FORMAT_SM4)
425 return wined3d_get_sm4_shader_type(desc->byte_code, desc->byte_code_size);
426
427 FIXME("Could not get shader type for byte code format %#x.\n", desc->format);
428 return WINED3D_SHADER_TYPE_INVALID;
429 }
430
431 void string_buffer_clear(struct wined3d_string_buffer *buffer)
432 {
433 buffer->buffer[0] = '\0';
434 buffer->content_size = 0;
435 }
436
437 BOOL string_buffer_init(struct wined3d_string_buffer *buffer)
438 {
439 buffer->buffer_size = 32;
440 if (!(buffer->buffer = heap_alloc(buffer->buffer_size)))
441 {
442 ERR("Failed to allocate shader buffer memory.\n");
443 return FALSE;
444 }
445
446 string_buffer_clear(buffer);
447 return TRUE;
448 }
449
450 void string_buffer_free(struct wined3d_string_buffer *buffer)
451 {
452 heap_free(buffer->buffer);
453 }
454
455 BOOL string_buffer_resize(struct wined3d_string_buffer *buffer, int rc)
456 {
457 char *new_buffer;
458 unsigned int new_buffer_size = buffer->buffer_size * 2;
459
460 while (rc > 0 && (unsigned int)rc >= new_buffer_size - buffer->content_size)
461 new_buffer_size *= 2;
462 if (!(new_buffer = heap_realloc(buffer->buffer, new_buffer_size)))
463 {
464 ERR("Failed to grow buffer.\n");
465 buffer->buffer[buffer->content_size] = '\0';
466 return FALSE;
467 }
468 buffer->buffer = new_buffer;
469 buffer->buffer_size = new_buffer_size;
470 return TRUE;
471 }
472
473 int shader_vaddline(struct wined3d_string_buffer *buffer, const char *format, va_list args)
474 {
475 unsigned int rem;
476 int rc;
477
478 rem = buffer->buffer_size - buffer->content_size;
479 rc = vsnprintf(&buffer->buffer[buffer->content_size], rem, format, args);
480 if (rc < 0 /* C89 */ || (unsigned int)rc >= rem /* C99 */)
481 return rc;
482
483 buffer->content_size += rc;
484 return 0;
485 }
486
487 int shader_addline(struct wined3d_string_buffer *buffer, const char *format, ...)
488 {
489 va_list args;
490 int ret;
491
492 for (;;)
493 {
494 va_start(args, format);
495 ret = shader_vaddline(buffer, format, args);
496 va_end(args);
497 if (!ret)
498 return ret;
499 if (!string_buffer_resize(buffer, ret))
500 return -1;
501 }
502 }
503
504 struct wined3d_string_buffer *string_buffer_get(struct wined3d_string_buffer_list *list)
505 {
506 struct wined3d_string_buffer *buffer;
507
508 if (list_empty(&list->list))
509 {
510 buffer = heap_alloc(sizeof(*buffer));
511 if (!buffer || !string_buffer_init(buffer))
512 {
513 ERR("Couldn't allocate buffer for temporary string.\n");
514 heap_free(buffer);
515 return NULL;
516 }
517 }
518 else
519 {
520 buffer = LIST_ENTRY(list_head(&list->list), struct wined3d_string_buffer, entry);
521 list_remove(&buffer->entry);
522 }
523 string_buffer_clear(buffer);
524 return buffer;
525 }
526
527 static int string_buffer_vsprintf(struct wined3d_string_buffer *buffer, const char *format, va_list args)
528 {
529 if (!buffer)
530 return 0;
531 string_buffer_clear(buffer);
532 return shader_vaddline(buffer, format, args);
533 }
534
535 void string_buffer_sprintf(struct wined3d_string_buffer *buffer, const char *format, ...)
536 {
537 va_list args;
538 int ret;
539
540 for (;;)
541 {
542 va_start(args, format);
543 ret = string_buffer_vsprintf(buffer, format, args);
544 va_end(args);
545 if (!ret)
546 return;
547 if (!string_buffer_resize(buffer, ret))
548 return;
549 }
550 }
551
552 void string_buffer_release(struct wined3d_string_buffer_list *list, struct wined3d_string_buffer *buffer)
553 {
554 if (!buffer)
555 return;
556 list_add_head(&list->list, &buffer->entry);
557 }
558
559 void string_buffer_list_init(struct wined3d_string_buffer_list *list)
560 {
561 list_init(&list->list);
562 }
563
564 void string_buffer_list_cleanup(struct wined3d_string_buffer_list *list)
565 {
566 struct wined3d_string_buffer *buffer, *buffer_next;
567
568 LIST_FOR_EACH_ENTRY_SAFE(buffer, buffer_next, &list->list, struct wined3d_string_buffer, entry)
569 {
570 string_buffer_free(buffer);
571 heap_free(buffer);
572 }
573 list_init(&list->list);
574 }
575
576 /* Convert floating point offset relative to a register file to an absolute
577 * offset for float constants. */
578 static unsigned int shader_get_float_offset(enum wined3d_shader_register_type register_type, UINT register_idx)
579 {
580 switch (register_type)
581 {
582 case WINED3DSPR_CONST: return register_idx;
583 case WINED3DSPR_CONST2: return 2048 + register_idx;
584 case WINED3DSPR_CONST3: return 4096 + register_idx;
585 case WINED3DSPR_CONST4: return 6144 + register_idx;
586 default:
587 FIXME("Unsupported register type: %u.\n", register_type);
588 return register_idx;
589 }
590 }
591
592 static void shader_delete_constant_list(struct list *clist)
593 {
594 struct wined3d_shader_lconst *constant, *constant_next;
595
596 LIST_FOR_EACH_ENTRY_SAFE(constant, constant_next, clist, struct wined3d_shader_lconst, entry)
597 heap_free(constant);
598 list_init(clist);
599 }
600
601 static void shader_set_limits(struct wined3d_shader *shader)
602 {
603 static const struct limits_entry
604 {
605 unsigned int min_version;
606 unsigned int max_version;
607 struct wined3d_shader_limits limits;
608 }
609 vs_limits[] =
610 {
611 /* min_version, max_version, sampler, constant_int, constant_float, constant_bool, packed_output, packed_input */
612 {WINED3D_SHADER_VERSION(1, 0), WINED3D_SHADER_VERSION(1, 1), { 0, 0, 256, 0, 12, 0}},
613 {WINED3D_SHADER_VERSION(2, 0), WINED3D_SHADER_VERSION(2, 1), { 0, 16, 256, 16, 12, 0}},
614 /* DX10 cards on Windows advertise a D3D9 constant limit of 256
615 * even though they are capable of supporting much more (GL
616 * drivers advertise 1024). d3d9.dll and d3d8.dll clamp the
617 * wined3d-advertised maximum. Clamp the constant limit for <= 3.0
618 * shaders to 256. */
619 {WINED3D_SHADER_VERSION(3, 0), WINED3D_SHADER_VERSION(3, 0), { 4, 16, 256, 16, 12, 0}},
620 {WINED3D_SHADER_VERSION(4, 0), WINED3D_SHADER_VERSION(4, 0), {16, 0, 0, 0, 16, 0}},
621 {WINED3D_SHADER_VERSION(4, 1), WINED3D_SHADER_VERSION(5, 0), {16, 0, 0, 0, 32, 0}},
622 {0}
623 },
624 hs_limits[] =
625 {
626 /* min_version, max_version, sampler, constant_int, constant_float, constant_bool, packed_output, packet_input */
627 {WINED3D_SHADER_VERSION(5, 0), WINED3D_SHADER_VERSION(5, 0), {16, 0, 0, 0, 32, 32}},
628 },
629 ds_limits[] =
630 {
631 /* min_version, max_version, sampler, constant_int, constant_float, constant_bool, packed_output, packet_input */
632 {WINED3D_SHADER_VERSION(5, 0), WINED3D_SHADER_VERSION(5, 0), {16, 0, 0, 0, 32, 32}},
633 },
634 gs_limits[] =
635 {
636 /* min_version, max_version, sampler, constant_int, constant_float, constant_bool, packed_output, packed_input */
637 {WINED3D_SHADER_VERSION(4, 0), WINED3D_SHADER_VERSION(4, 0), {16, 0, 0, 0, 32, 16}},
638 {WINED3D_SHADER_VERSION(4, 1), WINED3D_SHADER_VERSION(5, 0), {16, 0, 0, 0, 32, 32}},
639 {0}
640 },
641 ps_limits[] =
642 {
643 /* min_version, max_version, sampler, constant_int, constant_float, constant_bool, packed_output, packed_input */
644 {WINED3D_SHADER_VERSION(1, 0), WINED3D_SHADER_VERSION(1, 3), { 4, 0, 8, 0, 0, 0}},
645 {WINED3D_SHADER_VERSION(1, 4), WINED3D_SHADER_VERSION(1, 4), { 6, 0, 8, 0, 0, 0}},
646 {WINED3D_SHADER_VERSION(2, 0), WINED3D_SHADER_VERSION(2, 0), {16, 0, 32, 0, 0, 0}},
647 {WINED3D_SHADER_VERSION(2, 1), WINED3D_SHADER_VERSION(2, 1), {16, 16, 32, 16, 0, 0}},
648 {WINED3D_SHADER_VERSION(3, 0), WINED3D_SHADER_VERSION(3, 0), {16, 16, 224, 16, 0, 10}},
649 {WINED3D_SHADER_VERSION(4, 0), WINED3D_SHADER_VERSION(5, 0), {16, 0, 0, 0, 0, 32}},
650 {0}
651 },
652 cs_limits[] =
653 {
654 /* min_version, max_version, sampler, constant_int, constant_float, constant_bool, packed_output, packed_input */
655 {WINED3D_SHADER_VERSION(5, 0), WINED3D_SHADER_VERSION(5, 0), {16, 0, 0, 0, 0, 0}},
656 };
657 const struct limits_entry *limits_array;
658 DWORD shader_version = WINED3D_SHADER_VERSION(shader->reg_maps.shader_version.major,
659 shader->reg_maps.shader_version.minor);
660 int i = 0;
661
662 switch (shader->reg_maps.shader_version.type)
663 {
664 default:
665 FIXME("Unexpected shader type %u found.\n", shader->reg_maps.shader_version.type);
666 /* Fall-through. */
667 case WINED3D_SHADER_TYPE_VERTEX:
668 limits_array = vs_limits;
669 break;
670 case WINED3D_SHADER_TYPE_HULL:
671 limits_array = hs_limits;
672 break;
673 case WINED3D_SHADER_TYPE_DOMAIN:
674 limits_array = ds_limits;
675 break;
676 case WINED3D_SHADER_TYPE_GEOMETRY:
677 limits_array = gs_limits;
678 break;
679 case WINED3D_SHADER_TYPE_PIXEL:
680 limits_array = ps_limits;
681 break;
682 case WINED3D_SHADER_TYPE_COMPUTE:
683 limits_array = cs_limits;
684 break;
685 }
686
687 while (limits_array[i].min_version && limits_array[i].min_version <= shader_version)
688 {
689 if (shader_version <= limits_array[i].max_version)
690 {
691 shader->limits = &limits_array[i].limits;
692 break;
693 }
694 ++i;
695 }
696 if (!shader->limits)
697 {
698 FIXME("Unexpected shader version \"%u.%u\".\n",
699 shader->reg_maps.shader_version.major,
700 shader->reg_maps.shader_version.minor);
701 shader->limits = &limits_array[max(0, i - 1)].limits;
702 }
703 }
704
705 static BOOL shader_record_register_usage(struct wined3d_shader *shader, struct wined3d_shader_reg_maps *reg_maps,
706 const struct wined3d_shader_register *reg, enum wined3d_shader_type shader_type, unsigned int constf_size)
707 {
708 switch (reg->type)
709 {
710 case WINED3DSPR_TEXTURE: /* WINED3DSPR_ADDR */
711 if (shader_type == WINED3D_SHADER_TYPE_PIXEL)
712 reg_maps->texcoord |= 1u << reg->idx[0].offset;
713 else
714 reg_maps->address |= 1u << reg->idx[0].offset;
715 break;
716
717 case WINED3DSPR_TEMP:
718 reg_maps->temporary |= 1u << reg->idx[0].offset;
719 break;
720
721 case WINED3DSPR_INPUT:
722 if (reg->idx[0].rel_addr)
723 reg_maps->input_rel_addressing = 1;
724 if (shader_type == WINED3D_SHADER_TYPE_PIXEL)
725 {
726 /* If relative addressing is used, we must assume that all
727 * registers are used. Even if it is a construct like v3[aL],
728 * we can't assume that v0, v1 and v2 aren't read because aL
729 * can be negative. */
730 if (reg->idx[0].rel_addr)
731 shader->u.ps.input_reg_used = ~0u;
732 else
733 shader->u.ps.input_reg_used |= 1u << reg->idx[0].offset;
734 }
735 else
736 {
737 reg_maps->input_registers |= 1u << reg->idx[0].offset;
738 }
739 break;
740
741 case WINED3DSPR_RASTOUT:
742 if (reg->idx[0].offset == 1)
743 reg_maps->fog = 1;
744 if (reg->idx[0].offset == 2)
745 reg_maps->point_size = 1;
746 break;
747
748 case WINED3DSPR_MISCTYPE:
749 if (shader_type == WINED3D_SHADER_TYPE_PIXEL)
750 {
751 if (!reg->idx[0].offset)
752 reg_maps->vpos = 1;
753 else if (reg->idx[0].offset == 1)
754 reg_maps->usesfacing = 1;
755 }
756 break;
757
758 case WINED3DSPR_CONST:
759 if (reg->idx[0].rel_addr)
760 {
761 if (reg->idx[0].offset < reg_maps->min_rel_offset)
762 reg_maps->min_rel_offset = reg->idx[0].offset;
763 if (reg->idx[0].offset > reg_maps->max_rel_offset)
764 reg_maps->max_rel_offset = reg->idx[0].offset;
765 reg_maps->usesrelconstF = TRUE;
766 }
767 else
768 {
769 if (reg->idx[0].offset >= min(shader->limits->constant_float, constf_size))
770 {
771 WARN("Shader using float constant %u which is not supported.\n", reg->idx[0].offset);
772 return FALSE;
773 }
774 else
775 {
776 wined3d_insert_bits(reg_maps->constf, reg->idx[0].offset, 1, 0x1);
777 }
778 }
779 break;
780
781 case WINED3DSPR_CONSTINT:
782 if (reg->idx[0].offset >= shader->limits->constant_int)
783 {
784 WARN("Shader using integer constant %u which is not supported.\n", reg->idx[0].offset);
785 return FALSE;
786 }
787 else
788 {
789 reg_maps->integer_constants |= (1u << reg->idx[0].offset);
790 }
791 break;
792
793 case WINED3DSPR_CONSTBOOL:
794 if (reg->idx[0].offset >= shader->limits->constant_bool)
795 {
796 WARN("Shader using bool constant %u which is not supported.\n", reg->idx[0].offset);
797 return FALSE;
798 }
799 else
800 {
801 reg_maps->boolean_constants |= (1u << reg->idx[0].offset);
802 }
803 break;
804
805 case WINED3DSPR_COLOROUT:
806 reg_maps->rt_mask |= (1u << reg->idx[0].offset);
807 break;
808
809 case WINED3DSPR_OUTCONTROLPOINT:
810 reg_maps->vocp = 1;
811 break;
812
813 default:
814 TRACE("Not recording register of type %#x and [%#x][%#x].\n",
815 reg->type, reg->idx[0].offset, reg->idx[1].offset);
816 break;
817 }
818 return TRUE;
819 }
820
821 static void shader_record_sample(struct wined3d_shader_reg_maps *reg_maps,
822 unsigned int resource_idx, unsigned int sampler_idx, unsigned int bind_idx)
823 {
824 struct wined3d_shader_sampler_map_entry *entries, *entry;
825 struct wined3d_shader_sampler_map *map;
826 unsigned int i;
827
828 map = &reg_maps->sampler_map;
829 entries = map->entries;
830 for (i = 0; i < map->count; ++i)
831 {
832 if (entries[i].resource_idx == resource_idx && entries[i].sampler_idx == sampler_idx)
833 return;
834 }
835
836 if (!map->size)
837 {
838 if (!(entries = heap_calloc(4, sizeof(*entries))))
839 {
840 ERR("Failed to allocate sampler map entries.\n");
841 return;
842 }
843 map->size = 4;
844 map->entries = entries;
845 }
846 else if (map->count == map->size)
847 {
848 size_t new_size = map->size * 2;
849
850 if (sizeof(*entries) * new_size <= sizeof(*entries) * map->size
851 || !(entries = heap_realloc(entries, sizeof(*entries) * new_size)))
852 {
853 ERR("Failed to resize sampler map entries.\n");
854 return;
855 }
856 map->size = new_size;
857 map->entries = entries;
858 }
859
860 entry = &entries[map->count++];
861 entry->resource_idx = resource_idx;
862 entry->sampler_idx = sampler_idx;
863 entry->bind_idx = bind_idx;
864 }
865
866 static unsigned int get_instr_extra_regcount(enum WINED3D_SHADER_INSTRUCTION_HANDLER instr, unsigned int param)
867 {
868 switch (instr)
869 {
870 case WINED3DSIH_M4x4:
871 case WINED3DSIH_M3x4:
872 return param == 1 ? 3 : 0;
873
874 case WINED3DSIH_M4x3:
875 case WINED3DSIH_M3x3:
876 return param == 1 ? 2 : 0;
877
878 case WINED3DSIH_M3x2:
879 return param == 1 ? 1 : 0;
880
881 default:
882 return 0;
883 }
884 }
885
886 static HRESULT shader_reg_maps_add_tgsm(struct wined3d_shader_reg_maps *reg_maps,
887 unsigned int register_idx, unsigned int size, unsigned int stride)
888 {
889 struct wined3d_shader_tgsm *tgsm;
890
891 if (register_idx >= MAX_TGSM_REGISTERS)
892 {
893 ERR("Invalid TGSM register index %u.\n", register_idx);
894 return S_OK;
895 }
896 if (reg_maps->shader_version.type != WINED3D_SHADER_TYPE_COMPUTE)
897 {
898 FIXME("TGSM declarations are allowed only in compute shaders.\n");
899 return S_OK;
900 }
901
902 if (!wined3d_array_reserve((void **)&reg_maps->tgsm, &reg_maps->tgsm_capacity,
903 register_idx + 1, sizeof(*reg_maps->tgsm)))
904 return E_OUTOFMEMORY;
905
906 reg_maps->tgsm_count = max(register_idx + 1, reg_maps->tgsm_count);
907 tgsm = &reg_maps->tgsm[register_idx];
908 tgsm->size = size;
909 tgsm->stride = stride;
910 return S_OK;
911 }
912
913 static HRESULT shader_record_shader_phase(struct wined3d_shader *shader,
914 struct wined3d_shader_phase **current_phase, const struct wined3d_shader_instruction *ins,
915 const DWORD *current_instruction_ptr, const DWORD *previous_instruction_ptr)
916 {
917 struct wined3d_shader_phase *phase;
918
919 if ((phase = *current_phase))
920 {
921 phase->end = previous_instruction_ptr;
922 *current_phase = NULL;
923 }
924
925 if (shader->reg_maps.shader_version.type != WINED3D_SHADER_TYPE_HULL)
926 {
927 ERR("Unexpected shader type %#x.\n", shader->reg_maps.shader_version.type);
928 return E_FAIL;
929 }
930
931 switch (ins->handler_idx)
932 {
933 case WINED3DSIH_HS_CONTROL_POINT_PHASE:
934 if (shader->u.hs.phases.control_point)
935 {
936 FIXME("Multiple control point phases.\n");
937 heap_free(shader->u.hs.phases.control_point);
938 }
939 if (!(shader->u.hs.phases.control_point = heap_alloc_zero(sizeof(*shader->u.hs.phases.control_point))))
940 return E_OUTOFMEMORY;
941 phase = shader->u.hs.phases.control_point;
942 break;
943 case WINED3DSIH_HS_FORK_PHASE:
944 if (!wined3d_array_reserve((void **)&shader->u.hs.phases.fork,
945 &shader->u.hs.phases.fork_size, shader->u.hs.phases.fork_count + 1,
946 sizeof(*shader->u.hs.phases.fork)))
947 return E_OUTOFMEMORY;
948 phase = &shader->u.hs.phases.fork[shader->u.hs.phases.fork_count++];
949 break;
950 case WINED3DSIH_HS_JOIN_PHASE:
951 if (!wined3d_array_reserve((void **)&shader->u.hs.phases.join,
952 &shader->u.hs.phases.join_size, shader->u.hs.phases.join_count + 1,
953 sizeof(*shader->u.hs.phases.join)))
954 return E_OUTOFMEMORY;
955 phase = &shader->u.hs.phases.join[shader->u.hs.phases.join_count++];
956 break;
957 default:
958 ERR("Unexpected opcode %s.\n", debug_d3dshaderinstructionhandler(ins->handler_idx));
959 return E_FAIL;
960 }
961
962 phase->start = current_instruction_ptr;
963 *current_phase = phase;
964
965 return WINED3D_OK;
966 }
967
968 static HRESULT shader_calculate_clip_or_cull_distance_mask(
969 const struct wined3d_shader_signature_element *e, unsigned int *mask)
970 {
971 /* Clip and cull distances are packed in 4 component registers. 0 and 1 are
972 * the only allowed semantic indices.
973 */
974 if (e->semantic_idx >= MAX_CLIP_DISTANCES / 4)
975 {
976 *mask = 0;
977 WARN("Invalid clip/cull distance index %u.\n", e->semantic_idx);
978 return WINED3DERR_INVALIDCALL;
979 }
980
981 *mask = (e->mask & WINED3DSP_WRITEMASK_ALL) << (4 * e->semantic_idx);
982 return WINED3D_OK;
983 }
984
985 static void wined3d_insert_interpolation_mode(DWORD *packed_interpolation_mode,
986 unsigned int register_idx, enum wined3d_shader_interpolation_mode mode)
987 {
988 if (mode > WINED3DSIM_LINEAR_NOPERSPECTIVE_SAMPLE)
989 FIXME("Unexpected interpolation mode %#x.\n", mode);
990
991 wined3d_insert_bits(packed_interpolation_mode,
992 register_idx * WINED3D_PACKED_INTERPOLATION_BIT_COUNT, WINED3D_PACKED_INTERPOLATION_BIT_COUNT, mode);
993 }
994
995 /* Note that this does not count the loop register as an address register. */
996 static HRESULT shader_get_registers_used(struct wined3d_shader *shader, const struct wined3d_shader_frontend *fe,
997 struct wined3d_shader_reg_maps *reg_maps, struct wined3d_shader_signature *input_signature,
998 struct wined3d_shader_signature *output_signature, DWORD constf_size)
999 {
1000 struct wined3d_shader_signature_element input_signature_elements[max(MAX_ATTRIBS, MAX_REG_INPUT)];
1001 struct wined3d_shader_signature_element output_signature_elements[MAX_REG_OUTPUT];
1002 unsigned int cur_loop_depth = 0, max_loop_depth = 0;
1003 struct wined3d_shader_version shader_version;
1004 struct wined3d_shader_phase *phase = NULL;
1005 const DWORD *ptr, *prev_ins, *current_ins;
1006 void *fe_data = shader->frontend_data;
1007 unsigned int i;
1008 HRESULT hr;
1009
1010 memset(reg_maps, 0, sizeof(*reg_maps));
1011 memset(input_signature_elements, 0, sizeof(input_signature_elements));
1012 memset(output_signature_elements, 0, sizeof(output_signature_elements));
1013 reg_maps->min_rel_offset = ~0U;
1014 list_init(&reg_maps->indexable_temps);
1015
1016 fe->shader_read_header(fe_data, &ptr, &shader_version);
1017 prev_ins = current_ins = ptr;
1018 reg_maps->shader_version = shader_version;
1019
1020 shader_set_limits(shader);
1021
1022 if (!(reg_maps->constf = heap_calloc(((min(shader->limits->constant_float, constf_size) + 31) / 32),
1023 sizeof(*reg_maps->constf))))
1024 {
1025 ERR("Failed to allocate constant map memory.\n");
1026 return E_OUTOFMEMORY;
1027 }
1028
1029 while (!fe->shader_is_end(fe_data, &ptr))
1030 {
1031 struct wined3d_shader_instruction ins;
1032
1033 current_ins = ptr;
1034 /* Fetch opcode. */
1035 fe->shader_read_instruction(fe_data, &ptr, &ins);
1036
1037 /* Unhandled opcode, and its parameters. */
1038 if (ins.handler_idx == WINED3DSIH_TABLE_SIZE)
1039 {
1040 WARN("Encountered unrecognised or invalid instruction.\n");
1041 return WINED3DERR_INVALIDCALL;
1042 }
1043
1044 /* Handle declarations. */
1045 if (ins.handler_idx == WINED3DSIH_DCL
1046 || ins.handler_idx == WINED3DSIH_DCL_UAV_TYPED)
1047 {
1048 struct wined3d_shader_semantic *semantic = &ins.declaration.semantic;
1049 unsigned int reg_idx = semantic->reg.reg.idx[0].offset;
1050
1051 switch (semantic->reg.reg.type)
1052 {
1053 /* Mark input registers used. */
1054 case WINED3DSPR_INPUT:
1055 if (reg_idx >= MAX_REG_INPUT)
1056 {
1057 ERR("Invalid input register index %u.\n", reg_idx);
1058 break;
1059 }
1060 if (shader_version.type == WINED3D_SHADER_TYPE_PIXEL && shader_version.major == 3
1061 && semantic->usage == WINED3D_DECL_USAGE_POSITION && !semantic->usage_idx)
1062 return WINED3DERR_INVALIDCALL;
1063 reg_maps->input_registers |= 1u << reg_idx;
1064 shader_signature_from_semantic(&input_signature_elements[reg_idx], semantic);
1065 break;
1066
1067 /* Vertex shader: mark 3.0 output registers used, save token. */
1068 case WINED3DSPR_OUTPUT:
1069 if (reg_idx >= MAX_REG_OUTPUT)
1070 {
1071 ERR("Invalid output register index %u.\n", reg_idx);
1072 break;
1073 }
1074 reg_maps->output_registers |= 1u << reg_idx;
1075 shader_signature_from_semantic(&output_signature_elements[reg_idx], semantic);
1076 if (semantic->usage == WINED3D_DECL_USAGE_FOG)
1077 reg_maps->fog = 1;
1078 if (semantic->usage == WINED3D_DECL_USAGE_PSIZE)
1079 reg_maps->point_size = 1;
1080 break;
1081
1082 case WINED3DSPR_SAMPLER:
1083 shader_record_sample(reg_maps, reg_idx, reg_idx, reg_idx);
1084 case WINED3DSPR_RESOURCE:
1085 if (reg_idx >= ARRAY_SIZE(reg_maps->resource_info))
1086 {
1087 ERR("Invalid resource index %u.\n", reg_idx);
1088 break;
1089 }
1090 reg_maps->resource_info[reg_idx].type = semantic->resource_type;
1091 reg_maps->resource_info[reg_idx].data_type = semantic->resource_data_type;
1092 break;
1093
1094 case WINED3DSPR_UAV:
1095 if (reg_idx >= ARRAY_SIZE(reg_maps->uav_resource_info))
1096 {
1097 ERR("Invalid UAV resource index %u.\n", reg_idx);
1098 break;
1099 }
1100 reg_maps->uav_resource_info[reg_idx].type = semantic->resource_type;
1101 reg_maps->uav_resource_info[reg_idx].data_type = semantic->resource_data_type;
1102 if (ins.flags)
1103 FIXME("Ignoring typed UAV flags %#x.\n", ins.flags);
1104 break;
1105
1106 default:
1107 TRACE("Not recording DCL register type %#x.\n", semantic->reg.reg.type);
1108 break;
1109 }
1110 }
1111 else if (ins.handler_idx == WINED3DSIH_DCL_CONSTANT_BUFFER)
1112 {
1113 struct wined3d_shader_register *reg = &ins.declaration.src.reg;
1114 if (reg->idx[0].offset >= WINED3D_MAX_CBS)
1115 ERR("Invalid CB index %u.\n", reg->idx[0].offset);
1116 else
1117 reg_maps->cb_sizes[reg->idx[0].offset] = reg->idx[1].offset;
1118 }
1119 else if (ins.handler_idx == WINED3DSIH_DCL_GLOBAL_FLAGS)
1120 {
1121 if (ins.flags & WINED3DSGF_FORCE_EARLY_DEPTH_STENCIL)
1122 {
1123 if (shader_version.type == WINED3D_SHADER_TYPE_PIXEL)
1124 shader->u.ps.force_early_depth_stencil = TRUE;
1125 else
1126 FIXME("Invalid instruction %#x for shader type %#x.\n",
1127 ins.handler_idx, shader_version.type);
1128 }
1129 else
1130 {
1131 WARN("Ignoring global flags %#x.\n", ins.flags);
1132 }
1133 }
1134 else if (ins.handler_idx == WINED3DSIH_DCL_GS_INSTANCES)
1135 {
1136 if (shader_version.type == WINED3D_SHADER_TYPE_GEOMETRY)
1137 shader->u.gs.instance_count = ins.declaration.count;
1138 else
1139 FIXME("Invalid instruction %#x for shader type %#x.\n",
1140 ins.handler_idx, shader_version.type);
1141 }
1142 else if (ins.handler_idx == WINED3DSIH_DCL_HS_FORK_PHASE_INSTANCE_COUNT
1143 || ins.handler_idx == WINED3DSIH_DCL_HS_JOIN_PHASE_INSTANCE_COUNT)
1144 {
1145 if (phase)
1146 phase->instance_count = ins.declaration.count;
1147 else
1148 FIXME("Instruction %s outside of shader phase.\n",
1149 debug_d3dshaderinstructionhandler(ins.handler_idx));
1150 }
1151 else if (ins.handler_idx == WINED3DSIH_DCL_IMMEDIATE_CONSTANT_BUFFER)
1152 {
1153 if (reg_maps->icb)
1154 FIXME("Multiple immediate constant buffers.\n");
1155 reg_maps->icb = ins.declaration.icb;
1156 }
1157 else if (ins.handler_idx == WINED3DSIH_DCL_INDEXABLE_TEMP)
1158 {
1159 if (phase)
1160 {
1161 FIXME("Indexable temporary registers not supported.\n");
1162 }
1163 else
1164 {
1165 struct wined3d_shader_indexable_temp *reg;
1166
1167 if (!(reg = heap_alloc(sizeof(*reg))))
1168 return E_OUTOFMEMORY;
1169
1170 *reg = ins.declaration.indexable_temp;
1171 list_add_tail(&reg_maps->indexable_temps, &reg->entry);
1172 }
1173 }
1174 else if (ins.handler_idx == WINED3DSIH_DCL_INPUT_PRIMITIVE)
1175 {
1176 if (shader_version.type == WINED3D_SHADER_TYPE_GEOMETRY)
1177 shader->u.gs.input_type = ins.declaration.primitive_type.type;
1178 else
1179 FIXME("Invalid instruction %#x for shader type %#x.\n",
1180 ins.handler_idx, shader_version.type);
1181 }
1182 else if (ins.handler_idx == WINED3DSIH_DCL_INPUT_PS)
1183 {
1184 unsigned int reg_idx = ins.declaration.dst.reg.idx[0].offset;
1185 if (reg_idx >= MAX_REG_INPUT)
1186 {
1187 ERR("Invalid register index %u.\n", reg_idx);
1188 break;
1189 }
1190 if (shader_version.type == WINED3D_SHADER_TYPE_PIXEL)
1191 wined3d_insert_interpolation_mode(shader->u.ps.interpolation_mode, reg_idx, ins.flags);
1192 else
1193 FIXME("Invalid instruction %#x for shader type %#x.\n",
1194 ins.handler_idx, shader_version.type);
1195 }
1196 else if (ins.handler_idx == WINED3DSIH_DCL_OUTPUT)
1197 {
1198 if (ins.declaration.dst.reg.type == WINED3DSPR_DEPTHOUT
1199 || ins.declaration.dst.reg.type == WINED3DSPR_DEPTHOUTGE
1200 || ins.declaration.dst.reg.type == WINED3DSPR_DEPTHOUTLE)
1201 {
1202 if (shader_version.type == WINED3D_SHADER_TYPE_PIXEL)
1203 shader->u.ps.depth_output = ins.declaration.dst.reg.type;
1204 else
1205 FIXME("Invalid instruction %#x for shader type %#x.\n",
1206 ins.handler_idx, shader_version.type);
1207 }
1208 }
1209 else if (ins.handler_idx == WINED3DSIH_DCL_OUTPUT_CONTROL_POINT_COUNT)
1210 {
1211 if (shader_version.type == WINED3D_SHADER_TYPE_HULL)
1212 shader->u.hs.output_vertex_count = ins.declaration.count;
1213 else
1214 FIXME("Invalid instruction %#x for shader type %#x.\n", ins.handler_idx, shader_version.type);
1215 }
1216 else if (ins.handler_idx == WINED3DSIH_DCL_OUTPUT_TOPOLOGY)
1217 {
1218 if (shader_version.type == WINED3D_SHADER_TYPE_GEOMETRY)
1219 shader->u.gs.output_type = ins.declaration.primitive_type.type;
1220 else
1221 FIXME("Invalid instruction %#x for shader type %#x.\n",
1222 ins.handler_idx, shader_version.type);
1223 }
1224 else if (ins.handler_idx == WINED3DSIH_DCL_RESOURCE_RAW)
1225 {
1226 unsigned int reg_idx = ins.declaration.dst.reg.idx[0].offset;
1227 if (reg_idx >= ARRAY_SIZE(reg_maps->resource_info))
1228 {
1229 ERR("Invalid resource index %u.\n", reg_idx);
1230 break;
1231 }
1232 reg_maps->resource_info[reg_idx].type = WINED3D_SHADER_RESOURCE_BUFFER;
1233 reg_maps->resource_info[reg_idx].data_type = WINED3D_DATA_UINT;
1234 reg_maps->resource_info[reg_idx].flags = WINED3D_VIEW_BUFFER_RAW;
1235 }
1236 else if (ins.handler_idx == WINED3DSIH_DCL_RESOURCE_STRUCTURED)
1237 {
1238 unsigned int reg_idx = ins.declaration.structured_resource.reg.reg.idx[0].offset;
1239 if (reg_idx >= ARRAY_SIZE(reg_maps->resource_info))
1240 {
1241 ERR("Invalid resource index %u.\n", reg_idx);
1242 break;
1243 }
1244 reg_maps->resource_info[reg_idx].type = WINED3D_SHADER_RESOURCE_BUFFER;
1245 reg_maps->resource_info[reg_idx].data_type = WINED3D_DATA_UINT;
1246 reg_maps->resource_info[reg_idx].flags = 0;
1247 reg_maps->resource_info[reg_idx].stride = ins.declaration.structured_resource.byte_stride / 4;
1248 }
1249 else if (ins.handler_idx == WINED3DSIH_DCL_SAMPLER)
1250 {
1251 if (ins.flags & WINED3DSI_SAMPLER_COMPARISON_MODE)
1252 reg_maps->sampler_comparison_mode |= (1u << ins.declaration.dst.reg.idx[0].offset);
1253 }
1254 else if (ins.handler_idx == WINED3DSIH_DCL_TEMPS)
1255 {
1256 if (phase)
1257 phase->temporary_count = ins.declaration.count;
1258 else
1259 reg_maps->temporary_count = ins.declaration.count;
1260 }
1261 else if (ins.handler_idx == WINED3DSIH_DCL_TESSELLATOR_DOMAIN)
1262 {
1263 if (shader_version.type == WINED3D_SHADER_TYPE_DOMAIN)
1264 shader->u.ds.tessellator_domain = ins.declaration.tessellator_domain;
1265 else if (shader_version.type != WINED3D_SHADER_TYPE_HULL)
1266 FIXME("Invalid instruction %#x for shader type %#x.\n", ins.handler_idx, shader_version.type);
1267 }
1268 else if (ins.handler_idx == WINED3DSIH_DCL_TESSELLATOR_OUTPUT_PRIMITIVE)
1269 {
1270 if (shader_version.type == WINED3D_SHADER_TYPE_HULL)
1271 shader->u.hs.tessellator_output_primitive = ins.declaration.tessellator_output_primitive;
1272 else
1273 FIXME("Invalid instruction %#x for shader type %#x.\n", ins.handler_idx, shader_version.type);
1274 }
1275 else if (ins.handler_idx == WINED3DSIH_DCL_TESSELLATOR_PARTITIONING)
1276 {
1277 if (shader_version.type == WINED3D_SHADER_TYPE_HULL)
1278 shader->u.hs.tessellator_partitioning = ins.declaration.tessellator_partitioning;
1279 else
1280 FIXME("Invalid instruction %#x for shader type %#x.\n", ins.handler_idx, shader_version.type);
1281 }
1282 else if (ins.handler_idx == WINED3DSIH_DCL_TGSM_RAW)
1283 {
1284 if (FAILED(hr = shader_reg_maps_add_tgsm(reg_maps, ins.declaration.tgsm_raw.reg.reg.idx[0].offset,
1285 ins.declaration.tgsm_raw.byte_count / 4, 0)))
1286 return hr;
1287 }
1288 else if (ins.handler_idx == WINED3DSIH_DCL_TGSM_STRUCTURED)
1289 {
1290 unsigned int stride = ins.declaration.tgsm_structured.byte_stride / 4;
1291 unsigned int size = stride * ins.declaration.tgsm_structured.structure_count;
1292 if (FAILED(hr = shader_reg_maps_add_tgsm(reg_maps,
1293 ins.declaration.tgsm_structured.reg.reg.idx[0].offset, size, stride)))
1294 return hr;
1295 }
1296 else if (ins.handler_idx == WINED3DSIH_DCL_THREAD_GROUP)
1297 {
1298 if (shader_version.type == WINED3D_SHADER_TYPE_COMPUTE)
1299 {
1300 shader->u.cs.thread_group_size = ins.declaration.thread_group_size;
1301 }
1302 else
1303 {
1304 FIXME("Invalid instruction %#x for shader type %#x.\n",
1305 ins.handler_idx, shader_version.type);
1306 }
1307 }
1308 else if (ins.handler_idx == WINED3DSIH_DCL_UAV_RAW)
1309 {
1310 unsigned int reg_idx = ins.declaration.dst.reg.idx[0].offset;
1311 if (reg_idx >= ARRAY_SIZE(reg_maps->uav_resource_info))
1312 {
1313 ERR("Invalid UAV resource index %u.\n", reg_idx);
1314 break;
1315 }
1316 if (ins.flags)
1317 FIXME("Ignoring raw UAV flags %#x.\n", ins.flags);
1318 reg_maps->uav_resource_info[reg_idx].type = WINED3D_SHADER_RESOURCE_BUFFER;
1319 reg_maps->uav_resource_info[reg_idx].data_type = WINED3D_DATA_UINT;
1320 reg_maps->uav_resource_info[reg_idx].flags = WINED3D_VIEW_BUFFER_RAW;
1321 }
1322 else if (ins.handler_idx == WINED3DSIH_DCL_UAV_STRUCTURED)
1323 {
1324 unsigned int reg_idx = ins.declaration.structured_resource.reg.reg.idx[0].offset;
1325 if (reg_idx >= ARRAY_SIZE(reg_maps->uav_resource_info))
1326 {
1327 ERR("Invalid UAV resource index %u.\n", reg_idx);
1328 break;
1329 }
1330 if (ins.flags)
1331 FIXME("Ignoring structured UAV flags %#x.\n", ins.flags);
1332 reg_maps->uav_resource_info[reg_idx].type = WINED3D_SHADER_RESOURCE_BUFFER;
1333 reg_maps->uav_resource_info[reg_idx].data_type = WINED3D_DATA_UINT;
1334 reg_maps->uav_resource_info[reg_idx].flags = 0;
1335 reg_maps->uav_resource_info[reg_idx].stride = ins.declaration.structured_resource.byte_stride / 4;
1336 }
1337 else if (ins.handler_idx == WINED3DSIH_DCL_VERTICES_OUT)
1338 {
1339 if (shader_version.type == WINED3D_SHADER_TYPE_GEOMETRY)
1340 shader->u.gs.vertices_out = ins.declaration.count;
1341 else
1342 FIXME("Invalid instruction %#x for shader type %#x.\n",
1343 ins.handler_idx, shader_version.type);
1344 }
1345 else if (ins.handler_idx == WINED3DSIH_DEF)
1346 {
1347 struct wined3d_shader_lconst *lconst;
1348 float *value;
1349
1350 if (!(lconst = heap_alloc(sizeof(*lconst))))
1351 return E_OUTOFMEMORY;
1352
1353 lconst->idx = ins.dst[0].reg.idx[0].offset;
1354 memcpy(lconst->value, ins.src[0].reg.u.immconst_data, 4 * sizeof(DWORD));
1355 value = (float *)lconst->value;
1356
1357 /* In pixel shader 1.X shaders, the constants are clamped between [-1;1] */
1358 if (shader_version.major == 1 && shader_version.type == WINED3D_SHADER_TYPE_PIXEL)
1359 {
1360 if (value[0] < -1.0f) value[0] = -1.0f;
1361 else if (value[0] > 1.0f) value[0] = 1.0f;
1362 if (value[1] < -1.0f) value[1] = -1.0f;
1363 else if (value[1] > 1.0f) value[1] = 1.0f;
1364 if (value[2] < -1.0f) value[2] = -1.0f;
1365 else if (value[2] > 1.0f) value[2] = 1.0f;
1366 if (value[3] < -1.0f) value[3] = -1.0f;
1367 else if (value[3] > 1.0f) value[3] = 1.0f;
1368 }
1369
1370 list_add_head(&shader->constantsF, &lconst->entry);
1371
1372 if (isinf(value[0]) || isnan(value[0]) || isinf(value[1]) || isnan(value[1])
1373 || isinf(value[2]) || isnan(value[2]) || isinf(value[3]) || isnan(value[3]))
1374 {
1375 shader->lconst_inf_or_nan = TRUE;
1376 }
1377 }
1378 else if (ins.handler_idx == WINED3DSIH_DEFI)
1379 {
1380 struct wined3d_shader_lconst *lconst;
1381
1382 if (!(lconst = heap_alloc(sizeof(*lconst))))
1383 return E_OUTOFMEMORY;
1384
1385 lconst->idx = ins.dst[0].reg.idx[0].offset;
1386 memcpy(lconst->value, ins.src[0].reg.u.immconst_data, 4 * sizeof(DWORD));
1387
1388 list_add_head(&shader->constantsI, &lconst->entry);
1389 reg_maps->local_int_consts |= (1u << lconst->idx);
1390 }
1391 else if (ins.handler_idx == WINED3DSIH_DEFB)
1392 {
1393 struct wined3d_shader_lconst *lconst;
1394
1395 if (!(lconst = heap_alloc(sizeof(*lconst))))
1396 return E_OUTOFMEMORY;
1397
1398 lconst->idx = ins.dst[0].reg.idx[0].offset;
1399 memcpy(lconst->value, ins.src[0].reg.u.immconst_data, sizeof(DWORD));
1400
1401 list_add_head(&shader->constantsB, &lconst->entry);
1402 reg_maps->local_bool_consts |= (1u << lconst->idx);
1403 }
1404 /* Handle shader phases. */
1405 else if (ins.handler_idx == WINED3DSIH_HS_CONTROL_POINT_PHASE
1406 || ins.handler_idx == WINED3DSIH_HS_FORK_PHASE
1407 || ins.handler_idx == WINED3DSIH_HS_JOIN_PHASE)
1408 {
1409 if (FAILED(hr = shader_record_shader_phase(shader, &phase, &ins, current_ins, prev_ins)))
1410 return hr;
1411 }
1412 /* For subroutine prototypes. */
1413 else if (ins.handler_idx == WINED3DSIH_LABEL)
1414 {
1415 reg_maps->labels |= 1u << ins.src[0].reg.idx[0].offset;
1416 }
1417 /* Set texture, address, temporary registers. */
1418 else
1419 {
1420 BOOL color0_mov = FALSE;
1421 unsigned int i;
1422
1423 /* This will loop over all the registers and try to
1424 * make a bitmask of the ones we're interested in.
1425 *
1426 * Relative addressing tokens are ignored, but that's
1427 * okay, since we'll catch any address registers when
1428 * they are initialized (required by spec). */
1429 for (i = 0; i < ins.dst_count; ++i)
1430 {
1431 if (!shader_record_register_usage(shader, reg_maps, &ins.dst[i].reg,
1432 shader_version.type, constf_size))
1433 return WINED3DERR_INVALIDCALL;
1434
1435 if (shader_version.type == WINED3D_SHADER_TYPE_VERTEX)
1436 {
1437 UINT idx = ins.dst[i].reg.idx[0].offset;
1438
1439 switch (ins.dst[i].reg.type)
1440 {
1441 case WINED3DSPR_RASTOUT:
1442 if (shader_version.major >= 3)
1443 break;
1444 switch (idx)
1445 {
1446 case 0: /* oPos */
1447 reg_maps->output_registers |= 1u << 10;
1448 shader_signature_from_usage(&output_signature_elements[10],
1449 WINED3D_DECL_USAGE_POSITION, 0, 10, WINED3DSP_WRITEMASK_ALL);
1450 break;
1451
1452 case 1: /* oFog */
1453 reg_maps->output_registers |= 1u << 11;
1454 shader_signature_from_usage(&output_signature_elements[11],
1455 WINED3D_DECL_USAGE_FOG, 0, 11, WINED3DSP_WRITEMASK_0);
1456 break;
1457
1458 case 2: /* oPts */
1459 reg_maps->output_registers |= 1u << 11;
1460 shader_signature_from_usage(&output_signature_elements[11],
1461 WINED3D_DECL_USAGE_PSIZE, 0, 11, WINED3DSP_WRITEMASK_1);
1462 break;
1463 }
1464 break;
1465
1466 case WINED3DSPR_ATTROUT:
1467 if (shader_version.major >= 3)
1468 break;
1469 if (idx < 2)
1470 {
1471 idx += 8;
1472 if (reg_maps->output_registers & (1u << idx))
1473 {
1474 output_signature_elements[idx].mask |= ins.dst[i].write_mask;
1475 }
1476 else
1477 {
1478 reg_maps->output_registers |= 1u << idx;
1479 shader_signature_from_usage(&output_signature_elements[idx],
1480 WINED3D_DECL_USAGE_COLOR, idx - 8, idx, ins.dst[i].write_mask);
1481 }
1482 }
1483 break;
1484
1485 case WINED3DSPR_TEXCRDOUT: /* WINED3DSPR_OUTPUT */
1486 if (shader_version.major >= 3)
1487 {
1488 if (idx >= ARRAY_SIZE(reg_maps->u.output_registers_mask))
1489 {
1490 WARN("Invalid output register index %u.\n", idx);
1491 break;
1492 }
1493 reg_maps->u.output_registers_mask[idx] |= ins.dst[i].write_mask;
1494 break;
1495 }
1496 if (idx >= ARRAY_SIZE(reg_maps->u.texcoord_mask))
1497 {
1498 WARN("Invalid texcoord index %u.\n", idx);
1499 break;
1500 }
1501 reg_maps->u.texcoord_mask[idx] |= ins.dst[i].write_mask;
1502 if (reg_maps->output_registers & (1u << idx))
1503 {
1504 output_signature_elements[idx].mask |= ins.dst[i].write_mask;
1505 }
1506 else
1507 {
1508 reg_maps->output_registers |= 1u << idx;
1509 shader_signature_from_usage(&output_signature_elements[idx],
1510 WINED3D_DECL_USAGE_TEXCOORD, idx, idx, ins.dst[i].write_mask);
1511 }
1512 break;
1513
1514 default:
1515 break;
1516 }
1517 }
1518
1519 if (shader_version.type == WINED3D_SHADER_TYPE_PIXEL)
1520 {
1521 if (ins.dst[i].reg.type == WINED3DSPR_COLOROUT && !ins.dst[i].reg.idx[0].offset)
1522 {
1523 /* Many 2.0 and 3.0 pixel shaders end with a MOV from a temp register to
1524 * COLOROUT 0. If we know this in advance, the ARB shader backend can skip
1525 * the mov and perform the sRGB write correction from the source register.
1526 *
1527 * However, if the mov is only partial, we can't do this, and if the write
1528 * comes from an instruction other than MOV it is hard to do as well. If
1529 * COLOROUT 0 is overwritten partially later, the marker is dropped again. */
1530 shader->u.ps.color0_mov = FALSE;
1531 if (ins.handler_idx == WINED3DSIH_MOV
1532 && ins.dst[i].write_mask == WINED3DSP_WRITEMASK_ALL)
1533 {
1534 /* Used later when the source register is read. */
1535 color0_mov = TRUE;
1536 }
1537 }
1538 /* Also drop the MOV marker if the source register is overwritten prior to the shader
1539 * end
1540 */
1541 else if (ins.dst[i].reg.type == WINED3DSPR_TEMP
1542 && ins.dst[i].reg.idx[0].offset == shader->u.ps.color0_reg)
1543 {
1544 shader->u.ps.color0_mov = FALSE;
1545 }
1546 }
1547
1548 /* Declare 1.x samplers implicitly, based on the destination reg. number. */
1549 if (shader_version.major == 1
1550 && (ins.handler_idx == WINED3DSIH_TEX
1551 || ins.handler_idx == WINED3DSIH_TEXBEM
1552 || ins.handler_idx == WINED3DSIH_TEXBEML
1553 || ins.handler_idx == WINED3DSIH_TEXDP3TEX
1554 || ins.handler_idx == WINED3DSIH_TEXM3x2TEX
1555 || ins.handler_idx == WINED3DSIH_TEXM3x3SPEC
1556 || ins.handler_idx == WINED3DSIH_TEXM3x3TEX
1557 || ins.handler_idx == WINED3DSIH_TEXM3x3VSPEC
1558 || ins.handler_idx == WINED3DSIH_TEXREG2AR
1559 || ins.handler_idx == WINED3DSIH_TEXREG2GB
1560 || ins.handler_idx == WINED3DSIH_TEXREG2RGB))
1561 {
1562 unsigned int reg_idx = ins.dst[i].reg.idx[0].offset;
1563
1564 if (reg_idx >= ARRAY_SIZE(reg_maps->resource_info))
1565 {
1566 WARN("Invalid 1.x sampler index %u.\n", reg_idx);
1567 continue;
1568 }
1569
1570 TRACE("Setting fake 2D resource for 1.x pixelshader.\n");
1571 reg_maps->resource_info[reg_idx].type = WINED3D_SHADER_RESOURCE_TEXTURE_2D;
1572 reg_maps->resource_info[reg_idx].data_type = WINED3D_DATA_FLOAT;
1573 shader_record_sample(reg_maps, reg_idx, reg_idx, reg_idx);
1574
1575 /* texbem is only valid with < 1.4 pixel shaders */
1576 if (ins.handler_idx == WINED3DSIH_TEXBEM
1577 || ins.handler_idx == WINED3DSIH_TEXBEML)
1578 {
1579 reg_maps->bumpmat |= 1u << reg_idx;
1580 if (ins.handler_idx == WINED3DSIH_TEXBEML)
1581 {
1582 reg_maps->luminanceparams |= 1u << reg_idx;
1583 }
1584 }
1585 }
1586 else if (ins.handler_idx == WINED3DSIH_BEM)
1587 {
1588 reg_maps->bumpmat |= 1u << ins.dst[i].reg.idx[0].offset;
1589 }
1590 }
1591
1592 if (ins.handler_idx == WINED3DSIH_IMM_ATOMIC_ALLOC || ins.handler_idx == WINED3DSIH_IMM_ATOMIC_CONSUME)
1593 {
1594 unsigned int reg_idx = ins.src[0].reg.idx[0].offset;
1595 if (reg_idx >= MAX_UNORDERED_ACCESS_VIEWS)
1596 {
1597 ERR("Invalid UAV index %u.\n", reg_idx);
1598 break;
1599 }
1600 reg_maps->uav_counter_mask |= (1u << reg_idx);
1601 }
1602 else if ((WINED3DSIH_ATOMIC_AND <= ins.handler_idx && ins.handler_idx <= WINED3DSIH_ATOMIC_XOR)
1603 || (WINED3DSIH_IMM_ATOMIC_AND <= ins.handler_idx && ins.handler_idx <= WINED3DSIH_IMM_ATOMIC_XOR)
1604 || (ins.handler_idx == WINED3DSIH_BUFINFO && ins.src[0].reg.type == WINED3DSPR_UAV)
1605 || ins.handler_idx == WINED3DSIH_LD_UAV_TYPED
1606 || (ins.handler_idx == WINED3DSIH_LD_RAW && ins.src[1].reg.type == WINED3DSPR_UAV)
1607 || (ins.handler_idx == WINED3DSIH_LD_STRUCTURED && ins.src[2].reg.type == WINED3DSPR_UAV))
1608 {
1609 unsigned int reg_idx;
1610 if (ins.handler_idx == WINED3DSIH_LD_UAV_TYPED || ins.handler_idx == WINED3DSIH_LD_RAW)
1611 reg_idx = ins.src[1].reg.idx[0].offset;
1612 else if (ins.handler_idx == WINED3DSIH_LD_STRUCTURED)
1613 reg_idx = ins.src[2].reg.idx[0].offset;
1614 else if (WINED3DSIH_ATOMIC_AND <= ins.handler_idx && ins.handler_idx <= WINED3DSIH_ATOMIC_XOR)
1615 reg_idx = ins.dst[0].reg.idx[0].offset;
1616 else if (ins.handler_idx == WINED3DSIH_BUFINFO)
1617 reg_idx = ins.src[0].reg.idx[0].offset;
1618 else
1619 reg_idx = ins.dst[1].reg.idx[0].offset;
1620 if (reg_idx >= MAX_UNORDERED_ACCESS_VIEWS)
1621 {
1622 ERR("Invalid UAV index %u.\n", reg_idx);
1623 break;
1624 }
1625 reg_maps->uav_read_mask |= (1u << reg_idx);
1626 }
1627 else if (ins.handler_idx == WINED3DSIH_NRM)
1628 {
1629 reg_maps->usesnrm = 1;
1630 }
1631 else if (ins.handler_idx == WINED3DSIH_DSY
1632 || ins.handler_idx == WINED3DSIH_DSY_COARSE
1633 || ins.handler_idx == WINED3DSIH_DSY_FINE)
1634 {
1635 reg_maps->usesdsy = 1;
1636 }
1637 else if (ins.handler_idx == WINED3DSIH_DSX
1638 || ins.handler_idx == WINED3DSIH_DSX_COARSE
1639 || ins.handler_idx == WINED3DSIH_DSX_FINE)
1640 {
1641 reg_maps->usesdsx = 1;
1642 }
1643 else if (ins.handler_idx == WINED3DSIH_TEXLDD) reg_maps->usestexldd = 1;
1644 else if (ins.handler_idx == WINED3DSIH_TEXLDL) reg_maps->usestexldl = 1;
1645 else if (ins.handler_idx == WINED3DSIH_MOVA) reg_maps->usesmova = 1;
1646 else if (ins.handler_idx == WINED3DSIH_IFC) reg_maps->usesifc = 1;
1647 else if (ins.handler_idx == WINED3DSIH_CALL) reg_maps->usescall = 1;
1648 else if (ins.handler_idx == WINED3DSIH_POW) reg_maps->usespow = 1;
1649 else if (ins.handler_idx == WINED3DSIH_LOOP
1650 || ins.handler_idx == WINED3DSIH_REP)
1651 {
1652 ++cur_loop_depth;
1653 if (cur_loop_depth > max_loop_depth)
1654 max_loop_depth = cur_loop_depth;
1655 }
1656 else if (ins.handler_idx == WINED3DSIH_ENDLOOP
1657 || ins.handler_idx == WINED3DSIH_ENDREP)
1658 {
1659 --cur_loop_depth;
1660 }
1661 else if (ins.handler_idx == WINED3DSIH_GATHER4
1662 || ins.handler_idx == WINED3DSIH_GATHER4_C
1663 || ins.handler_idx == WINED3DSIH_SAMPLE
1664 || ins.handler_idx == WINED3DSIH_SAMPLE_B
1665 || ins.handler_idx == WINED3DSIH_SAMPLE_C
1666 || ins.handler_idx == WINED3DSIH_SAMPLE_C_LZ
1667 || ins.handler_idx == WINED3DSIH_SAMPLE_GRAD
1668 || ins.handler_idx == WINED3DSIH_SAMPLE_LOD)
1669 {
1670 shader_record_sample(reg_maps, ins.src[1].reg.idx[0].offset,
1671 ins.src[2].reg.idx[0].offset, reg_maps->sampler_map.count);
1672 }
1673 else if (ins.handler_idx == WINED3DSIH_GATHER4_PO
1674 || ins.handler_idx == WINED3DSIH_GATHER4_PO_C)
1675 {
1676 shader_record_sample(reg_maps, ins.src[2].reg.idx[0].offset,
1677 ins.src[3].reg.idx[0].offset, reg_maps->sampler_map.count);
1678 }
1679 else if (ins.handler_idx == WINED3DSIH_BUFINFO && ins.src[0].reg.type == WINED3DSPR_RESOURCE)
1680 {
1681 shader_record_sample(reg_maps, ins.src[0].reg.idx[0].offset,
1682 WINED3D_SAMPLER_DEFAULT, reg_maps->sampler_map.count);
1683 }
1684 else if (ins.handler_idx == WINED3DSIH_LD
1685 || ins.handler_idx == WINED3DSIH_LD2DMS
1686 || (ins.handler_idx == WINED3DSIH_LD_RAW && ins.src[1].reg.type == WINED3DSPR_RESOURCE)
1687 || (ins.handler_idx == WINED3DSIH_RESINFO && ins.src[1].reg.type == WINED3DSPR_RESOURCE))
1688 {
1689 shader_record_sample(reg_maps, ins.src[1].reg.idx[0].offset,
1690 WINED3D_SAMPLER_DEFAULT, reg_maps->sampler_map.count);
1691 }
1692 else if (ins.handler_idx == WINED3DSIH_LD_STRUCTURED
1693 && ins.src[2].reg.type == WINED3DSPR_RESOURCE)
1694 {
1695 shader_record_sample(reg_maps, ins.src[2].reg.idx[0].offset,
1696 WINED3D_SAMPLER_DEFAULT, reg_maps->sampler_map.count);
1697 }
1698
1699 if (ins.predicate)
1700 if (!shader_record_register_usage(shader, reg_maps, &ins.predicate->reg,
1701 shader_version.type, constf_size))
1702 return WINED3DERR_INVALIDCALL;
1703
1704 for (i = 0; i < ins.src_count; ++i)
1705 {
1706 unsigned int count = get_instr_extra_regcount(ins.handler_idx, i);
1707 struct wined3d_shader_register reg = ins.src[i].reg;
1708
1709 if (!shader_record_register_usage(shader, reg_maps, &ins.src[i].reg,
1710 shader_version.type, constf_size))
1711 return WINED3DERR_INVALIDCALL;
1712 while (count)
1713 {
1714 ++reg.idx[0].offset;
1715 if (!shader_record_register_usage(shader, reg_maps, &reg,
1716 shader_version.type, constf_size))
1717 return WINED3DERR_INVALIDCALL;
1718 --count;
1719 }
1720
1721 if (color0_mov)
1722 {
1723 if (ins.src[i].reg.type == WINED3DSPR_TEMP
1724 && ins.src[i].swizzle == WINED3DSP_NOSWIZZLE)
1725 {
1726 shader->u.ps.color0_mov = TRUE;
1727 shader->u.ps.color0_reg = ins.src[i].reg.idx[0].offset;
1728 }
1729 }
1730 }
1731 }
1732
1733 prev_ins = current_ins;
1734 }
1735 reg_maps->loop_depth = max_loop_depth;
1736
1737 if (phase)
1738 {
1739 phase->end = prev_ins;
1740 phase = NULL;
1741 }
1742
1743 /* PS before 2.0 don't have explicit color outputs. Instead the value of
1744 * R0 is written to the render target. */
1745 if (shader_version.major < 2 && shader_version.type == WINED3D_SHADER_TYPE_PIXEL)
1746 reg_maps->rt_mask |= (1u << 0);
1747
1748 if (input_signature->elements)
1749 {
1750 for (i = 0; i < input_signature->element_count; ++i)
1751 {
1752 if (shader_version.type == WINED3D_SHADER_TYPE_VERTEX)
1753 {
1754 if (input_signature->elements[i].register_idx >= ARRAY_SIZE(shader->u.vs.attributes))
1755 {
1756 WARN("Invalid input signature register index %u.\n", input_signature->elements[i].register_idx);
1757 return WINED3DERR_INVALIDCALL;
1758 }
1759 }
1760 else if (shader_version.type == WINED3D_SHADER_TYPE_PIXEL)
1761 {
1762 if (input_signature->elements[i].sysval_semantic == WINED3D_SV_POSITION)
1763 reg_maps->vpos = 1;
1764 else if (input_signature->elements[i].sysval_semantic == WINED3D_SV_IS_FRONT_FACE)
1765 reg_maps->usesfacing = 1;
1766 }
1767 reg_maps->input_registers |= 1u << input_signature->elements[i].register_idx;
1768 }
1769 }
1770 else if (!input_signature->elements && reg_maps->input_registers)
1771 {
1772 unsigned int count = wined3d_popcount(reg_maps->input_registers);
1773 struct wined3d_shader_signature_element *e;
1774 unsigned int i;
1775
1776 if (!(input_signature->elements = heap_calloc(count, sizeof(*input_signature->elements))))
1777 return E_OUTOFMEMORY;
1778 input_signature->element_count = count;
1779
1780 e = input_signature->elements;
1781 for (i = 0; i < ARRAY_SIZE(input_signature_elements); ++i)
1782 {
1783 if (!(reg_maps->input_registers & (1u << i)))
1784 continue;
1785 input_signature_elements[i].register_idx = i;
1786 *e++ = input_signature_elements[i];
1787 }
1788 }
1789
1790 if (output_signature->elements)
1791 {
1792 for (i = 0; i < output_signature->element_count; ++i)
1793 {
1794 const struct wined3d_shader_signature_element *e = &output_signature->elements[i];
1795 unsigned int mask;
1796
1797 reg_maps->output_registers |= 1u << e->register_idx;
1798 if (e->sysval_semantic == WINED3D_SV_CLIP_DISTANCE)
1799 {
1800 if (FAILED(hr = shader_calculate_clip_or_cull_distance_mask(e, &mask)))
1801 return hr;
1802 reg_maps->clip_distance_mask |= mask;
1803 }
1804 else if (e->sysval_semantic == WINED3D_SV_CULL_DISTANCE)
1805 {
1806 if (FAILED(hr = shader_calculate_clip_or_cull_distance_mask(e, &mask)))
1807 return hr;
1808 reg_maps->cull_distance_mask |= mask;
1809 }
1810 }
1811 }
1812 else if (reg_maps->output_registers)
1813 {
1814 unsigned int count = wined3d_popcount(reg_maps->output_registers);
1815 struct wined3d_shader_signature_element *e;
1816
1817 if (!(output_signature->elements = heap_calloc(count, sizeof(*output_signature->elements))))
1818 return E_OUTOFMEMORY;
1819 output_signature->element_count = count;
1820
1821 e = output_signature->elements;
1822 for (i = 0; i < ARRAY_SIZE(output_signature_elements); ++i)
1823 {
1824 if (!(reg_maps->output_registers & (1u << i)))
1825 continue;
1826 *e++ = output_signature_elements[i];
1827 }
1828 }
1829
1830 return WINED3D_OK;
1831 }
1832
1833 static void shader_cleanup_reg_maps(struct wined3d_shader_reg_maps *reg_maps)
1834 {
1835 struct wined3d_shader_indexable_temp *reg, *reg_next;
1836
1837 heap_free(reg_maps->constf);
1838 heap_free(reg_maps->sampler_map.entries);
1839
1840 LIST_FOR_EACH_ENTRY_SAFE(reg, reg_next, &reg_maps->indexable_temps, struct wined3d_shader_indexable_temp, entry)
1841 heap_free(reg);
1842 list_init(&reg_maps->indexable_temps);
1843
1844 heap_free(reg_maps->tgsm);
1845 }
1846
1847 unsigned int shader_find_free_input_register(const struct wined3d_shader_reg_maps *reg_maps, unsigned int max)
1848 {
1849 DWORD map = 1u << max;
1850 map |= map - 1;
1851 map &= reg_maps->shader_version.major < 3 ? ~reg_maps->texcoord : ~reg_maps->input_registers;
1852
1853 return wined3d_log2i(map);
1854 }
1855
1856 static void shader_dump_global_flags(struct wined3d_string_buffer *buffer, DWORD global_flags)
1857 {
1858 if (global_flags & WINED3DSGF_REFACTORING_ALLOWED)
1859 {
1860 shader_addline(buffer, "refactoringAllowed");
1861 global_flags &= ~WINED3DSGF_REFACTORING_ALLOWED;
1862 if (global_flags)
1863 shader_addline(buffer, " | ");
1864 }
1865
1866 if (global_flags & WINED3DSGF_FORCE_EARLY_DEPTH_STENCIL)
1867 {
1868 shader_addline(buffer, "forceEarlyDepthStencil");
1869 global_flags &= ~WINED3DSGF_FORCE_EARLY_DEPTH_STENCIL;
1870 if (global_flags)
1871 shader_addline(buffer, " | ");
1872 }
1873
1874 if (global_flags & WINED3DSGF_ENABLE_RAW_AND_STRUCTURED_BUFFERS)
1875 {
1876 shader_addline(buffer, "enableRawAndStructuredBuffers");
1877 global_flags &= ~WINED3DSGF_ENABLE_RAW_AND_STRUCTURED_BUFFERS;
1878 }
1879
1880 if (global_flags)
1881 shader_addline(buffer, "unknown_flags(%#x)", global_flags);
1882 }
1883
1884 static void shader_dump_sync_flags(struct wined3d_string_buffer *buffer, DWORD sync_flags)
1885 {
1886 if (sync_flags & WINED3DSSF_GROUP_SHARED_MEMORY)
1887 {
1888 shader_addline(buffer, "_g");
1889 sync_flags &= ~WINED3DSSF_GROUP_SHARED_MEMORY;
1890 }
1891 if (sync_flags & WINED3DSSF_THREAD_GROUP)
1892 {
1893 shader_addline(buffer, "_t");
1894 sync_flags &= ~WINED3DSSF_THREAD_GROUP;
1895 }
1896
1897 if (sync_flags)
1898 shader_addline(buffer, "_unknown_flags(%#x)", sync_flags);
1899 }
1900
1901 static void shader_dump_uav_flags(struct wined3d_string_buffer *buffer, DWORD uav_flags)
1902 {
1903 if (uav_flags & WINED3DSUF_GLOBALLY_COHERENT)
1904 {
1905 shader_addline(buffer, "_glc");
1906 uav_flags &= ~WINED3DSUF_GLOBALLY_COHERENT;
1907 }
1908 if (uav_flags & WINED3DSUF_ORDER_PRESERVING_COUNTER)
1909 {
1910 shader_addline(buffer, "_opc");
1911 uav_flags &= ~WINED3DSUF_ORDER_PRESERVING_COUNTER;
1912 }
1913
1914 if (uav_flags)
1915 shader_addline(buffer, "_unknown_flags(%#x)", uav_flags);
1916 }
1917
1918 static void shader_dump_tessellator_domain(struct wined3d_string_buffer *buffer,
1919 enum wined3d_tessellator_domain domain)
1920 {
1921 switch (domain)
1922 {
1923 case WINED3D_TESSELLATOR_DOMAIN_LINE:
1924 shader_addline(buffer, "line");
1925 break;
1926 case WINED3D_TESSELLATOR_DOMAIN_TRIANGLE:
1927 shader_addline(buffer, "triangle");
1928 break;
1929 case WINED3D_TESSELLATOR_DOMAIN_QUAD:
1930 shader_addline(buffer, "quad");
1931 break;
1932 default:
1933 shader_addline(buffer, "unknown_tessellator_domain(%#x)", domain);
1934 break;
1935 }
1936 }
1937
1938 static void shader_dump_tessellator_output_primitive(struct wined3d_string_buffer *buffer,
1939 enum wined3d_tessellator_output_primitive output_primitive)
1940 {
1941 switch (output_primitive)
1942 {
1943 case WINED3D_TESSELLATOR_OUTPUT_POINT:
1944 shader_addline(buffer, "point");
1945 break;
1946 case WINED3D_TESSELLATOR_OUTPUT_LINE:
1947 shader_addline(buffer, "line");
1948 break;
1949 case WINED3D_TESSELLATOR_OUTPUT_TRIANGLE_CW:
1950 shader_addline(buffer, "triangle_cw");
1951 break;
1952 case WINED3D_TESSELLATOR_OUTPUT_TRIANGLE_CCW:
1953 shader_addline(buffer, "triangle_ccw");
1954 break;
1955 default:
1956 shader_addline(buffer, "unknown_tessellator_output_primitive(%#x)", output_primitive);
1957 break;
1958 }
1959 }
1960
1961 static void shader_dump_tessellator_partitioning(struct wined3d_string_buffer *buffer,
1962 enum wined3d_tessellator_partitioning partitioning)
1963 {
1964 switch (partitioning)
1965 {
1966 case WINED3D_TESSELLATOR_PARTITIONING_INTEGER:
1967 shader_addline(buffer, "integer");
1968 break;
1969 case WINED3D_TESSELLATOR_PARTITIONING_POW2:
1970 shader_addline(buffer, "pow2");
1971 break;
1972 case WINED3D_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD:
1973 shader_addline(buffer, "fractional_odd");
1974 break;
1975 case WINED3D_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN:
1976 shader_addline(buffer, "fractional_even");
1977 break;
1978 default:
1979 shader_addline(buffer, "unknown_tessellator_partitioning(%#x)", partitioning);
1980 break;
1981 }
1982 }
1983
1984 static void shader_dump_shader_input_sysval_semantic(struct wined3d_string_buffer *buffer,
1985 enum wined3d_shader_input_sysval_semantic semantic)
1986 {
1987 unsigned int i;
1988
1989 for (i = 0; i < ARRAY_SIZE(shader_input_sysval_semantic_names); ++i)
1990 {
1991 if (shader_input_sysval_semantic_names[i].sysval_semantic == semantic)
1992 {
1993 shader_addline(buffer, "%s", shader_input_sysval_semantic_names[i].sysval_name);
1994 return;
1995 }
1996 }
1997
1998 shader_addline(buffer, "unknown_shader_input_sysval_semantic(%#x)", semantic);
1999 }
2000
2001 static void shader_dump_decl_usage(struct wined3d_string_buffer *buffer,
2002 const struct wined3d_shader_semantic *semantic, unsigned int flags,
2003 const struct wined3d_shader_version *shader_version)
2004 {
2005 shader_addline(buffer, "dcl");
2006
2007 if (semantic->reg.reg.type == WINED3DSPR_SAMPLER)
2008 {
2009 switch (semantic->resource_type)
2010 {
2011 case WINED3D_SHADER_RESOURCE_TEXTURE_2D:
2012 shader_addline(buffer, "_2d");
2013 break;
2014
2015 case WINED3D_SHADER_RESOURCE_TEXTURE_3D:
2016 shader_addline(buffer, "_3d");
2017 break;
2018
2019 case WINED3D_SHADER_RESOURCE_TEXTURE_CUBE:
2020 shader_addline(buffer, "_cube");
2021 break;
2022
2023 default:
2024 shader_addline(buffer, "_unknown_resource_type(%#x)", semantic->resource_type);
2025 break;
2026 }
2027 }
2028 else if (semantic->reg.reg.type == WINED3DSPR_RESOURCE || semantic->reg.reg.type == WINED3DSPR_UAV)
2029 {
2030 if (semantic->reg.reg.type == WINED3DSPR_RESOURCE)
2031 shader_addline(buffer, "_resource_");
2032 else
2033 shader_addline(buffer, "_uav_");
2034 switch (semantic->resource_type)
2035 {
2036 case WINED3D_SHADER_RESOURCE_BUFFER:
2037 shader_addline(buffer, "buffer");
2038 break;
2039
2040 case WINED3D_SHADER_RESOURCE_TEXTURE_1D:
2041 shader_addline(buffer, "texture1d");
2042 break;
2043
2044 case WINED3D_SHADER_RESOURCE_TEXTURE_2D:
2045 shader_addline(buffer, "texture2d");
2046 break;
2047
2048 case WINED3D_SHADER_RESOURCE_TEXTURE_2DMS:
2049 shader_addline(buffer, "texture2dms");
2050 break;
2051
2052 case WINED3D_SHADER_RESOURCE_TEXTURE_3D:
2053 shader_addline(buffer, "texture3d");
2054 break;
2055
2056 case WINED3D_SHADER_RESOURCE_TEXTURE_CUBE:
2057 shader_addline(buffer, "texturecube");
2058 break;
2059
2060 case WINED3D_SHADER_RESOURCE_TEXTURE_1DARRAY:
2061 shader_addline(buffer, "texture1darray");
2062 break;
2063
2064 case WINED3D_SHADER_RESOURCE_TEXTURE_2DARRAY:
2065 shader_addline(buffer, "texture2darray");
2066 break;
2067
2068 case WINED3D_SHADER_RESOURCE_TEXTURE_2DMSARRAY:
2069 shader_addline(buffer, "texture2dmsarray");
2070 break;
2071
2072 case WINED3D_SHADER_RESOURCE_TEXTURE_CUBEARRAY:
2073 shader_addline(buffer, "texturecubearray");
2074 break;
2075
2076 default:
2077 shader_addline(buffer, "unknown");
2078 break;
2079 }
2080 if (semantic->reg.reg.type == WINED3DSPR_UAV)
2081 shader_dump_uav_flags(buffer, flags);
2082 switch (semantic->resource_data_type)
2083 {
2084 case WINED3D_DATA_FLOAT:
2085 shader_addline(buffer, " (float)");
2086 break;
2087
2088 case WINED3D_DATA_INT:
2089 shader_addline(buffer, " (int)");
2090 break;
2091
2092 case WINED3D_DATA_UINT:
2093 shader_addline(buffer, " (uint)");
2094 break;
2095
2096 case WINED3D_DATA_UNORM:
2097 shader_addline(buffer, " (unorm)");
2098 break;
2099
2100 case WINED3D_DATA_SNORM:
2101 shader_addline(buffer, " (snorm)");
2102 break;
2103
2104 default:
2105 shader_addline(buffer, " (unknown)");
2106 break;
2107 }
2108 }
2109 else
2110 {
2111 /* Pixel shaders 3.0 don't have usage semantics. */
2112 if (shader_version->major < 3 && shader_version->type == WINED3D_SHADER_TYPE_PIXEL)
2113 return;
2114 else
2115 shader_addline(buffer, "_");
2116
2117 switch (semantic->usage)
2118 {
2119 case WINED3D_DECL_USAGE_POSITION:
2120 shader_addline(buffer, "position%u", semantic->usage_idx);
2121 break;
2122
2123 case WINED3D_DECL_USAGE_BLEND_INDICES:
2124 shader_addline(buffer, "blend");
2125 break;
2126
2127 case WINED3D_DECL_USAGE_BLEND_WEIGHT:
2128 shader_addline(buffer, "weight");
2129 break;
2130
2131 case WINED3D_DECL_USAGE_NORMAL:
2132 shader_addline(buffer, "normal%u", semantic->usage_idx);
2133 break;
2134
2135 case WINED3D_DECL_USAGE_PSIZE:
2136 shader_addline(buffer, "psize");
2137 break;
2138
2139 case WINED3D_DECL_USAGE_COLOR:
2140 if (!semantic->usage_idx)
2141 shader_addline(buffer, "color");
2142 else
2143 shader_addline(buffer, "specular%u", (semantic->usage_idx - 1));
2144 break;
2145
2146 case WINED3D_DECL_USAGE_TEXCOORD:
2147 shader_addline(buffer, "texture%u", semantic->usage_idx);
2148 break;
2149
2150 case WINED3D_DECL_USAGE_TANGENT:
2151 shader_addline(buffer, "tangent");
2152 break;
2153
2154 case WINED3D_DECL_USAGE_BINORMAL:
2155 shader_addline(buffer, "binormal");
2156 break;
2157
2158 case WINED3D_DECL_USAGE_TESS_FACTOR:
2159 shader_addline(buffer, "tessfactor");
2160 break;
2161
2162 case WINED3D_DECL_USAGE_POSITIONT:
2163 shader_addline(buffer, "positionT%u", semantic->usage_idx);
2164 break;
2165
2166 case WINED3D_DECL_USAGE_FOG:
2167 shader_addline(buffer, "fog");
2168 break;
2169
2170 case WINED3D_DECL_USAGE_DEPTH:
2171 shader_addline(buffer, "depth");
2172 break;
2173
2174 case WINED3D_DECL_USAGE_SAMPLE:
2175 shader_addline(buffer, "sample");
2176 break;
2177
2178 default:
2179 shader_addline(buffer, "<unknown_semantic(%#x)>", semantic->usage);
2180 FIXME("Unrecognised semantic usage %#x.\n", semantic->usage);
2181 }
2182 }
2183 }
2184
2185 static void shader_dump_register(struct wined3d_string_buffer *buffer,
2186 const struct wined3d_shader_register *reg, const struct wined3d_shader_version *shader_version)
2187 {
2188 static const char * const rastout_reg_names[] = {"oPos", "oFog", "oPts"};
2189 static const char * const misctype_reg_names[] = {"vPos", "vFace"};
2190 UINT offset = reg->idx[0].offset;
2191
2192 switch (reg->type)
2193 {
2194 case WINED3DSPR_TEMP:
2195 shader_addline(buffer, "r");
2196 break;
2197
2198 case WINED3DSPR_INPUT:
2199 shader_addline(buffer, "v");
2200 break;
2201
2202 case WINED3DSPR_CONST:
2203 case WINED3DSPR_CONST2:
2204 case WINED3DSPR_CONST3:
2205 case WINED3DSPR_CONST4:
2206 shader_addline(buffer, "c");
2207 offset = shader_get_float_offset(reg->type, offset);
2208 break;
2209
2210 case WINED3DSPR_TEXTURE: /* vs: case WINED3DSPR_ADDR */
2211 shader_addline(buffer, "%c", shader_version->type == WINED3D_SHADER_TYPE_PIXEL ? 't' : 'a');
2212 break;
2213
2214 case WINED3DSPR_RASTOUT:
2215 shader_addline(buffer, "%s", rastout_reg_names[offset]);
2216 break;
2217
2218 case WINED3DSPR_COLOROUT:
2219 shader_addline(buffer, "oC");
2220 break;
2221
2222 case WINED3DSPR_DEPTHOUT:
2223 shader_addline(buffer, "oDepth");
2224 break;
2225
2226 case WINED3DSPR_DEPTHOUTGE:
2227 shader_addline(buffer, "oDepthGE");
2228 break;
2229
2230 case WINED3DSPR_DEPTHOUTLE:
2231 shader_addline(buffer, "oDepthLE");
2232 break;
2233
2234 case WINED3DSPR_ATTROUT:
2235 shader_addline(buffer, "oD");
2236 break;
2237
2238 case WINED3DSPR_TEXCRDOUT:
2239 /* Vertex shaders >= 3.0 use general purpose output registers
2240 * (WINED3DSPR_OUTPUT), which can include an address token. */
2241 if (shader_version->major >= 3)
2242 shader_addline(buffer, "o");
2243 else
2244 shader_addline(buffer, "oT");
2245 break;
2246
2247 case WINED3DSPR_CONSTINT:
2248 shader_addline(buffer, "i");
2249 break;
2250
2251 case WINED3DSPR_CONSTBOOL:
2252 shader_addline(buffer, "b");
2253 break;
2254
2255 case WINED3DSPR_LABEL:
2256 shader_addline(buffer, "l");
2257 break;
2258
2259 case WINED3DSPR_LOOP:
2260 shader_addline(buffer, "aL");
2261 break;
2262
2263 case WINED3DSPR_SAMPLER:
2264 shader_addline(buffer, "s");
2265 break;
2266
2267 case WINED3DSPR_MISCTYPE:
2268 if (offset > 1)
2269 {
2270 FIXME("Unhandled misctype register %u.\n", offset);
2271 shader_addline(buffer, "<unhandled misctype %#x>", offset);
2272 }
2273 else
2274 {
2275 shader_addline(buffer, "%s", misctype_reg_names[offset]);
2276 }
2277 break;
2278
2279 case WINED3DSPR_PREDICATE:
2280 shader_addline(buffer, "p");
2281 break;
2282
2283 case WINED3DSPR_IMMCONST:
2284 shader_addline(buffer, "l");
2285 break;
2286
2287 case WINED3DSPR_CONSTBUFFER:
2288 shader_addline(buffer, "cb");
2289 break;
2290
2291 case WINED3DSPR_IMMCONSTBUFFER:
2292 shader_addline(buffer, "icb");
2293 break;
2294
2295 case WINED3DSPR_PRIMID:
2296 shader_addline(buffer, "primID");
2297 break;
2298
2299 case WINED3DSPR_NULL:
2300 shader_addline(buffer, "null");
2301 break;
2302
2303 case WINED3DSPR_RESOURCE:
2304 shader_addline(buffer, "t");
2305 break;
2306
2307 case WINED3DSPR_UAV:
2308 shader_addline(buffer, "u");
2309 break;
2310
2311 case WINED3DSPR_OUTPOINTID:
2312 shader_addline(buffer, "vOutputControlPointID");
2313 break;
2314
2315 case WINED3DSPR_FORKINSTID:
2316 shader_addline(buffer, "vForkInstanceId");
2317 break;
2318
2319 case WINED3DSPR_JOININSTID:
2320 shader_addline(buffer, "vJoinInstanceId");
2321 break;
2322
2323 case WINED3DSPR_INCONTROLPOINT:
2324 shader_addline(buffer, "vicp");
2325 break;
2326
2327 case WINED3DSPR_OUTCONTROLPOINT:
2328 shader_addline(buffer, "vocp");
2329 break;
2330
2331 case WINED3DSPR_PATCHCONST:
2332 shader_addline(buffer, "vpc");
2333 break;
2334
2335 case WINED3DSPR_TESSCOORD:
2336 shader_addline(buffer, "vDomainLocation");
2337 break;
2338
2339 case WINED3DSPR_GROUPSHAREDMEM:
2340 shader_addline(buffer, "g");
2341 break;
2342
2343 case WINED3DSPR_THREADID:
2344 shader_addline(buffer, "vThreadID");
2345 break;
2346
2347 case WINED3DSPR_THREADGROUPID:
2348 shader_addline(buffer, "vThreadGroupID");
2349 break;
2350
2351 case WINED3DSPR_LOCALTHREADID:
2352 shader_addline(buffer, "vThreadIDInGroup");
2353 break;
2354
2355 case WINED3DSPR_LOCALTHREADINDEX:
2356 shader_addline(buffer, "vThreadIDInGroupFlattened");
2357 break;
2358
2359 case WINED3DSPR_IDXTEMP:
2360 shader_addline(buffer, "x");
2361 break;
2362
2363 case WINED3DSPR_STREAM:
2364 shader_addline(buffer, "m");
2365 break;
2366
2367 case WINED3DSPR_FUNCTIONBODY:
2368 shader_addline(buffer, "fb");
2369 break;
2370
2371 case WINED3DSPR_FUNCTIONPOINTER:
2372 shader_addline(buffer, "fp");
2373 break;
2374
2375 case WINED3DSPR_COVERAGE:
2376 shader_addline(buffer, "vCoverage");
2377 break;
2378
2379 case WINED3DSPR_SAMPLEMASK:
2380 shader_addline(buffer, "oMask");
2381 break;
2382
2383 case WINED3DSPR_GSINSTID:
2384 shader_addline(buffer, "vGSInstanceID");
2385 break;
2386
2387 default:
2388 shader_addline(buffer, "<unhandled_rtype(%#x)>", reg->type);
2389 break;
2390 }
2391
2392 if (reg->type == WINED3DSPR_IMMCONST)
2393 {
2394 shader_addline(buffer, "(");
2395 switch (reg->immconst_type)
2396 {
2397 case WINED3D_IMMCONST_SCALAR:
2398 switch (reg->data_type)
2399 {
2400 case WINED3D_DATA_FLOAT:
2401 shader_addline(buffer, "%.8e", *(const float *)reg->u.immconst_data);
2402 break;
2403 case WINED3D_DATA_INT:
2404 shader_addline(buffer, "%d", reg->u.immconst_data[0]);
2405 break;
2406 case WINED3D_DATA_RESOURCE:
2407 case WINED3D_DATA_SAMPLER:
2408 case WINED3D_DATA_UINT:
2409 shader_addline(buffer, "%u", reg->u.immconst_data[0]);
2410 break;
2411 default:
2412 shader_addline(buffer, "<unhandled data type %#x>", reg->data_type);
2413 break;
2414 }
2415 break;
2416
2417 case WINED3D_IMMCONST_VEC4:
2418 switch (reg->data_type)
2419 {
2420 case WINED3D_DATA_FLOAT:
2421 shader_addline(buffer, "%.8e, %.8e, %.8e, %.8e",
2422 *(const float *)&reg->u.immconst_data[0], *(const float *)&reg->u.immconst_data[1],
2423 *(const float *)&reg->u.immconst_data[2], *(const float *)&reg->u.immconst_data[3]);
2424 break;
2425 case WINED3D_DATA_INT:
2426 shader_addline(buffer, "%d, %d, %d, %d",
2427 reg->u.immconst_data[0], reg->u.immconst_data[1],
2428 reg->u.immconst_data[2], reg->u.immconst_data[3]);
2429 break;
2430 case WINED3D_DATA_RESOURCE:
2431 case WINED3D_DATA_SAMPLER:
2432 case WINED3D_DATA_UINT:
2433 shader_addline(buffer, "%u, %u, %u, %u",
2434 reg->u.immconst_data[0], reg->u.immconst_data[1],
2435 reg->u.immconst_data[2], reg->u.immconst_data[3]);
2436 break;
2437 default:
2438 shader_addline(buffer, "<unhandled data type %#x>", reg->data_type);
2439 break;
2440 }
2441 break;
2442
2443 default:
2444 shader_addline(buffer, "<unhandled immconst_type %#x>", reg->immconst_type);
2445 break;
2446 }
2447 shader_addline(buffer, ")");
2448 }
2449 else if (reg->type != WINED3DSPR_RASTOUT
2450 && reg->type != WINED3DSPR_MISCTYPE
2451 && reg->type != WINED3DSPR_NULL)
2452 {
2453 if (offset != ~0u)
2454 {
2455 shader_addline(buffer, "[");
2456 if (reg->idx[0].rel_addr)
2457 {
2458 shader_dump_src_param(buffer, reg->idx[0].rel_addr, shader_version);
2459 shader_addline(buffer, " + ");
2460 }
2461 shader_addline(buffer, "%u]", offset);
2462
2463 if (reg->idx[1].offset != ~0u)
2464 {
2465 shader_addline(buffer, "[");
2466 if (reg->idx[1].rel_addr)
2467 {
2468 shader_dump_src_param(buffer, reg->idx[1].rel_addr, shader_version);
2469 shader_addline(buffer, " + ");
2470 }
2471 shader_addline(buffer, "%u]", reg->idx[1].offset);
2472 }
2473 }
2474
2475 if (reg->type == WINED3DSPR_FUNCTIONPOINTER)
2476 shader_addline(buffer, "[%u]", reg->u.fp_body_idx);
2477 }
2478 }
2479
2480 static void shader_dump_dst_param(struct wined3d_string_buffer *buffer,
2481 const struct wined3d_shader_dst_param *param, const struct wined3d_shader_version *shader_version)
2482 {
2483 DWORD write_mask = param->write_mask;
2484
2485 shader_dump_register(buffer, &param->reg, shader_version);
2486
2487 if (write_mask && write_mask != WINED3DSP_WRITEMASK_ALL)
2488 {
2489 static const char write_mask_chars[] = "xyzw";
2490
2491 shader_addline(buffer, ".");
2492 if (write_mask & WINED3DSP_WRITEMASK_0)
2493 shader_addline(buffer, "%c", write_mask_chars[0]);
2494 if (write_mask & WINED3DSP_WRITEMASK_1)
2495 shader_addline(buffer, "%c", write_mask_chars[1]);
2496 if (write_mask & WINED3DSP_WRITEMASK_2)
2497 shader_addline(buffer, "%c", write_mask_chars[2]);
2498 if (write_mask & WINED3DSP_WRITEMASK_3)
2499 shader_addline(buffer, "%c", write_mask_chars[3]);
2500 }
2501 }
2502
2503 static void shader_dump_src_param(struct wined3d_string_buffer *buffer,
2504 const struct wined3d_shader_src_param *param, const struct wined3d_shader_version *shader_version)
2505 {
2506 enum wined3d_shader_src_modifier src_modifier = param->modifiers;
2507 DWORD swizzle = param->swizzle;
2508
2509 if (src_modifier == WINED3DSPSM_NEG
2510 || src_modifier == WINED3DSPSM_BIASNEG
2511 || src_modifier == WINED3DSPSM_SIGNNEG
2512 || src_modifier == WINED3DSPSM_X2NEG
2513 || src_modifier == WINED3DSPSM_ABSNEG)
2514 shader_addline(buffer, "-");
2515 else if (src_modifier == WINED3DSPSM_COMP)
2516 shader_addline(buffer, "1-");
2517 else if (src_modifier == WINED3DSPSM_NOT)
2518 shader_addline(buffer, "!");
2519
2520 if (src_modifier == WINED3DSPSM_ABS || src_modifier == WINED3DSPSM_ABSNEG)
2521 shader_addline(buffer, "abs(");
2522
2523 shader_dump_register(buffer, &param->reg, shader_version);
2524
2525 switch (src_modifier)
2526 {
2527 case WINED3DSPSM_NONE: break;
2528 case WINED3DSPSM_NEG: break;
2529 case WINED3DSPSM_NOT: break;
2530 case WINED3DSPSM_BIAS: shader_addline(buffer, "_bias"); break;
2531 case WINED3DSPSM_BIASNEG: shader_addline(buffer, "_bias"); break;
2532 case WINED3DSPSM_SIGN: shader_addline(buffer, "_bx2"); break;
2533 case WINED3DSPSM_SIGNNEG: shader_addline(buffer, "_bx2"); break;
2534 case WINED3DSPSM_COMP: break;
2535 case WINED3DSPSM_X2: shader_addline(buffer, "_x2"); break;
2536 case WINED3DSPSM_X2NEG: shader_addline(buffer, "_x2"); break;
2537 case WINED3DSPSM_DZ: shader_addline(buffer, "_dz"); break;
2538 case WINED3DSPSM_DW: shader_addline(buffer, "_dw"); break;
2539 case WINED3DSPSM_ABSNEG: shader_addline(buffer, ")"); break;
2540 case WINED3DSPSM_ABS: shader_addline(buffer, ")"); break;
2541 default: shader_addline(buffer, "_unknown_modifier(%#x)", src_modifier);
2542 }
2543
2544 if (swizzle != WINED3DSP_NOSWIZZLE)
2545 {
2546 static const char swizzle_chars[] = "xyzw";
2547 DWORD swizzle_x = swizzle & 0x03;
2548 DWORD swizzle_y = (swizzle >> 2) & 0x03;
2549 DWORD swizzle_z = (swizzle >> 4) & 0x03;
2550 DWORD swizzle_w = (swizzle >> 6) & 0x03;
2551
2552 if (swizzle_x == swizzle_y
2553 && swizzle_x == swizzle_z
2554 && swizzle_x == swizzle_w)
2555 {
2556 shader_addline(buffer, ".%c", swizzle_chars[swizzle_x]);
2557 }
2558 else
2559 {
2560 shader_addline(buffer, ".%c%c%c%c", swizzle_chars[swizzle_x], swizzle_chars[swizzle_y],
2561 swizzle_chars[swizzle_z], swizzle_chars[swizzle_w]);
2562 }
2563 }
2564 }
2565
2566 /* Shared code in order to generate the bulk of the shader string. */
2567 HRESULT shader_generate_code(const struct wined3d_shader *shader, struct wined3d_string_buffer *buffer,
2568 const struct wined3d_shader_reg_maps *reg_maps, void *backend_ctx,
2569 const DWORD *start, const DWORD *end)
2570 {
2571 struct wined3d_device *device = shader->device;
2572 const struct wined3d_shader_frontend *fe = shader->frontend;
2573 void *fe_data = shader->frontend_data;
2574 struct wined3d_shader_version shader_version;
2575 struct wined3d_shader_parser_state state;
2576 struct wined3d_shader_instruction ins;
2577 struct wined3d_shader_tex_mx tex_mx;
2578 struct wined3d_shader_context ctx;
2579 const DWORD *ptr;
2580
2581 /* Initialize current parsing state. */
2582 tex_mx.current_row = 0;
2583 state.current_loop_depth = 0;
2584 state.current_loop_reg = 0;
2585 state.in_subroutine = FALSE;
2586
2587 ctx.shader = shader;
2588 ctx.gl_info = &device->adapter->gl_info;
2589 ctx.reg_maps = reg_maps;
2590 ctx.buffer = buffer;
2591 ctx.tex_mx = &tex_mx;
2592 ctx.state = &state;
2593 ctx.backend_data = backend_ctx;
2594 ins.ctx = &ctx;
2595
2596 fe->shader_read_header(fe_data, &ptr, &shader_version);
2597 if (start)
2598 ptr = start;
2599
2600 while (!fe->shader_is_end(fe_data, &ptr) && ptr != end)
2601 {
2602 /* Read opcode. */
2603 fe->shader_read_instruction(fe_data, &ptr, &ins);
2604
2605 /* Unknown opcode and its parameters. */
2606 if (ins.handler_idx == WINED3DSIH_TABLE_SIZE)
2607 {
2608 WARN("Encountered unrecognised or invalid instruction.\n");
2609 return WINED3DERR_INVALIDCALL;
2610 }
2611
2612 if (ins.predicate)
2613 FIXME("Predicates not implemented.\n");
2614
2615 /* Call appropriate function for output target */
2616 device->shader_backend->shader_handle_instruction(&ins);
2617 }
2618
2619 return WINED3D_OK;
2620 }
2621
2622 static void shader_dump_ins_modifiers(struct wined3d_string_buffer *buffer,
2623 const struct wined3d_shader_dst_param *dst)
2624 {
2625 DWORD mmask = dst->modifiers;
2626
2627 switch (dst->shift)
2628 {
2629 case 0: break;
2630 case 13: shader_addline(buffer, "_d8"); break;
2631 case 14: shader_addline(buffer, "_d4"); break;
2632 case 15: shader_addline(buffer, "_d2"); break;
2633 case 1: shader_addline(buffer, "_x2"); break;
2634 case 2: shader_addline(buffer, "_x4"); break;
2635 case 3: shader_addline(buffer, "_x8"); break;
2636 default: shader_addline(buffer, "_unhandled_shift(%d)", dst->shift); break;
2637 }
2638
2639 if (mmask & WINED3DSPDM_SATURATE) shader_addline(buffer, "_sat");
2640 if (mmask & WINED3DSPDM_PARTIALPRECISION) shader_addline(buffer, "_pp");
2641 if (mmask & WINED3DSPDM_MSAMPCENTROID) shader_addline(buffer, "_centroid");
2642
2643 mmask &= ~(WINED3DSPDM_SATURATE | WINED3DSPDM_PARTIALPRECISION | WINED3DSPDM_MSAMPCENTROID);
2644 if (mmask) FIXME("Unrecognised modifier %#x.\n", mmask);
2645 }
2646
2647 static void shader_dump_primitive_type(struct wined3d_string_buffer *buffer,
2648 const struct wined3d_shader_primitive_type *primitive_type)
2649 {
2650 switch (primitive_type->type)
2651 {
2652 case WINED3D_PT_UNDEFINED:
2653 shader_addline(buffer, "undefined");
2654 break;
2655 case WINED3D_PT_POINTLIST:
2656 shader_addline(buffer, "pointlist");
2657 break;
2658 case WINED3D_PT_LINELIST:
2659 shader_addline(buffer, "linelist");
2660 break;
2661 case WINED3D_PT_LINESTRIP:
2662 shader_addline(buffer, "linestrip");
2663 break;
2664 case WINED3D_PT_TRIANGLELIST:
2665 shader_addline(buffer, "trianglelist");
2666 break;
2667 case WINED3D_PT_TRIANGLESTRIP:
2668 shader_addline(buffer, "trianglestrip");
2669 break;
2670 case WINED3D_PT_TRIANGLEFAN:
2671 shader_addline(buffer, "trianglefan");
2672 break;
2673 case WINED3D_PT_LINELIST_ADJ:
2674 shader_addline(buffer, "linelist_adj");
2675 break;
2676 case WINED3D_PT_LINESTRIP_ADJ:
2677 shader_addline(buffer, "linestrip_adj");
2678 break;
2679 case WINED3D_PT_TRIANGLELIST_ADJ:
2680 shader_addline(buffer, "trianglelist_adj");
2681 break;
2682 case WINED3D_PT_TRIANGLESTRIP_ADJ:
2683 shader_addline(buffer, "trianglestrip_adj");
2684 break;
2685 case WINED3D_PT_PATCH:
2686 shader_addline(buffer, "patch%u", primitive_type->patch_vertex_count);
2687 break;
2688 default:
2689 shader_addline(buffer, "<unrecognized_primitive_type %#x>", primitive_type->type);
2690 break;
2691 }
2692 }
2693
2694 static void shader_dump_interpolation_mode(struct wined3d_string_buffer *buffer,
2695 enum wined3d_shader_interpolation_mode interpolation_mode)
2696 {
2697 switch (interpolation_mode)
2698 {
2699 case WINED3DSIM_CONSTANT:
2700 shader_addline(buffer, "constant");
2701 break;
2702 case WINED3DSIM_LINEAR:
2703 shader_addline(buffer, "linear");
2704 break;
2705 case WINED3DSIM_LINEAR_CENTROID:
2706 shader_addline(buffer, "linear centroid");
2707 break;
2708 case WINED3DSIM_LINEAR_NOPERSPECTIVE:
2709 shader_addline(buffer, "linear noperspective");
2710 break;
2711 case WINED3DSIM_LINEAR_SAMPLE:
2712 shader_addline(buffer, "linear sample");
2713 break;
2714 case WINED3DSIM_LINEAR_NOPERSPECTIVE_CENTROID:
2715 shader_addline(buffer, "linear noperspective centroid");
2716 break;
2717 case WINED3DSIM_LINEAR_NOPERSPECTIVE_SAMPLE:
2718 shader_addline(buffer, "linear noperspective sample");
2719 break;
2720 default:
2721 shader_addline(buffer, "<unrecognized_interpolation_mode %#x>", interpolation_mode);
2722 break;
2723 }
2724 }
2725
2726 static void shader_trace_init(const struct wined3d_shader_frontend *fe, void *fe_data)
2727 {
2728 struct wined3d_shader_version shader_version;
2729 struct wined3d_string_buffer buffer;
2730 const char *type_prefix;
2731 const char *p, *q;
2732 const DWORD *ptr;
2733 DWORD i;
2734
2735 if (!string_buffer_init(&buffer))
2736 {
2737 ERR("Failed to initialize string buffer.\n");
2738 return;
2739 }
2740
2741 fe->shader_read_header(fe_data, &ptr, &shader_version);
2742
2743 TRACE("Parsing %p.\n", ptr);
2744
2745 switch (shader_version.type)
2746 {
2747 case WINED3D_SHADER_TYPE_VERTEX:
2748 type_prefix = "vs";
2749 break;
2750
2751 case WINED3D_SHADER_TYPE_HULL:
2752 type_prefix = "hs";
2753 break;
2754
2755 case WINED3D_SHADER_TYPE_DOMAIN:
2756 type_prefix = "ds";
2757 break;
2758
2759 case WINED3D_SHADER_TYPE_GEOMETRY:
2760 type_prefix = "gs";
2761 break;
2762
2763 case WINED3D_SHADER_TYPE_PIXEL:
2764 type_prefix = "ps";
2765 break;
2766
2767 case WINED3D_SHADER_TYPE_COMPUTE:
2768 type_prefix = "cs";
2769 break;
2770
2771 default:
2772 FIXME("Unhandled shader type %#x.\n", shader_version.type);
2773 type_prefix = "unknown";
2774 break;
2775 }
2776
2777 shader_addline(&buffer, "%s_%u_%u\n", type_prefix, shader_version.major, shader_version.minor);
2778
2779 while (!fe->shader_is_end(fe_data, &ptr))
2780 {
2781 struct wined3d_shader_instruction ins;
2782
2783 fe->shader_read_instruction(fe_data, &ptr, &ins);
2784 if (ins.handler_idx == WINED3DSIH_TABLE_SIZE)
2785 {
2786 WARN("Skipping unrecognized instruction.\n");
2787 shader_addline(&buffer, "<unrecognized instruction>\n");
2788 continue;
2789 }
2790
2791 if (ins.handler_idx == WINED3DSIH_DCL || ins.handler_idx == WINED3DSIH_DCL_UAV_TYPED)
2792 {
2793 shader_dump_decl_usage(&buffer, &ins.declaration.semantic, ins.flags, &shader_version);
2794 shader_dump_ins_modifiers(&buffer, &ins.declaration.semantic.reg);
2795 shader_addline(&buffer, " ");
2796 shader_dump_dst_param(&buffer, &ins.declaration.semantic.reg, &shader_version);
2797 }
2798 else if (ins.handler_idx == WINED3DSIH_DCL_CONSTANT_BUFFER)
2799 {
2800 shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]);
2801 shader_dump_src_param(&buffer, &ins.declaration.src, &shader_version);
2802 shader_addline(&buffer, ", %s",
2803 ins.flags & WINED3DSI_INDEXED_DYNAMIC ? "dynamicIndexed" : "immediateIndexed");
2804 }
2805 else if (ins.handler_idx == WINED3DSIH_DCL_FUNCTION_BODY)
2806 {
2807 shader_addline(&buffer, "%s fb%u",
2808 shader_opcode_names[ins.handler_idx], ins.declaration.index);
2809 }
2810 else if (ins.handler_idx == WINED3DSIH_DCL_FUNCTION_TABLE)
2811 {
2812 shader_addline(&buffer, "%s ft%u = {...}",
2813 shader_opcode_names[ins.handler_idx], ins.declaration.index);
2814 }
2815 else if (ins.handler_idx == WINED3DSIH_DCL_GLOBAL_FLAGS)
2816 {
2817 shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]);
2818 shader_dump_global_flags(&buffer, ins.flags);
2819 }
2820 else if (ins.handler_idx == WINED3DSIH_DCL_HS_MAX_TESSFACTOR)
2821 {
2822 shader_addline(&buffer, "%s %.8e", shader_opcode_names[ins.handler_idx],
2823 ins.declaration.max_tessellation_factor);
2824 }
2825 else if (ins.handler_idx == WINED3DSIH_DCL_IMMEDIATE_CONSTANT_BUFFER)
2826 {
2827 shader_addline(&buffer, "%s {\n", shader_opcode_names[ins.handler_idx]);
2828 for (i = 0; i < ins.declaration.icb->vec4_count; ++i)
2829 {
2830 shader_addline(&buffer, " {0x%08x, 0x%08x, 0x%08x, 0x%08x},\n",
2831 ins.declaration.icb->data[4 * i + 0],
2832 ins.declaration.icb->data[4 * i + 1],
2833 ins.declaration.icb->data[4 * i + 2],
2834 ins.declaration.icb->data[4 * i + 3]);
2835 }
2836 shader_addline(&buffer, "}");
2837 }
2838 else if (ins.handler_idx == WINED3DSIH_DCL_INDEX_RANGE)
2839 {
2840 shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]);
2841 shader_dump_dst_param(&buffer, &ins.declaration.index_range.first_register, &shader_version);
2842 shader_addline(&buffer, " %u", ins.declaration.index_range.last_register);
2843 }
2844 else if (ins.handler_idx == WINED3DSIH_DCL_INDEXABLE_TEMP)
2845 {
2846 shader_addline(&buffer, "%s x[%u][%u], %u", shader_opcode_names[ins.handler_idx],
2847 ins.declaration.indexable_temp.register_idx,
2848 ins.declaration.indexable_temp.register_size,
2849 ins.declaration.indexable_temp.component_count);
2850 }
2851 else if (ins.handler_idx == WINED3DSIH_DCL_INPUT_PS)
2852 {
2853 shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]);
2854 shader_dump_interpolation_mode(&buffer, ins.flags);
2855 shader_addline(&buffer, " ");
2856 shader_dump_dst_param(&buffer, &ins.declaration.dst, &shader_version);
2857 }
2858 else if (ins.handler_idx == WINED3DSIH_DCL_INPUT_PS_SGV
2859 || ins.handler_idx == WINED3DSIH_DCL_INPUT_SGV
2860 || ins.handler_idx == WINED3DSIH_DCL_INPUT_SIV
2861 || ins.handler_idx == WINED3DSIH_DCL_OUTPUT_SIV)
2862 {
2863 shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]);
2864 shader_dump_dst_param(&buffer, &ins.declaration.register_semantic.reg, &shader_version);
2865 shader_addline(&buffer, ", ");
2866 shader_dump_shader_input_sysval_semantic(&buffer, ins.declaration.register_semantic.sysval_semantic);
2867 }
2868 else if (ins.handler_idx == WINED3DSIH_DCL_INPUT_PS_SIV)
2869 {
2870 shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]);
2871 shader_dump_interpolation_mode(&buffer, ins.flags);
2872 shader_addline(&buffer, " ");
2873 shader_dump_dst_param(&buffer, &ins.declaration.register_semantic.reg, &shader_version);
2874 shader_addline(&buffer, ", ");
2875 shader_dump_shader_input_sysval_semantic(&buffer, ins.declaration.register_semantic.sysval_semantic);
2876 }
2877 else if (ins.handler_idx == WINED3DSIH_DCL_INPUT
2878 || ins.handler_idx == WINED3DSIH_DCL_OUTPUT)
2879 {
2880 shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]);
2881 shader_dump_dst_param(&buffer, &ins.declaration.dst, &shader_version);
2882 }
2883 else if (ins.handler_idx == WINED3DSIH_DCL_INPUT_PRIMITIVE
2884 || ins.handler_idx == WINED3DSIH_DCL_OUTPUT_TOPOLOGY)
2885 {
2886 shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]);
2887 shader_dump_primitive_type(&buffer, &ins.declaration.primitive_type);
2888 }
2889 else if (ins.handler_idx == WINED3DSIH_DCL_INTERFACE)
2890 {
2891 shader_addline(&buffer, "%s fp[%u][%u][%u] = {...}",
2892 shader_opcode_names[ins.handler_idx], ins.declaration.fp.index,
2893 ins.declaration.fp.array_size, ins.declaration.fp.body_count);
2894 }
2895 else if (ins.handler_idx == WINED3DSIH_DCL_RESOURCE_RAW)
2896 {
2897 shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]);
2898 shader_dump_dst_param(&buffer, &ins.declaration.dst, &shader_version);
2899 }
2900 else if (ins.handler_idx == WINED3DSIH_DCL_RESOURCE_STRUCTURED)
2901 {
2902 shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]);
2903 shader_dump_dst_param(&buffer, &ins.declaration.structured_resource.reg, &shader_version);
2904 shader_addline(&buffer, ", %u", ins.declaration.structured_resource.byte_stride);
2905 }
2906 else if (ins.handler_idx == WINED3DSIH_DCL_SAMPLER)
2907 {
2908 shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]);
2909 shader_dump_dst_param(&buffer, &ins.declaration.dst, &shader_version);
2910 if (ins.flags == WINED3DSI_SAMPLER_COMPARISON_MODE)
2911 shader_addline(&buffer, ", comparisonMode");
2912 }
2913 else if (ins.handler_idx == WINED3DSIH_DCL_TEMPS
2914 || ins.handler_idx == WINED3DSIH_DCL_GS_INSTANCES
2915 || ins.handler_idx == WINED3DSIH_DCL_HS_FORK_PHASE_INSTANCE_COUNT
2916 || ins.handler_idx == WINED3DSIH_DCL_HS_JOIN_PHASE_INSTANCE_COUNT
2917 || ins.handler_idx == WINED3DSIH_DCL_INPUT_CONTROL_POINT_COUNT
2918 || ins.handler_idx == WINED3DSIH_DCL_OUTPUT_CONTROL_POINT_COUNT
2919 || ins.handler_idx == WINED3DSIH_DCL_VERTICES_OUT)
2920 {
2921 shader_addline(&buffer, "%s %u", shader_opcode_names[ins.handler_idx], ins.declaration.count);
2922 }
2923 else if (ins.handler_idx == WINED3DSIH_DCL_TESSELLATOR_DOMAIN)
2924 {
2925 shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]);
2926 shader_dump_tessellator_domain(&buffer, ins.declaration.tessellator_domain);
2927 }
2928 else if (ins.handler_idx == WINED3DSIH_DCL_TESSELLATOR_OUTPUT_PRIMITIVE)
2929 {
2930 shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]);
2931 shader_dump_tessellator_output_primitive(&buffer, ins.declaration.tessellator_output_primitive);
2932 }
2933 else if (ins.handler_idx == WINED3DSIH_DCL_TESSELLATOR_PARTITIONING)
2934 {
2935 shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]);
2936 shader_dump_tessellator_partitioning(&buffer, ins.declaration.tessellator_partitioning);
2937 }
2938 else if (ins.handler_idx == WINED3DSIH_DCL_TGSM_RAW)
2939 {
2940 shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]);
2941 shader_dump_dst_param(&buffer, &ins.declaration.tgsm_raw.reg, &shader_version);
2942 shader_addline(&buffer, ", %u", ins.declaration.tgsm_raw.byte_count);
2943 }
2944 else if (ins.handler_idx == WINED3DSIH_DCL_TGSM_STRUCTURED)
2945 {
2946 shader_addline(&buffer, "%s ", shader_opcode_names[ins.handler_idx]);
2947 shader_dump_dst_param(&buffer, &ins.declaration.tgsm_structured.reg, &shader_version);
2948 shader_addline(&buffer, ", %u, %u", ins.declaration.tgsm_structured.byte_stride,
2949 ins.declaration.tgsm_structured.structure_count);
2950 }
2951 else if (ins.handler_idx == WINED3DSIH_DCL_THREAD_GROUP)
2952 {
2953 shader_addline(&buffer, "%s %u, %u, %u", shader_opcode_names[ins.handler_idx],
2954 ins.declaration.thread_group_size.x,
2955 ins.declaration.thread_group_size.y,
2956 ins.declaration.thread_group_size.z);
2957 }
2958 else if (ins.handler_idx == WINED3DSIH_DCL_UAV_RAW)
2959 {
2960 shader_addline(&buffer, "%s", shader_opcode_names[ins.handler_idx]);
2961 shader_dump_uav_flags(&buffer, ins.flags);
2962 shader_addline(&buffer, " ");
2963 shader_dump_dst_param(&buffer, &ins.declaration.dst, &shader_version);
2964 }
2965 else if (ins.handler_idx == WINED3DSIH_DCL_UAV_STRUCTURED)
2966 {
2967 shader_addline(&buffer, "%s", shader_opcode_names[ins.handler_idx]);
2968 shader_dump_uav_flags(&buffer, ins.flags);
2969 shader_addline(&buffer, " ");
2970 shader_dump_dst_param(&buffer, &ins.declaration.structured_resource.reg, &shader_version);
2971 shader_addline(&buffer, ", %u", ins.declaration.structured_resource.byte_stride);
2972 }
2973 else if (ins.handler_idx == WINED3DSIH_DEF)
2974 {
2975 shader_addline(&buffer, "def c%u = %.8e, %.8e, %.8e, %.8e", shader_get_float_offset(ins.dst[0].reg.type,
2976 ins.dst[0].reg.idx[0].offset),
2977 *(const float *)&ins.src[0].reg.u.immconst_data[0],
2978 *(const float *)&ins.src[0].reg.u.immconst_data[1],
2979 *(const float *)&ins.src[0].reg.u.immconst_data[2],
2980 *(const float *)&ins.src[0].reg.u.immconst_data[3]);
2981 }
2982 else if (ins.handler_idx == WINED3DSIH_DEFI)
2983 {
2984 shader_addline(&buffer, "defi i%u = %d, %d, %d, %d", ins.dst[0].reg.idx[0].offset,
2985 ins.src[0].reg.u.immconst_data[0],
2986 ins.src[0].reg.u.immconst_data[1],
2987 ins.src[0].reg.u.immconst_data[2],
2988 ins.src[0].reg.u.immconst_data[3]);
2989 }
2990 else if (ins.handler_idx == WINED3DSIH_DEFB)
2991 {
2992 shader_addline(&buffer, "defb b%u = %s",
2993 ins.dst[0].reg.idx[0].offset, ins.src[0].reg.u.immconst_data[0] ? "true" : "false");
2994 }
2995 else
2996 {
2997 if (ins.predicate)
2998 {
2999 shader_addline(&buffer, "(");
3000 shader_dump_src_param(&buffer, ins.predicate, &shader_version);
3001 shader_addline(&buffer, ") ");
3002 }
3003
3004 /* PixWin marks instructions with the coissue flag with a '+' */
3005 if (ins.coissue)
3006 shader_addline(&buffer, "+");
3007
3008 shader_addline(&buffer, "%s", shader_opcode_names[ins.handler_idx]);
3009
3010 if (ins.handler_idx == WINED3DSIH_BREAKP
3011 || ins.handler_idx == WINED3DSIH_CONTINUEP
3012 || ins.handler_idx == WINED3DSIH_IF
3013 || ins.handler_idx == WINED3DSIH_RETP
3014 || ins.handler_idx == WINED3DSIH_TEXKILL)
3015 {
3016 switch (ins.flags)
3017 {
3018 case WINED3D_SHADER_CONDITIONAL_OP_NZ: shader_addline(&buffer, "_nz"); break;
3019 case WINED3D_SHADER_CONDITIONAL_OP_Z: shader_addline(&buffer, "_z"); break;
3020 default: shader_addline(&buffer, "_unrecognized(%#x)", ins.flags); break;
3021 }
3022 }
3023 else if (ins.handler_idx == WINED3DSIH_IFC
3024 || ins.handler_idx == WINED3DSIH_BREAKC)
3025 {
3026 switch (ins.flags)
3027 {
3028 case WINED3D_SHADER_REL_OP_GT: shader_addline(&buffer, "_gt"); break;
3029 case WINED3D_SHADER_REL_OP_EQ: shader_addline(&buffer, "_eq"); break;
3030 case WINED3D_SHADER_REL_OP_GE: shader_addline(&buffer, "_ge"); break;
3031 case WINED3D_SHADER_REL_OP_LT: shader_addline(&buffer, "_lt"); break;
3032 case WINED3D_SHADER_REL_OP_NE: shader_addline(&buffer, "_ne"); break;
3033 case WINED3D_SHADER_REL_OP_LE: shader_addline(&buffer, "_le"); break;
3034 default: shader_addline(&buffer, "_(%u)", ins.flags);
3035 }
3036 }
3037 else if (ins.handler_idx == WINED3DSIH_TEX
3038 && shader_version.major >= 2
3039 && (ins.flags & WINED3DSI_TEXLD_PROJECT))
3040 {
3041 shader_addline(&buffer, "p");
3042 }
3043 else if (ins.handler_idx == WINED3DSIH_RESINFO && ins.flags)
3044 {
3045 switch (ins.flags)
3046 {
3047 case WINED3DSI_RESINFO_RCP_FLOAT: shader_addline(&buffer, "_rcpFloat"); break;
3048 case WINED3DSI_RESINFO_UINT: shader_addline(&buffer, "_uint"); break;
3049 default: shader_addline(&buffer, "_unrecognized(%#x)", ins.flags);
3050 }
3051 }
3052 else if (ins.handler_idx == WINED3DSIH_SAMPLE_INFO && ins.flags)
3053 {
3054 switch (ins.flags)
3055 {
3056 case WINED3DSI_SAMPLE_INFO_UINT: shader_addline(&buffer, "_uint"); break;
3057 default: shader_addline(&buffer, "_unrecognized(%#x)", ins.flags);
3058 }
3059 }
3060 else if (ins.handler_idx == WINED3DSIH_SYNC)
3061 {
3062 shader_dump_sync_flags(&buffer, ins.flags);
3063 }
3064
3065 if (wined3d_shader_instruction_has_texel_offset(&ins))
3066 shader_addline(&buffer, "(%d,%d,%d)", ins.texel_offset.u, ins.texel_offset.v, ins.texel_offset.w);
3067
3068 for (i = 0; i < ins.dst_count; ++i)
3069 {
3070 shader_dump_ins_modifiers(&buffer, &ins.dst[i]);
3071 shader_addline(&buffer, !i ? " " : ", ");
3072 shader_dump_dst_param(&buffer, &ins.dst[i], &shader_version);
3073 }
3074
3075 /* Other source tokens */
3076 for (i = ins.dst_count; i < (ins.dst_count + ins.src_count); ++i)
3077 {
3078 shader_addline(&buffer, !i ? " " : ", ");
3079 shader_dump_src_param(&buffer, &ins.src[i - ins.dst_count], &shader_version);
3080 }
3081 }
3082 shader_addline(&buffer, "\n");
3083 }
3084
3085 for (p = buffer.buffer; *p; p = q)
3086 {
3087 if (!(q = strstr(p, "\n")))
3088 q = p + strlen(p);
3089 else
3090 ++q;
3091 TRACE(" %.*s", (int)(q - p), p);
3092 }
3093
3094 string_buffer_free(&buffer);
3095 }
3096
3097 static void shader_cleanup(struct wined3d_shader *shader)
3098 {
3099 if (shader->reg_maps.shader_version.type == WINED3D_SHADER_TYPE_HULL)
3100 {
3101 heap_free(shader->u.hs.phases.control_point);
3102 heap_free(shader->u.hs.phases.fork);
3103 heap_free(shader->u.hs.phases.join);
3104 }
3105 else if (shader->reg_maps.shader_version.type == WINED3D_SHADER_TYPE_GEOMETRY)
3106 {
3107 heap_free(shader->u.gs.so_desc.elements);
3108 }
3109
3110 heap_free(shader->patch_constant_signature.elements);
3111 heap_free(shader->output_signature.elements);
3112 heap_free(shader->input_signature.elements);
3113 heap_free(shader->signature_strings);
3114 shader->device->shader_backend->shader_destroy(shader);
3115 shader_cleanup_reg_maps(&shader->reg_maps);
3116 heap_free(shader->function);
3117 shader_delete_constant_list(&shader->constantsF);
3118 shader_delete_constant_list(&shader->constantsB);
3119 shader_delete_constant_list(&shader->constantsI);
3120 list_remove(&shader->shader_list_entry);
3121
3122 if (shader->frontend && shader->frontend_data)
3123 shader->frontend->shader_free(shader->frontend_data);
3124 }
3125
3126 struct shader_none_priv
3127 {
3128 const struct wined3d_vertex_pipe_ops *vertex_pipe;
3129 const struct fragment_pipeline *fragment_pipe;
3130 BOOL ffp_proj_control;
3131 };
3132
3133 static void shader_none_handle_instruction(const struct wined3d_shader_instruction *ins) {}
3134 static void shader_none_precompile(void *shader_priv, struct wined3d_shader *shader) {}
3135 static void shader_none_select_compute(void *shader_priv, struct wined3d_context *context,
3136 const struct wined3d_state *state) {}
3137 static void shader_none_update_float_vertex_constants(struct wined3d_device *device, UINT start, UINT count) {}
3138 static void shader_none_update_float_pixel_constants(struct wined3d_device *device, UINT start, UINT count) {}
3139 static void shader_none_load_constants(void *shader_priv, struct wined3d_context *context,
3140 const struct wined3d_state *state) {}
3141 static void shader_none_destroy(struct wined3d_shader *shader) {}
3142 static void shader_none_free_context_data(struct wined3d_context *context) {}
3143 static void shader_none_init_context_state(struct wined3d_context *context) {}
3144
3145 /* Context activation is done by the caller. */
3146 static void shader_none_select(void *shader_priv, struct wined3d_context *context,
3147 const struct wined3d_state *state)
3148 {
3149 const struct wined3d_gl_info *gl_info = context->gl_info;
3150 struct shader_none_priv *priv = shader_priv;
3151
3152 priv->vertex_pipe->vp_enable(gl_info, !use_vs(state));
3153 priv->fragment_pipe->enable_extension(gl_info, !use_ps(state));
3154 }
3155
3156 /* Context activation is done by the caller. */
3157 static void shader_none_disable(void *shader_priv, struct wined3d_context *context)
3158 {
3159 struct shader_none_priv *priv = shader_priv;
3160 const struct wined3d_gl_info *gl_info = context->gl_info;
3161
3162 priv->vertex_pipe->vp_enable(gl_info, FALSE);
3163 priv->fragment_pipe->enable_extension(gl_info, FALSE);
3164
3165 context->shader_update_mask = (1u << WINED3D_SHADER_TYPE_PIXEL)
3166 | (1u << WINED3D_SHADER_TYPE_VERTEX)
3167 | (1u << WINED3D_SHADER_TYPE_GEOMETRY)
3168 | (1u << WINED3D_SHADER_TYPE_HULL)
3169 | (1u << WINED3D_SHADER_TYPE_DOMAIN)
3170 | (1u << WINED3D_SHADER_TYPE_COMPUTE);
3171 }
3172
3173 static HRESULT shader_none_alloc(struct wined3d_device *device, const struct wined3d_vertex_pipe_ops *vertex_pipe,
3174 const struct fragment_pipeline *fragment_pipe)
3175 {
3176 struct fragment_caps fragment_caps;
3177 void *vertex_priv, *fragment_priv;
3178 struct shader_none_priv *priv;
3179
3180 if (!(priv = heap_alloc(sizeof(*priv))))
3181 return E_OUTOFMEMORY;
3182
3183 if (!(vertex_priv = vertex_pipe->vp_alloc(&none_shader_backend, priv)))
3184 {
3185 ERR("Failed to initialize vertex pipe.\n");
3186 heap_free(priv);
3187 return E_FAIL;
3188 }
3189
3190 if (!(fragment_priv = fragment_pipe->alloc_private(&none_shader_backend, priv)))
3191 {
3192 ERR("Failed to initialize fragment pipe.\n");
3193 vertex_pipe->vp_free(device);
3194 heap_free(priv);
3195 return E_FAIL;
3196 }
3197
3198 priv->vertex_pipe = vertex_pipe;
3199 priv->fragment_pipe = fragment_pipe;
3200 fragment_pipe->get_caps(&device->adapter->gl_info, &fragment_caps);
3201 priv->ffp_proj_control = fragment_caps.wined3d_caps & WINED3D_FRAGMENT_CAP_PROJ_CONTROL;
3202
3203 device->vertex_priv = vertex_priv;
3204 device->fragment_priv = fragment_priv;
3205 device->shader_priv = priv;
3206
3207 return WINED3D_OK;
3208 }
3209
3210 static void shader_none_free(struct wined3d_device *device)
3211 {
3212 struct shader_none_priv *priv = device->shader_priv;
3213
3214 priv->fragment_pipe->free_private(device);
3215 priv->vertex_pipe->vp_free(device);
3216 heap_free(priv);
3217 }
3218
3219 static BOOL shader_none_allocate_context_data(struct wined3d_context *context)
3220 {
3221 return TRUE;
3222 }
3223
3224 static void shader_none_get_caps(const struct wined3d_gl_info *gl_info, struct shader_caps *caps)
3225 {
3226 /* Set the shader caps to 0 for the none shader backend */
3227 caps->vs_version = 0;
3228 caps->hs_version = 0;
3229 caps->ds_version = 0;
3230 caps->gs_version = 0;
3231 caps->ps_version = 0;
3232 caps->cs_version = 0;
3233 caps->vs_uniform_count = 0;
3234 caps->ps_uniform_count = 0;
3235 caps->ps_1x_max_value = 0.0f;
3236 caps->varying_count = 0;
3237 caps->wined3d_caps = 0;
3238 }
3239
3240 static BOOL shader_none_color_fixup_supported(struct color_fixup_desc fixup)
3241 {
3242 /* We "support" every possible fixup, since we don't support any shader
3243 * model, and will never have to actually sample a texture. */
3244 return TRUE;
3245 }
3246
3247 static BOOL shader_none_has_ffp_proj_control(void *shader_priv)
3248 {
3249 struct shader_none_priv *priv = shader_priv;
3250
3251 return priv->ffp_proj_control;
3252 }
3253
3254 const struct wined3d_shader_backend_ops none_shader_backend =
3255 {
3256 shader_none_handle_instruction,
3257 shader_none_precompile,
3258 shader_none_select,
3259 shader_none_select_compute,
3260 shader_none_disable,
3261 shader_none_update_float_vertex_constants,
3262 shader_none_update_float_pixel_constants,
3263 shader_none_load_constants,
3264 shader_none_destroy,
3265 shader_none_alloc,
3266 shader_none_free,
3267 shader_none_allocate_context_data,
3268 shader_none_free_context_data,
3269 shader_none_init_context_state,
3270 shader_none_get_caps,
3271 shader_none_color_fixup_supported,
3272 shader_none_has_ffp_proj_control,
3273 };
3274
3275 static HRESULT shader_set_function(struct wined3d_shader *shader, DWORD float_const_count,
3276 enum wined3d_shader_type type, unsigned int max_version)
3277 {
3278 struct wined3d_shader_reg_maps *reg_maps = &shader->reg_maps;
3279 const struct wined3d_shader_frontend *fe;
3280 HRESULT hr;
3281 unsigned int backend_version;
3282 const struct wined3d_d3d_info *d3d_info = &shader->device->adapter->d3d_info;
3283
3284 TRACE("shader %p, float_const_count %u, type %#x, max_version %u.\n",
3285 shader, float_const_count, type, max_version);
3286
3287 fe = shader->frontend;
3288 if (!(shader->frontend_data = fe->shader_init(shader->function,
3289 shader->functionLength, &shader->output_signature)))
3290 {
3291 FIXME("Failed to initialize frontend.\n");
3292 return WINED3DERR_INVALIDCALL;
3293 }
3294
3295 /* First pass: trace shader. */
3296 if (TRACE_ON(d3d_shader))
3297 shader_trace_init(fe, shader->frontend_data);
3298
3299 /* Second pass: figure out which registers are used, what the semantics are, etc. */
3300 if (FAILED(hr = shader_get_registers_used(shader, fe, reg_maps, &shader->input_signature,
3301 &shader->output_signature, float_const_count)))
3302 return hr;
3303
3304 if (reg_maps->shader_version.type != type)
3305 {
3306 WARN("Wrong shader type %d.\n", reg_maps->shader_version.type);
3307 return WINED3DERR_INVALIDCALL;
3308 }
3309 if (reg_maps->shader_version.major > max_version)
3310 {
3311 WARN("Shader version %d not supported by this D3D API version.\n", reg_maps->shader_version.major);
3312 return WINED3DERR_INVALIDCALL;
3313 }
3314 switch (type)
3315 {
3316 case WINED3D_SHADER_TYPE_VERTEX:
3317 backend_version = d3d_info->limits.vs_version;
3318 break;
3319 case WINED3D_SHADER_TYPE_HULL:
3320 backend_version = d3d_info->limits.hs_version;
3321 break;
3322 case WINED3D_SHADER_TYPE_DOMAIN:
3323 backend_version = d3d_info->limits.ds_version;
3324 break;
3325 case WINED3D_SHADER_TYPE_GEOMETRY:
3326 backend_version = d3d_info->limits.gs_version;
3327 break;
3328 case WINED3D_SHADER_TYPE_PIXEL:
3329 backend_version = d3d_info->limits.ps_version;
3330 break;
3331 case WINED3D_SHADER_TYPE_COMPUTE:
3332 backend_version = d3d_info->limits.cs_version;
3333 break;
3334 default:
3335 FIXME("No backend version-checking for this shader type.\n");
3336 backend_version = 0;
3337 }
3338 if (reg_maps->shader_version.major > backend_version)
3339 {
3340 WARN("Shader version %d.%d not supported by your GPU with the current shader backend.\n",
3341 reg_maps->shader_version.major, reg_maps->shader_version.minor);
3342 return WINED3DERR_INVALIDCALL;
3343 }
3344
3345 return WINED3D_OK;
3346 }
3347
3348 ULONG CDECL wined3d_shader_incref(struct wined3d_shader *shader)
3349 {
3350 ULONG refcount = InterlockedIncrement(&shader->ref);
3351
3352 TRACE("%p increasing refcount to %u.\n", shader, refcount);
3353
3354 return refcount;
3355 }
3356
3357 static void wined3d_shader_init_object(void *object)
3358 {
3359 struct wined3d_shader *shader = object;
3360 struct wined3d_device *device = shader->device;
3361
3362 list_add_head(&device->shaders, &shader->shader_list_entry);
3363
3364 device->shader_backend->shader_precompile(device->shader_priv, shader);
3365 }
3366
3367 static void wined3d_shader_destroy_object(void *object)
3368 {
3369 shader_cleanup(object);
3370 heap_free(object);
3371 }
3372
3373 ULONG CDECL wined3d_shader_decref(struct wined3d_shader *shader)
3374 {
3375 ULONG refcount = InterlockedDecrement(&shader->ref);
3376
3377 TRACE("%p decreasing refcount to %u.\n", shader, refcount);
3378
3379 if (!refcount)
3380 {
3381 shader->parent_ops->wined3d_object_destroyed(shader->parent);
3382 wined3d_cs_destroy_object(shader->device->cs, wined3d_shader_destroy_object, shader);
3383 }
3384
3385 return refcount;
3386 }
3387
3388 void * CDECL wined3d_shader_get_parent(const struct wined3d_shader *shader)
3389 {
3390 TRACE("shader %p.\n", shader);
3391
3392 return shader->parent;
3393 }
3394
3395 HRESULT CDECL wined3d_shader_get_byte_code(const struct wined3d_shader *shader,
3396 void *byte_code, UINT *byte_code_size)
3397 {
3398 TRACE("shader %p, byte_code %p, byte_code_size %p.\n", shader, byte_code, byte_code_size);
3399
3400 if (!byte_code)
3401 {
3402 *byte_code_size = shader->functionLength;
3403 return WINED3D_OK;
3404 }
3405
3406 if (*byte_code_size < shader->functionLength)
3407 {
3408 /* MSDN claims (for d3d8 at least) that if *byte_code_size is smaller
3409 * than the required size we should write the required size and
3410 * return D3DERR_MOREDATA. That's not actually true. */
3411 return WINED3DERR_INVALIDCALL;
3412 }
3413
3414 memcpy(byte_code, shader->function, shader->functionLength);
3415
3416 return WINED3D_OK;
3417 }
3418
3419 /* Set local constants for d3d8 shaders. */
3420 HRESULT CDECL wined3d_shader_set_local_constants_float(struct wined3d_shader *shader,
3421 UINT start_idx, const float *src_data, UINT count)
3422 {
3423 UINT end_idx = start_idx + count;
3424 UINT i;
3425
3426 TRACE("shader %p, start_idx %u, src_data %p, count %u.\n", shader, start_idx, src_data, count);
3427
3428 if (end_idx > shader->limits->constant_float)
3429 {
3430 WARN("end_idx %u > float constants limit %u.\n",
3431 end_idx, shader->limits->constant_float);
3432 end_idx = shader->limits->constant_float;
3433 }
3434
3435 for (i = start_idx; i < end_idx; ++i)
3436 {
3437 struct wined3d_shader_lconst *lconst;
3438 float *value;
3439
3440 if (!(lconst = heap_alloc(sizeof(*lconst))))
3441 return E_OUTOFMEMORY;
3442
3443 lconst->idx = i;
3444 value = (float *)lconst->value;
3445 memcpy(value, src_data + (i - start_idx) * 4 /* 4 components */, 4 * sizeof(float));
3446 list_add_head(&shader->constantsF, &lconst->entry);
3447
3448 if (isinf(value[0]) || isnan(value[0]) || isinf(value[1]) || isnan(value[1])
3449 || isinf(value[2]) || isnan(value[2]) || isinf(value[3]) || isnan(value[3]))
3450 {
3451 shader->lconst_inf_or_nan = TRUE;
3452 }
3453 }
3454
3455 return WINED3D_OK;
3456 }
3457
3458 static void init_interpolation_compile_args(DWORD *interpolation_args,
3459 const struct wined3d_shader *pixel_shader, const struct wined3d_gl_info *gl_info)
3460 {
3461 if (!needs_interpolation_qualifiers_for_shader_outputs(gl_info)
3462 || !pixel_shader || pixel_shader->reg_maps.shader_version.major < 4)
3463 {
3464 memset(interpolation_args, 0, sizeof(pixel_shader->u.ps.interpolation_mode));
3465 return;
3466 }
3467
3468 memcpy(interpolation_args, pixel_shader->u.ps.interpolation_mode,
3469 sizeof(pixel_shader->u.ps.interpolation_mode));
3470 }
3471
3472 void find_vs_compile_args(const struct wined3d_state *state, const struct wined3d_shader *shader,
3473 WORD swizzle_map, struct vs_compile_args *args, const struct wined3d_context *context)
3474 {
3475 const struct wined3d_shader *geometry_shader = state->shader[WINED3D_SHADER_TYPE_GEOMETRY];
3476 const struct wined3d_shader *pixel_shader = state->shader[WINED3D_SHADER_TYPE_PIXEL];
3477 const struct wined3d_shader *hull_shader = state->shader[WINED3D_SHADER_TYPE_HULL];
3478 const struct wined3d_d3d_info *d3d_info = context->d3d_info;
3479 const struct wined3d_gl_info *gl_info = context->gl_info;
3480
3481 args->fog_src = state->render_states[WINED3D_RS_FOGTABLEMODE]
3482 == WINED3D_FOG_NONE ? VS_FOG_COORD : VS_FOG_Z;
3483 args->clip_enabled = state->render_states[WINED3D_RS_CLIPPING]
3484 && state->render_states[WINED3D_RS_CLIPPLANEENABLE];
3485 args->point_size = state->gl_primitive_type == GL_POINTS;
3486 args->per_vertex_point_size = shader->reg_maps.point_size;
3487 args->next_shader_type = hull_shader? WINED3D_SHADER_TYPE_HULL
3488 : geometry_shader ? WINED3D_SHADER_TYPE_GEOMETRY : WINED3D_SHADER_TYPE_PIXEL;
3489 if (shader->reg_maps.shader_version.major >= 4)
3490 args->next_shader_input_count = hull_shader ? hull_shader->limits->packed_input
3491 : geometry_shader ? geometry_shader->limits->packed_input
3492 : pixel_shader ? pixel_shader->limits->packed_input : 0;
3493 else
3494 args->next_shader_input_count = 0;
3495 args->swizzle_map = swizzle_map;
3496 if (d3d_info->emulated_flatshading)
3497 args->flatshading = state->render_states[WINED3D_RS_SHADEMODE] == WINED3D_SHADE_FLAT;
3498 else
3499 args->flatshading = 0;
3500
3501 init_interpolation_compile_args(args->interpolation_mode,
3502 args->next_shader_type == WINED3D_SHADER_TYPE_PIXEL ? pixel_shader : NULL, gl_info);
3503 }
3504
3505 static BOOL match_usage(BYTE usage1, BYTE usage_idx1, BYTE usage2, BYTE usage_idx2)
3506 {
3507 if (usage_idx1 != usage_idx2)
3508 return FALSE;
3509 if (usage1 == usage2)
3510 return TRUE;
3511 if (usage1 == WINED3D_DECL_USAGE_POSITION && usage2 == WINED3D_DECL_USAGE_POSITIONT)
3512 return TRUE;
3513 if (usage2 == WINED3D_DECL_USAGE_POSITION && usage1 == WINED3D_DECL_USAGE_POSITIONT)
3514 return TRUE;
3515
3516 return FALSE;
3517 }
3518
3519 BOOL vshader_get_input(const struct wined3d_shader *shader,
3520 BYTE usage_req, BYTE usage_idx_req, unsigned int *regnum)
3521 {
3522 WORD map = shader->reg_maps.input_registers;
3523 unsigned int i;
3524
3525 for (i = 0; map; map >>= 1, ++i)
3526 {
3527 if (!(map & 1)) continue;
3528
3529 if (match_usage(shader->u.vs.attributes[i].usage,
3530 shader->u.vs.attributes[i].usage_idx, usage_req, usage_idx_req))
3531 {
3532 *regnum = i;
3533 return TRUE;
3534 }
3535 }
3536 return FALSE;
3537 }
3538
3539 static HRESULT shader_signature_calculate_strings_length(const struct wined3d_shader_signature *signature,
3540 SIZE_T *total)
3541 {
3542 struct wined3d_shader_signature_element *e;
3543 unsigned int i;
3544 SIZE_T len;
3545
3546 for (i = 0; i < signature->element_count; ++i)
3547 {
3548 e = &signature->elements[i];
3549 len = strlen(e->semantic_name);
3550 if (len >= ~(SIZE_T)0 - *total)
3551 return E_OUTOFMEMORY;
3552
3553 *total += len + 1;
3554 }
3555 return WINED3D_OK;
3556 }
3557
3558 static HRESULT shader_signature_copy(struct wined3d_shader_signature *dst,
3559 const struct wined3d_shader_signature *src, char **signature_strings)
3560 {
3561 struct wined3d_shader_signature_element *e;
3562 unsigned int i;
3563 SIZE_T len;
3564 char *ptr;
3565
3566 if (!src->element_count)
3567 return WINED3D_OK;
3568
3569 ptr = *signature_strings;
3570
3571 dst->element_count = src->element_count;
3572 if (!(dst->elements = heap_calloc(dst->element_count, sizeof(*dst->elements))))
3573 return E_OUTOFMEMORY;
3574
3575 for (i = 0; i < src->element_count; ++i)
3576 {
3577 e = &src->elements[i];
3578 dst->elements[i] = *e;
3579
3580 len = strlen(e->semantic_name);
3581 memcpy(ptr, e->semantic_name, len + 1);
3582 dst->elements[i].semantic_name = ptr;
3583 ptr += len + 1;
3584 }
3585
3586 *signature_strings = ptr;
3587
3588 return WINED3D_OK;
3589 }
3590
3591 static HRESULT shader_init(struct wined3d_shader *shader, struct wined3d_device *device,
3592 const struct wined3d_shader_desc *desc, DWORD float_const_count, enum wined3d_shader_type type,
3593 void *parent, const struct wined3d_parent_ops *parent_ops)
3594 {
3595 size_t byte_code_size;
3596 SIZE_T total;
3597 HRESULT hr;
3598 char *ptr;
3599
3600 TRACE("byte_code %p, byte_code_size %#lx, format %#x, max_version %#x.\n",
3601 desc->byte_code, (long)desc->byte_code_size, desc->format, desc->max_version);
3602
3603 if (!desc->byte_code)
3604 return WINED3DERR_INVALIDCALL;
3605
3606 if (!(shader->frontend = shader_select_frontend(desc->format)))
3607 {
3608 FIXME("Unable to find frontend for shader.\n");
3609 return WINED3DERR_INVALIDCALL;
3610 }
3611
3612 shader->ref = 1;
3613 shader->device = device;
3614 shader->parent = parent;
3615 shader->parent_ops = parent_ops;
3616
3617 total = 0;
3618 if (FAILED(hr = shader_signature_calculate_strings_length(&desc->input_signature, &total)))
3619 return hr;
3620 if (FAILED(hr = shader_signature_calculate_strings_length(&desc->output_signature, &total)))
3621 return hr;
3622 if (FAILED(hr = shader_signature_calculate_strings_length(&desc->patch_constant_signature, &total)))
3623 return hr;
3624 if (total && !(shader->signature_strings = heap_alloc(total)))
3625 return E_OUTOFMEMORY;
3626 ptr = shader->signature_strings;
3627
3628 if (FAILED(hr = shader_signature_copy(&shader->input_signature, &desc->input_signature, &ptr)))
3629 {
3630 heap_free(shader->signature_strings);
3631 return hr;
3632 }
3633 if (FAILED(hr = shader_signature_copy(&shader->output_signature, &desc->output_signature, &ptr)))
3634 {
3635 heap_free(shader->input_signature.elements);
3636 heap_free(shader->signature_strings);
3637 return hr;
3638 }
3639 if (FAILED(hr = shader_signature_copy(&shader->patch_constant_signature, &desc->patch_constant_signature, &ptr)))
3640 {
3641 heap_free(shader->output_signature.elements);
3642 heap_free(shader->input_signature.elements);
3643 heap_free(shader->signature_strings);
3644 return hr;
3645 }
3646
3647 list_init(&shader->linked_programs);
3648 list_init(&shader->constantsF);
3649 list_init(&shader->constantsB);
3650 list_init(&shader->constantsI);
3651 shader->lconst_inf_or_nan = FALSE;
3652 list_init(&shader->reg_maps.indexable_temps);
3653 list_init(&shader->shader_list_entry);
3654
3655 byte_code_size = desc->byte_code_size;
3656 if (byte_code_size == ~(size_t)0)
3657 {
3658 const struct wined3d_shader_frontend *fe = shader->frontend;
3659 struct wined3d_shader_version shader_version;
3660 struct wined3d_shader_instruction ins;
3661 const DWORD *ptr;
3662 void *fe_data;
3663
3664 if (!(fe_data = fe->shader_init(desc->byte_code, byte_code_size, &shader->output_signature)))
3665 {
3666 WARN("Failed to initialise frontend data.\n");
3667 shader_cleanup(shader);
3668 return WINED3DERR_INVALIDCALL;
3669 }
3670
3671 fe->shader_read_header(fe_data, &ptr, &shader_version);
3672 while (!fe->shader_is_end(fe_data, &ptr))
3673 fe->shader_read_instruction(fe_data, &ptr, &ins);
3674
3675 fe->shader_free(fe_data);
3676
3677 byte_code_size = (ptr - desc->byte_code) * sizeof(*ptr);
3678 }
3679
3680 if (!(shader->function = heap_alloc(byte_code_size)))
3681 {
3682 shader_cleanup(shader);
3683 return E_OUTOFMEMORY;
3684 }
3685 memcpy(shader->function, desc->byte_code, byte_code_size);
3686 shader->functionLength = byte_code_size;
3687
3688 if (FAILED(hr = shader_set_function(shader, float_const_count, type, desc->max_version)))
3689 {
3690 WARN("Failed to set function, hr %#x.\n", hr);
3691 shader_cleanup(shader);
3692 return hr;
3693 }
3694
3695 shader->load_local_constsF = shader->lconst_inf_or_nan;
3696
3697 return hr;
3698 }
3699
3700 static HRESULT vertex_shader_init(struct wined3d_shader *shader, struct wined3d_device *device,
3701 const struct wined3d_shader_desc *desc, void *parent, const struct wined3d_parent_ops *parent_ops)
3702 {
3703 struct wined3d_shader_reg_maps *reg_maps = &shader->reg_maps;
3704 unsigned int i;
3705 HRESULT hr;
3706
3707 if (FAILED(hr = shader_init(shader, device, desc, device->adapter->d3d_info.limits.vs_uniform_count,
3708 WINED3D_SHADER_TYPE_VERTEX, parent, parent_ops)))
3709 return hr;
3710
3711 for (i = 0; i < shader->input_signature.element_count; ++i)
3712 {
3713 const struct wined3d_shader_signature_element *input = &shader->input_signature.elements[i];
3714
3715 if (!(reg_maps->input_registers & (1u << input->register_idx)) || !input->semantic_name)
3716 continue;
3717
3718 shader->u.vs.attributes[input->register_idx].usage =
3719 shader_usage_from_semantic_name(input->semantic_name);
3720 shader->u.vs.attributes[input->register_idx].usage_idx = input->semantic_idx;
3721 }
3722
3723 if (reg_maps->usesrelconstF && !list_empty(&shader->constantsF))
3724 shader->load_local_constsF = TRUE;
3725
3726 return WINED3D_OK;
3727 }
3728
3729 static HRESULT geometry_shader_init(struct wined3d_shader *shader, struct wined3d_device *device,
3730 const struct wined3d_shader_desc *desc, const struct wined3d_stream_output_desc *so_desc,
3731 void *parent, const struct wined3d_parent_ops *parent_ops)
3732 {
3733 struct wined3d_stream_output_element *elements = NULL;
3734 enum wined3d_shader_type shader_type;
3735 HRESULT hr;
3736
3737 if (so_desc)
3738 {
3739 shader_type = shader_get_shader_type(desc);
3740 switch (shader_type)
3741 {
3742 case WINED3D_SHADER_TYPE_VERTEX:
3743 case WINED3D_SHADER_TYPE_DOMAIN:
3744 FIXME("Stream output not supported for %s.\n", debug_shader_type(shader_type));
3745 return E_NOTIMPL;
3746 default:
3747 break;
3748 }
3749 }
3750
3751 if (so_desc && !(elements = heap_calloc(so_desc->element_count, sizeof(*elements))))
3752 return E_OUTOFMEMORY;
3753
3754 if (FAILED(hr = shader_init(shader, device, desc, 0, WINED3D_SHADER_TYPE_GEOMETRY, parent, parent_ops)))
3755 {
3756 heap_free(elements);
3757 return hr;
3758 }
3759
3760 if (so_desc)
3761 {
3762 shader->u.gs.so_desc = *so_desc;
3763 shader->u.gs.so_desc.elements = elements;
3764 memcpy(elements, so_desc->elements, so_desc->element_count * sizeof(*elements));
3765 }
3766
3767 return WINED3D_OK;
3768 }
3769
3770 void find_ds_compile_args(const struct wined3d_state *state, const struct wined3d_shader *shader,
3771 struct ds_compile_args *args, const struct wined3d_context *context)
3772 {
3773 const struct wined3d_shader *geometry_shader = state->shader[WINED3D_SHADER_TYPE_GEOMETRY];
3774 const struct wined3d_shader *pixel_shader = state->shader[WINED3D_SHADER_TYPE_PIXEL];
3775 const struct wined3d_shader *hull_shader = state->shader[WINED3D_SHADER_TYPE_HULL];
3776 const struct wined3d_gl_info *gl_info = context->gl_info;
3777
3778 args->tessellator_output_primitive = hull_shader->u.hs.tessellator_output_primitive;
3779 args->tessellator_partitioning = hull_shader->u.hs.tessellator_partitioning;
3780
3781 args->output_count = geometry_shader ? geometry_shader->limits->packed_input
3782 : pixel_shader ? pixel_shader->limits->packed_input : shader->limits->packed_output;
3783 args->next_shader_type = geometry_shader ? WINED3D_SHADER_TYPE_GEOMETRY : WINED3D_SHADER_TYPE_PIXEL;
3784
3785 args->render_offscreen = context->render_offscreen;
3786
3787 init_interpolation_compile_args(args->interpolation_mode,
3788 args->next_shader_type == WINED3D_SHADER_TYPE_PIXEL ? pixel_shader : NULL, gl_info);
3789
3790 args->padding = 0;
3791 }
3792
3793 void find_gs_compile_args(const struct wined3d_state *state, const struct wined3d_shader *shader,
3794 struct gs_compile_args *args, const struct wined3d_context *context)
3795 {
3796 const struct wined3d_shader *pixel_shader = state->shader[WINED3D_SHADER_TYPE_PIXEL];
3797 const struct wined3d_gl_info *gl_info = context->gl_info;
3798
3799 args->output_count = pixel_shader ? pixel_shader->limits->packed_input : shader->limits->packed_output;
3800
3801 init_interpolation_compile_args(args->interpolation_mode, pixel_shader, gl_info);
3802 }
3803
3804 void find_ps_compile_args(const struct wined3d_state *state, const struct wined3d_shader *shader,
3805 BOOL position_transformed, struct ps_compile_args *args, const struct wined3d_context *context)
3806 {
3807 const struct wined3d_d3d_info *d3d_info = context->d3d_info;
3808 const struct wined3d_gl_info *gl_info = context->gl_info;
3809 const struct wined3d_texture *texture;
3810 unsigned int i;
3811
3812 memset(args, 0, sizeof(*args)); /* FIXME: Make sure all bits are set. */
3813 if (!gl_info->supported[ARB_FRAMEBUFFER_SRGB] && needs_srgb_write(context, state, state->fb))
3814 {
3815 static unsigned int warned = 0;
3816
3817 args->srgb_correction = 1;
3818 if (state->render_states[WINED3D_RS_ALPHABLENDENABLE] && !warned++)
3819 WARN("Blending into a sRGB render target with no GL_ARB_framebuffer_sRGB "
3820 "support, expect rendering artifacts.\n");
3821 }
3822
3823 if (shader->reg_maps.shader_version.major == 1
3824 && shader->reg_maps.shader_version.minor <= 3)
3825 {
3826 for (i = 0; i < shader->limits->sampler; ++i)
3827 {
3828 DWORD flags = state->texture_states[i][WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS];
3829
3830 if (flags & WINED3D_TTFF_PROJECTED)
3831 {
3832 DWORD tex_transform = flags & ~WINED3D_TTFF_PROJECTED;
3833
3834 if (!state->shader[WINED3D_SHADER_TYPE_VERTEX])
3835 {
3836 enum wined3d_shader_resource_type resource_type = shader->reg_maps.resource_info[i].type;
3837 unsigned int j;
3838 unsigned int index = state->texture_states[i][WINED3D_TSS_TEXCOORD_INDEX];
3839 DWORD max_valid = WINED3D_TTFF_COUNT4;
3840
3841 for (j = 0; j < state->vertex_declaration->element_count; ++j)
3842 {
3843 struct wined3d_vertex_declaration_element *element =
3844 &state->vertex_declaration->elements[j];
3845
3846 if (element->usage == WINED3D_DECL_USAGE_TEXCOORD
3847 && element->usage_idx == index)
3848 {
3849 max_valid = element->format->component_count;
3850 break;
3851 }
3852 }
3853 if (!tex_transform || tex_transform > max_valid)
3854 {
3855 WARN("Fixing up projected texture transform flags from %#x to %#x.\n",
3856 tex_transform, max_valid);
3857 tex_transform = max_valid;
3858 }
3859 if ((resource_type == WINED3D_SHADER_RESOURCE_TEXTURE_1D && tex_transform > WINED3D_TTFF_COUNT1)
3860 || (resource_type == WINED3D_SHADER_RESOURCE_TEXTURE_2D
3861 && tex_transform > WINED3D_TTFF_COUNT2)
3862 || (resource_type == WINED3D_SHADER_RESOURCE_TEXTURE_3D
3863 && tex_transform > WINED3D_TTFF_COUNT3))
3864 tex_transform |= WINED3D_PSARGS_PROJECTED;
3865 else
3866 {
3867 WARN("Application requested projected texture with unsuitable texture coordinates.\n");
3868 WARN("(texture unit %u, transform flags %#x, sampler type %u).\n",
3869 i, tex_transform, resource_type);
3870 }
3871 }
3872 else
3873 tex_transform = WINED3D_TTFF_COUNT4 | WINED3D_PSARGS_PROJECTED;
3874
3875 args->tex_transform |= tex_transform << i * WINED3D_PSARGS_TEXTRANSFORM_SHIFT;
3876 }
3877 }
3878 }
3879 if (shader->reg_maps.shader_version.major == 1
3880 && shader->reg_maps.shader_version.minor <= 4)
3881 {
3882 for (i = 0; i < shader->limits->sampler; ++i)
3883 {
3884 const struct wined3d_texture *texture = state->textures[i];
3885
3886 if (!shader->reg_maps.resource_info[i].type)
3887 continue;
3888
3889 /* Treat unbound textures as 2D. The dummy texture will provide
3890 * the proper sample value. The tex_types bitmap defaults to
3891 * 2D because of the memset. */
3892 if (!texture)
3893 continue;
3894
3895 switch (texture->target)
3896 {
3897 /* RECT textures are distinguished from 2D textures via np2_fixup */
3898 default:
3899 break;
3900
3901 case GL_TEXTURE_3D:
3902 args->tex_types |= WINED3D_SHADER_TEX_3D << i * WINED3D_PSARGS_TEXTYPE_SHIFT;
3903 break;
3904
3905 case GL_TEXTURE_CUBE_MAP_ARB:
3906 args->tex_types |= WINED3D_SHADER_TEX_CUBE << i * WINED3D_PSARGS_TEXTYPE_SHIFT;
3907 break;
3908 }
3909 }
3910 }
3911
3912 if (shader->reg_maps.shader_version.major >= 4)
3913 {
3914 /* In SM4+ we use dcl_sampler in order to determine if we should use shadow sampler. */
3915 args->shadow = 0;
3916 for (i = 0 ; i < MAX_FRAGMENT_SAMPLERS; ++i)
3917 args->color_fixup[i] = COLOR_FIXUP_IDENTITY;
3918 args->np2_fixup = 0;
3919 }
3920 else
3921 {
3922 for (i = 0; i < MAX_FRAGMENT_SAMPLERS; ++i)
3923 {
3924 if (!shader->reg_maps.resource_info[i].type)
3925 continue;
3926
3927 texture = state->textures[i];
3928 if (!texture)
3929 {
3930 args->color_fixup[i] = COLOR_FIXUP_IDENTITY;
3931 continue;
3932 }
3933 if (can_use_texture_swizzle(gl_info, texture->resource.format))
3934 args->color_fixup[i] = COLOR_FIXUP_IDENTITY;
3935 else
3936 args->color_fixup[i] = texture->resource.format->color_fixup;
3937
3938 if (texture->resource.format_flags & WINED3DFMT_FLAG_SHADOW)
3939 args->shadow |= 1u << i;
3940
3941 /* Flag samplers that need NP2 texcoord fixup. */
3942 if (!(texture->flags & WINED3D_TEXTURE_POW2_MAT_IDENT))
3943 args->np2_fixup |= (1u << i);
3944 }
3945 }
3946
3947 if (shader->reg_maps.shader_version.major >= 3)
3948 {
3949 if (position_transformed)
3950 args->vp_mode = WINED3D_VP_MODE_NONE;
3951 else if (use_vs(state))
3952 args->vp_mode = WINED3D_VP_MODE_SHADER;
3953 else
3954 args->vp_mode = WINED3D_VP_MODE_FF;
3955 args->fog = WINED3D_FFP_PS_FOG_OFF;
3956 }
3957 else
3958 {
3959 args->vp_mode = WINED3D_VP_MODE_SHADER;
3960 if (state->render_states[WINED3D_RS_FOGENABLE])
3961 {
3962 switch (state->render_states[WINED3D_RS_FOGTABLEMODE])
3963 {
3964 case WINED3D_FOG_NONE:
3965 if (position_transformed || use_vs(state))
3966 {
3967 args->fog = WINED3D_FFP_PS_FOG_LINEAR;
3968 break;
3969 }
3970
3971 switch (state->render_states[WINED3D_RS_FOGVERTEXMODE])
3972 {
3973 case WINED3D_FOG_NONE: /* Fall through. */
3974 case WINED3D_FOG_LINEAR: args->fog = WINED3D_FFP_PS_FOG_LINEAR; break;
3975 case WINED3D_FOG_EXP: args->fog = WINED3D_FFP_PS_FOG_EXP; break;
3976 case WINED3D_FOG_EXP2: args->fog = WINED3D_FFP_PS_FOG_EXP2; break;
3977 }
3978 break;
3979
3980 case WINED3D_FOG_LINEAR: args->fog = WINED3D_FFP_PS_FOG_LINEAR; break;
3981 case WINED3D_FOG_EXP: args->fog = WINED3D_FFP_PS_FOG_EXP; break;
3982 case WINED3D_FOG_EXP2: args->fog = WINED3D_FFP_PS_FOG_EXP2; break;
3983 }
3984 }
3985 else
3986 {
3987 args->fog = WINED3D_FFP_PS_FOG_OFF;
3988 }
3989 }
3990
3991 if (context->d3d_info->limits.varying_count < wined3d_max_compat_varyings(context->gl_info))
3992 {
3993 const struct wined3d_shader *vs = state->shader[WINED3D_SHADER_TYPE_VERTEX];
3994
3995 args->texcoords_initialized = 0;
3996 for (i = 0; i < MAX_TEXTURES; ++i)
3997 {
3998 if (vs)
3999 {
4000 if (state->shader[WINED3D_SHADER_TYPE_VERTEX]->reg_maps.output_registers & (1u << i))
4001 args->texcoords_initialized |= 1u << i;
4002 }
4003 else
4004 {
4005 const struct wined3d_stream_info *si = &context->stream_info;
4006 unsigned int coord_idx = state->texture_states[i][WINED3D_TSS_TEXCOORD_INDEX];
4007
4008 if ((state->texture_states[i][WINED3D_TSS_TEXCOORD_INDEX] >> WINED3D_FFP_TCI_SHIFT)
4009 & WINED3D_FFP_TCI_MASK
4010 || (coord_idx < MAX_TEXTURES && (si->use_map & (1u << (WINED3D_FFP_TEXCOORD0 + coord_idx)))))
4011 args->texcoords_initialized |= 1u << i;
4012 }
4013 }
4014 }
4015 else
4016 {
4017 args->texcoords_initialized = (1u << MAX_TEXTURES) - 1;
4018 }
4019
4020 args->pointsprite = state->render_states[WINED3D_RS_POINTSPRITEENABLE]
4021 && state->gl_primitive_type == GL_POINTS;
4022
4023 if (gl_info->supported[WINED3D_GL_LEGACY_CONTEXT])
4024 args->alpha_test_func = WINED3D_CMP_ALWAYS - 1;
4025 else
4026 args->alpha_test_func = (state->render_states[WINED3D_RS_ALPHATESTENABLE]
4027 ? wined3d_sanitize_cmp_func(state->render_states[WINED3D_RS_ALPHAFUNC])
4028 : WINED3D_CMP_ALWAYS) - 1;
4029
4030 if (d3d_info->emulated_flatshading)
4031 args->flatshading = state->render_states[WINED3D_RS_SHADEMODE] == WINED3D_SHADE_FLAT;
4032
4033 args->render_offscreen = shader->reg_maps.vpos && gl_info->supported[ARB_FRAGMENT_COORD_CONVENTIONS]
4034 ? context->render_offscreen : 0;
4035 }
4036
4037 static HRESULT pixel_shader_init(struct wined3d_shader *shader, struct wined3d_device *device,
4038 const struct wined3d_shader_desc *desc, void *parent, const struct wined3d_parent_ops *parent_ops)
4039 {
4040 const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
4041 unsigned int i, highest_reg_used = 0, num_regs_used = 0;
4042 HRESULT hr;
4043
4044 if (FAILED(hr = shader_init(shader, device, desc, device->adapter->d3d_info.limits.ps_uniform_count,
4045 WINED3D_SHADER_TYPE_PIXEL, parent, parent_ops)))
4046 return hr;
4047
4048 for (i = 0; i < MAX_REG_INPUT; ++i)
4049 {
4050 if (shader->u.ps.input_reg_used & (1u << i))
4051 {
4052 ++num_regs_used;
4053 highest_reg_used = i;
4054 }
4055 }
4056
4057 /* Don't do any register mapping magic if it is not needed, or if we can't
4058 * achieve anything anyway */
4059 if (highest_reg_used < (gl_info->limits.glsl_varyings / 4)
4060 || num_regs_used > (gl_info->limits.glsl_varyings / 4)
4061 || shader->reg_maps.shader_version.major >= 4)
4062 {
4063 if (num_regs_used > (gl_info->limits.glsl_varyings / 4))
4064 {
4065 /* This happens with relative addressing. The input mapper function
4066 * warns about this if the higher registers are declared too, so
4067 * don't write a FIXME here */
4068 WARN("More varying registers used than supported\n");
4069 }
4070
4071 for (i = 0; i < MAX_REG_INPUT; ++i)
4072 {
4073 shader->u.ps.input_reg_map[i] = i;
4074 }
4075
4076 shader->u.ps.declared_in_count = highest_reg_used + 1;
4077 }
4078 else
4079 {
4080 shader->u.ps.declared_in_count = 0;
4081 for (i = 0; i < MAX_REG_INPUT; ++i)
4082 {
4083 if (shader->u.ps.input_reg_used & (1u << i))
4084 shader->u.ps.input_reg_map[i] = shader->u.ps.declared_in_count++;
4085 else shader->u.ps.input_reg_map[i] = ~0U;
4086 }
4087 }
4088
4089 return WINED3D_OK;
4090 }
4091
4092 void pixelshader_update_resource_types(struct wined3d_shader *shader, WORD tex_types)
4093 {
4094 struct wined3d_shader_reg_maps *reg_maps = &shader->reg_maps;
4095 struct wined3d_shader_resource_info *resource_info = reg_maps->resource_info;
4096 unsigned int i;
4097
4098 if (reg_maps->shader_version.major != 1) return;
4099
4100 for (i = 0; i < shader->limits->sampler; ++i)
4101 {
4102 /* We don't sample from this sampler. */
4103 if (!resource_info[i].type)
4104 continue;
4105
4106 switch ((tex_types >> i * WINED3D_PSARGS_TEXTYPE_SHIFT) & WINED3D_PSARGS_TEXTYPE_MASK)
4107 {
4108 case WINED3D_SHADER_TEX_2D:
4109 resource_info[i].type = WINED3D_SHADER_RESOURCE_TEXTURE_2D;
4110 break;
4111
4112 case WINED3D_SHADER_TEX_3D:
4113 resource_info[i].type = WINED3D_SHADER_RESOURCE_TEXTURE_3D;
4114 break;
4115
4116 case WINED3D_SHADER_TEX_CUBE:
4117 resource_info[i].type = WINED3D_SHADER_RESOURCE_TEXTURE_CUBE;
4118 break;
4119 }
4120 }
4121 }
4122
4123 HRESULT CDECL wined3d_shader_create_cs(struct wined3d_device *device, const struct wined3d_shader_desc *desc,
4124 void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_shader **shader)
4125 {
4126 struct wined3d_shader *object;
4127 HRESULT hr;
4128
4129 TRACE("device %p, desc %p, parent %p, parent_ops %p, shader %p.\n",
4130 device, desc, parent, parent_ops, shader);
4131
4132 if (!(object = heap_alloc_zero(sizeof(*object))))
4133 return E_OUTOFMEMORY;
4134
4135 if (FAILED(hr = shader_init(object, device, desc, 0, WINED3D_SHADER_TYPE_COMPUTE, parent, parent_ops)))
4136 {
4137 WARN("Failed to initialize compute shader, hr %#x.\n", hr);
4138 heap_free(object);
4139 return hr;
4140 }
4141
4142 wined3d_cs_init_object(device->cs, wined3d_shader_init_object, object);
4143
4144 TRACE("Created compute shader %p.\n", object);
4145 *shader = object;
4146
4147 return WINED3D_OK;
4148 }
4149
4150 HRESULT CDECL wined3d_shader_create_ds(struct wined3d_device *device, const struct wined3d_shader_desc *desc,
4151 void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_shader **shader)
4152 {
4153 struct wined3d_shader *object;
4154 HRESULT hr;
4155
4156 TRACE("device %p, desc %p, parent %p, parent_ops %p, shader %p.\n",
4157 device, desc, parent, parent_ops, shader);
4158
4159 if (!(object = heap_alloc_zero(sizeof(*object))))
4160 return E_OUTOFMEMORY;
4161
4162 if (FAILED(hr = shader_init(object, device, desc, 0, WINED3D_SHADER_TYPE_DOMAIN, parent, parent_ops)))
4163 {
4164 WARN("Failed to initialize domain shader, hr %#x.\n", hr);
4165 heap_free(object);
4166 return hr;
4167 }
4168
4169 wined3d_cs_init_object(device->cs, wined3d_shader_init_object, object);
4170
4171 TRACE("Created domain shader %p.\n", object);
4172 *shader = object;
4173
4174 return WINED3D_OK;
4175 }
4176
4177 HRESULT CDECL wined3d_shader_create_gs(struct wined3d_device *device, const struct wined3d_shader_desc *desc,
4178 const struct wined3d_stream_output_desc *so_desc, void *parent,
4179 const struct wined3d_parent_ops *parent_ops, struct wined3d_shader **shader)
4180 {
4181 struct wined3d_shader *object;
4182 HRESULT hr;
4183
4184 TRACE("device %p, desc %p, so_desc %p, parent %p, parent_ops %p, shader %p.\n",
4185 device, desc, so_desc, parent, parent_ops, shader);
4186
4187 if (!(object = heap_alloc_zero(sizeof(*object))))
4188 return E_OUTOFMEMORY;
4189
4190 if (FAILED(hr = geometry_shader_init(object, device, desc, so_desc, parent, parent_ops)))
4191 {
4192 WARN("Failed to initialize geometry shader, hr %#x.\n", hr);
4193 heap_free(object);
4194 return hr;
4195 }
4196
4197 wined3d_cs_init_object(device->cs, wined3d_shader_init_object, object);
4198
4199 TRACE("Created geometry shader %p.\n", object);
4200 *shader = object;
4201
4202 return WINED3D_OK;
4203 }
4204
4205 HRESULT CDECL wined3d_shader_create_hs(struct wined3d_device *device, const struct wined3d_shader_desc *desc,
4206 void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_shader **shader)
4207 {
4208 struct wined3d_shader *object;
4209 HRESULT hr;
4210
4211 TRACE("device %p, desc %p, parent %p, parent_ops %p, shader %p.\n",
4212 device, desc, parent, parent_ops, shader);
4213
4214 if (!(object = heap_alloc_zero(sizeof(*object))))
4215 return E_OUTOFMEMORY;
4216
4217 if (FAILED(hr = shader_init(object, device, desc, 0, WINED3D_SHADER_TYPE_HULL, parent, parent_ops)))
4218 {
4219 WARN("Failed to initialize hull shader, hr %#x.\n", hr);
4220 heap_free(object);
4221 return hr;
4222 }
4223
4224 wined3d_cs_init_object(device->cs, wined3d_shader_init_object, object);
4225
4226 TRACE("Created hull shader %p.\n", object);
4227 *shader = object;
4228
4229 return WINED3D_OK;
4230 }
4231
4232 HRESULT CDECL wined3d_shader_create_ps(struct wined3d_device *device, const struct wined3d_shader_desc *desc,
4233 void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_shader **shader)
4234 {
4235 struct wined3d_shader *object;
4236 HRESULT hr;
4237
4238 TRACE("device %p, desc %p, parent %p, parent_ops %p, shader %p.\n",
4239 device, desc, parent, parent_ops, shader);
4240
4241 if (!(object = heap_alloc_zero(sizeof(*object))))
4242 return E_OUTOFMEMORY;
4243
4244 if (FAILED(hr = pixel_shader_init(object, device, desc, parent, parent_ops)))
4245 {
4246 WARN("Failed to initialize pixel shader, hr %#x.\n", hr);
4247 heap_free(object);
4248 return hr;
4249 }
4250
4251 wined3d_cs_init_object(device->cs, wined3d_shader_init_object, object);
4252
4253 TRACE("Created pixel shader %p.\n", object);
4254 *shader = object;
4255
4256 return WINED3D_OK;
4257 }
4258
4259 HRESULT CDECL wined3d_shader_create_vs(struct wined3d_device *device, const struct wined3d_shader_desc *desc,
4260 void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_shader **shader)
4261 {
4262 struct wined3d_shader *object;
4263 HRESULT hr;
4264
4265 TRACE("device %p, desc %p, parent %p, parent_ops %p, shader %p.\n",
4266 device, desc, parent, parent_ops, shader);
4267
4268 if (!(object = heap_alloc_zero(sizeof(*object))))
4269 return E_OUTOFMEMORY;
4270
4271 if (FAILED(hr = vertex_shader_init(object, device, desc, parent, parent_ops)))
4272 {
4273 WARN("Failed to initialize vertex shader, hr %#x.\n", hr);
4274 heap_free(object);
4275 return hr;
4276 }
4277
4278 wined3d_cs_init_object(device->cs, wined3d_shader_init_object, object);
4279
4280 TRACE("Created vertex shader %p.\n", object);
4281 *shader = object;
4282
4283 return WINED3D_OK;
4284 }
Windows API implementation