?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
msxml3: Fix attributes formatting.
[wine/multimedia.git] / dlls / wined3d / shader.c
blob9466ed156dde59e1b056f5c2f15529bf56590da7
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 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
27 #include <math.h>
28 #include <stdio.h>
29 #include <string.h>
30
31 #include "wined3d_private.h"
32
33 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
34 WINE_DECLARE_DEBUG_CHANNEL(d3d);
35
36 static const char * const shader_opcode_names[] =
37 {
38 /* WINED3DSIH_ABS */ "abs",
39 /* WINED3DSIH_ADD */ "add",
40 /* WINED3DSIH_AND */ "and",
41 /* WINED3DSIH_BEM */ "bem",
42 /* WINED3DSIH_BREAK */ "break",
43 /* WINED3DSIH_BREAKC */ "breakc",
44 /* WINED3DSIH_BREAKP */ "breakp",
45 /* WINED3DSIH_CALL */ "call",
46 /* WINED3DSIH_CALLNZ */ "callnz",
47 /* WINED3DSIH_CMP */ "cmp",
48 /* WINED3DSIH_CND */ "cnd",
49 /* WINED3DSIH_CRS */ "crs",
50 /* WINED3DSIH_CUT */ "cut",
51 /* WINED3DSIH_DCL */ "dcl",
52 /* WINED3DSIH_DEF */ "def",
53 /* WINED3DSIH_DEFB */ "defb",
54 /* WINED3DSIH_DEFI */ "defi",
55 /* WINED3DSIH_DIV */ "div",
56 /* WINED3DSIH_DP2ADD */ "dp2add",
57 /* WINED3DSIH_DP3 */ "dp3",
58 /* WINED3DSIH_DP4 */ "dp4",
59 /* WINED3DSIH_DST */ "dst",
60 /* WINED3DSIH_DSX */ "dsx",
61 /* WINED3DSIH_DSY */ "dsy",
62 /* WINED3DSIH_ELSE */ "else",
63 /* WINED3DSIH_EMIT */ "emit",
64 /* WINED3DSIH_ENDIF */ "endif",
65 /* WINED3DSIH_ENDLOOP */ "endloop",
66 /* WINED3DSIH_ENDREP */ "endrep",
67 /* WINED3DSIH_EXP */ "exp",
68 /* WINED3DSIH_EXPP */ "expp",
69 /* WINED3DSIH_FRC */ "frc",
70 /* WINED3DSIH_FTOI */ "ftoi",
71 /* WINED3DSIH_IADD */ "iadd",
72 /* WINED3DSIH_IEQ */ "ieq",
73 /* WINED3DSIH_IF */ "if",
74 /* WINED3DSIH_IFC */ "ifc",
75 /* WINED3DSIH_IGE */ "ige",
76 /* WINED3DSIH_IMUL */ "imul",
77 /* WINED3DSIH_ITOF */ "itof",
78 /* WINED3DSIH_LABEL */ "label",
79 /* WINED3DSIH_LD */ "ld",
80 /* WINED3DSIH_LIT */ "lit",
81 /* WINED3DSIH_LOG */ "log",
82 /* WINED3DSIH_LOGP */ "logp",
83 /* WINED3DSIH_LOOP */ "loop",
84 /* WINED3DSIH_LRP */ "lrp",
85 /* WINED3DSIH_LT */ "lt",
86 /* WINED3DSIH_M3x2 */ "m3x2",
87 /* WINED3DSIH_M3x3 */ "m3x3",
88 /* WINED3DSIH_M3x4 */ "m3x4",
89 /* WINED3DSIH_M4x3 */ "m4x3",
90 /* WINED3DSIH_M4x4 */ "m4x4",
91 /* WINED3DSIH_MAD */ "mad",
92 /* WINED3DSIH_MAX */ "max",
93 /* WINED3DSIH_MIN */ "min",
94 /* WINED3DSIH_MOV */ "mov",
95 /* WINED3DSIH_MOVA */ "mova",
96 /* WINED3DSIH_MOVC */ "movc",
97 /* WINED3DSIH_MUL */ "mul",
98 /* WINED3DSIH_NOP */ "nop",
99 /* WINED3DSIH_NRM */ "nrm",
100 /* WINED3DSIH_PHASE */ "phase",
101 /* WINED3DSIH_POW */ "pow",
102 /* WINED3DSIH_RCP */ "rcp",
103 /* WINED3DSIH_REP */ "rep",
104 /* WINED3DSIH_RET */ "ret",
105 /* WINED3DSIH_RSQ */ "rsq",
106 /* WINED3DSIH_SAMPLE */ "sample",
107 /* WINED3DSIH_SAMPLE_GRAD */ "sample_d",
108 /* WINED3DSIH_SAMPLE_LOD */ "sample_l",
109 /* WINED3DSIH_SETP */ "setp",
110 /* WINED3DSIH_SGE */ "sge",
111 /* WINED3DSIH_SGN */ "sgn",
112 /* WINED3DSIH_SINCOS */ "sincos",
113 /* WINED3DSIH_SLT */ "slt",
114 /* WINED3DSIH_SQRT */ "sqrt",
115 /* WINED3DSIH_SUB */ "sub",
116 /* WINED3DSIH_TEX */ "texld",
117 /* WINED3DSIH_TEXBEM */ "texbem",
118 /* WINED3DSIH_TEXBEML */ "texbeml",
119 /* WINED3DSIH_TEXCOORD */ "texcrd",
120 /* WINED3DSIH_TEXDEPTH */ "texdepth",
121 /* WINED3DSIH_TEXDP3 */ "texdp3",
122 /* WINED3DSIH_TEXDP3TEX */ "texdp3tex",
123 /* WINED3DSIH_TEXKILL */ "texkill",
124 /* WINED3DSIH_TEXLDD */ "texldd",
125 /* WINED3DSIH_TEXLDL */ "texldl",
126 /* WINED3DSIH_TEXM3x2DEPTH */ "texm3x2depth",
127 /* WINED3DSIH_TEXM3x2PAD */ "texm3x2pad",
128 /* WINED3DSIH_TEXM3x2TEX */ "texm3x2tex",
129 /* WINED3DSIH_TEXM3x3 */ "texm3x3",
130 /* WINED3DSIH_TEXM3x3DIFF */ "texm3x3diff",
131 /* WINED3DSIH_TEXM3x3PAD */ "texm3x3pad",
132 /* WINED3DSIH_TEXM3x3SPEC */ "texm3x3spec",
133 /* WINED3DSIH_TEXM3x3TEX */ "texm3x3tex",
134 /* WINED3DSIH_TEXM3x3VSPEC */ "texm3x3vspec",
135 /* WINED3DSIH_TEXREG2AR */ "texreg2ar",
136 /* WINED3DSIH_TEXREG2GB */ "texreg2gb",
137 /* WINED3DSIH_TEXREG2RGB */ "texreg2rgb",
138 /* WINED3DSIH_UTOF */ "utof",
139 };
140
141 static const char * const semantic_names[] =
142 {
143 /* WINED3DDECLUSAGE_POSITION */ "SV_POSITION",
144 /* WINED3DDECLUSAGE_BLENDWEIGHT */ "BLENDWEIGHT",
145 /* WINED3DDECLUSAGE_BLENDINDICES */ "BLENDINDICES",
146 /* WINED3DDECLUSAGE_NORMAL */ "NORMAL",
147 /* WINED3DDECLUSAGE_PSIZE */ "PSIZE",
148 /* WINED3DDECLUSAGE_TEXCOORD */ "TEXCOORD",
149 /* WINED3DDECLUSAGE_TANGENT */ "TANGENT",
150 /* WINED3DDECLUSAGE_BINORMAL */ "BINORMAL",
151 /* WINED3DDECLUSAGE_TESSFACTOR */ "TESSFACTOR",
152 /* WINED3DDECLUSAGE_POSITIONT */ "POSITIONT",
153 /* WINED3DDECLUSAGE_COLOR */ "COLOR",
154 /* WINED3DDECLUSAGE_FOG */ "FOG",
155 /* WINED3DDECLUSAGE_DEPTH */ "DEPTH",
156 /* WINED3DDECLUSAGE_SAMPLE */ "SAMPLE",
157 };
158
159 static const char *shader_semantic_name_from_usage(WINED3DDECLUSAGE usage)
160 {
161 if (usage >= sizeof(semantic_names) / sizeof(*semantic_names))
162 {
163 FIXME("Unrecognized usage %#x.\n", usage);
164 return "UNRECOGNIZED";
165 }
166
167 return semantic_names[usage];
168 }
169
170 static WINED3DDECLUSAGE shader_usage_from_semantic_name(const char *name)
171 {
172 unsigned int i;
173
174 for (i = 0; i < sizeof(semantic_names) / sizeof(*semantic_names); ++i)
175 {
176 if (!strcmp(name, semantic_names[i])) return i;
177 }
178
179 return ~0U;
180 }
181
182 BOOL shader_match_semantic(const char *semantic_name, WINED3DDECLUSAGE usage)
183 {
184 return !strcmp(semantic_name, shader_semantic_name_from_usage(usage));
185 }
186
187 static void shader_signature_from_semantic(struct wined3d_shader_signature_element *e,
188 const struct wined3d_shader_semantic *s)
189 {
190 e->semantic_name = shader_semantic_name_from_usage(s->usage);
191 e->semantic_idx = s->usage_idx;
192 e->sysval_semantic = 0;
193 e->component_type = 0;
194 e->register_idx = s->reg.reg.idx;
195 e->mask = s->reg.write_mask;
196 }
197
198 static void shader_signature_from_usage(struct wined3d_shader_signature_element *e,
199 WINED3DDECLUSAGE usage, UINT usage_idx, UINT reg_idx, DWORD write_mask)
200 {
201 e->semantic_name = shader_semantic_name_from_usage(usage);
202 e->semantic_idx = usage_idx;
203 e->sysval_semantic = 0;
204 e->component_type = 0;
205 e->register_idx = reg_idx;
206 e->mask = write_mask;
207 }
208
209 static const struct wined3d_shader_frontend *shader_select_frontend(DWORD version_token)
210 {
211 switch (version_token >> 16)
212 {
213 case WINED3D_SM1_VS:
214 case WINED3D_SM1_PS:
215 return &sm1_shader_frontend;
216
217 case WINED3D_SM4_PS:
218 case WINED3D_SM4_VS:
219 case WINED3D_SM4_GS:
220 return &sm4_shader_frontend;
221
222 default:
223 FIXME("Unrecognised version token %#x\n", version_token);
224 return NULL;
225 }
226 }
227
228 void shader_buffer_clear(struct wined3d_shader_buffer *buffer)
229 {
230 buffer->buffer[0] = '\0';
231 buffer->bsize = 0;
232 buffer->lineNo = 0;
233 buffer->newline = TRUE;
234 }
235
236 BOOL shader_buffer_init(struct wined3d_shader_buffer *buffer)
237 {
238 buffer->buffer = HeapAlloc(GetProcessHeap(), 0, SHADER_PGMSIZE);
239 if (!buffer->buffer)
240 {
241 ERR("Failed to allocate shader buffer memory.\n");
242 return FALSE;
243 }
244
245 shader_buffer_clear(buffer);
246 return TRUE;
247 }
248
249 void shader_buffer_free(struct wined3d_shader_buffer *buffer)
250 {
251 HeapFree(GetProcessHeap(), 0, buffer->buffer);
252 }
253
254 int shader_vaddline(struct wined3d_shader_buffer *buffer, const char *format, va_list args)
255 {
256 char *base = buffer->buffer + buffer->bsize;
257 int rc;
258
259 rc = vsnprintf(base, SHADER_PGMSIZE - 1 - buffer->bsize, format, args);
260
261 if (rc < 0 /* C89 */ || (unsigned int)rc > SHADER_PGMSIZE - 1 - buffer->bsize /* C99 */)
262 {
263 ERR("The buffer allocated for the shader program string "
264 "is too small at %d bytes.\n", SHADER_PGMSIZE);
265 buffer->bsize = SHADER_PGMSIZE - 1;
266 return -1;
267 }
268
269 if (buffer->newline)
270 {
271 TRACE("GL HW (%u, %u) : %s", buffer->lineNo + 1, buffer->bsize, base);
272 buffer->newline = FALSE;
273 }
274 else
275 {
276 TRACE("%s", base);
277 }
278
279 buffer->bsize += rc;
280 if (buffer->buffer[buffer->bsize-1] == '\n')
281 {
282 ++buffer->lineNo;
283 buffer->newline = TRUE;
284 }
285
286 return 0;
287 }
288
289 int shader_addline(struct wined3d_shader_buffer *buffer, const char *format, ...)
290 {
291 va_list args;
292 int ret;
293
294 va_start(args, format);
295 ret = shader_vaddline(buffer, format, args);
296 va_end(args);
297
298 return ret;
299 }
300
301 static void shader_init(struct wined3d_shader *shader, struct wined3d_device *device,
302 void *parent, const struct wined3d_parent_ops *parent_ops)
303 {
304 shader->ref = 1;
305 shader->device = device;
306 shader->parent = parent;
307 shader->parent_ops = parent_ops;
308 list_init(&shader->linked_programs);
309 list_add_head(&device->shaders, &shader->shader_list_entry);
310 }
311
312 /* Convert floating point offset relative to a register file to an absolute
313 * offset for float constants. */
314 static unsigned int shader_get_float_offset(WINED3DSHADER_PARAM_REGISTER_TYPE register_type, UINT register_idx)
315 {
316 switch (register_type)
317 {
318 case WINED3DSPR_CONST: return register_idx;
319 case WINED3DSPR_CONST2: return 2048 + register_idx;
320 case WINED3DSPR_CONST3: return 4096 + register_idx;
321 case WINED3DSPR_CONST4: return 6144 + register_idx;
322 default:
323 FIXME("Unsupported register type: %u.\n", register_type);
324 return register_idx;
325 }
326 }
327
328 static void shader_delete_constant_list(struct list *clist)
329 {
330 struct local_constant *constant;
331 struct list *ptr;
332
333 ptr = list_head(clist);
334 while (ptr)
335 {
336 constant = LIST_ENTRY(ptr, struct local_constant, entry);
337 ptr = list_next(clist, ptr);
338 HeapFree(GetProcessHeap(), 0, constant);
339 }
340 list_init(clist);
341 }
342
343 static inline void set_bitmap_bit(DWORD *bitmap, DWORD bit)
344 {
345 DWORD idx, shift;
346 idx = bit >> 5;
347 shift = bit & 0x1f;
348 bitmap[idx] |= (1 << shift);
349 }
350
351 static void shader_record_register_usage(struct wined3d_shader *shader, struct wined3d_shader_reg_maps *reg_maps,
352 const struct wined3d_shader_register *reg, enum wined3d_shader_type shader_type)
353 {
354 switch (reg->type)
355 {
356 case WINED3DSPR_TEXTURE: /* WINED3DSPR_ADDR */
357 if (shader_type == WINED3D_SHADER_TYPE_PIXEL) reg_maps->texcoord |= 1 << reg->idx;
358 else reg_maps->address |= 1 << reg->idx;
359 break;
360
361 case WINED3DSPR_TEMP:
362 reg_maps->temporary |= 1 << reg->idx;
363 break;
364
365 case WINED3DSPR_INPUT:
366 if (shader_type == WINED3D_SHADER_TYPE_PIXEL)
367 {
368 if (reg->rel_addr)
369 {
370 /* If relative addressing is used, we must assume that all registers
371 * are used. Even if it is a construct like v3[aL], we can't assume
372 * that v0, v1 and v2 aren't read because aL can be negative */
373 unsigned int i;
374 for (i = 0; i < MAX_REG_INPUT; ++i)
375 {
376 shader->u.ps.input_reg_used[i] = TRUE;
377 }
378 }
379 else
380 {
381 shader->u.ps.input_reg_used[reg->idx] = TRUE;
382 }
383 }
384 else reg_maps->input_registers |= 1 << reg->idx;
385 break;
386
387 case WINED3DSPR_RASTOUT:
388 if (reg->idx == 1) reg_maps->fog = 1;
389 break;
390
391 case WINED3DSPR_MISCTYPE:
392 if (shader_type == WINED3D_SHADER_TYPE_PIXEL)
393 {
394 if (!reg->idx) reg_maps->vpos = 1;
395 else if (reg->idx == 1) reg_maps->usesfacing = 1;
396 }
397 break;
398
399 case WINED3DSPR_CONST:
400 if (reg->rel_addr)
401 {
402 if (reg->idx < reg_maps->min_rel_offset) reg_maps->min_rel_offset = reg->idx;
403 if (reg->idx > reg_maps->max_rel_offset) reg_maps->max_rel_offset = reg->idx;
404 reg_maps->usesrelconstF = TRUE;
405 }
406 else
407 {
408 set_bitmap_bit(reg_maps->constf, reg->idx);
409 }
410 break;
411
412 case WINED3DSPR_CONSTINT:
413 reg_maps->integer_constants |= (1 << reg->idx);
414 break;
415
416 case WINED3DSPR_CONSTBOOL:
417 reg_maps->boolean_constants |= (1 << reg->idx);
418 break;
419
420 case WINED3DSPR_COLOROUT:
421 reg_maps->rt_mask |= (1 << reg->idx);
422 break;
423
424 default:
425 TRACE("Not recording register of type %#x and idx %u\n", reg->type, reg->idx);
426 break;
427 }
428 }
429
430 static unsigned int get_instr_extra_regcount(enum WINED3D_SHADER_INSTRUCTION_HANDLER instr, unsigned int param)
431 {
432 switch (instr)
433 {
434 case WINED3DSIH_M4x4:
435 case WINED3DSIH_M3x4:
436 return param == 1 ? 3 : 0;
437
438 case WINED3DSIH_M4x3:
439 case WINED3DSIH_M3x3:
440 return param == 1 ? 2 : 0;
441
442 case WINED3DSIH_M3x2:
443 return param == 1 ? 1 : 0;
444
445 default:
446 return 0;
447 }
448 }
449
450 /* Note that this does not count the loop register as an address register. */
451 static HRESULT shader_get_registers_used(struct wined3d_shader *shader, const struct wined3d_shader_frontend *fe,
452 struct wined3d_shader_reg_maps *reg_maps, struct wined3d_shader_signature_element *input_signature,
453 struct wined3d_shader_signature_element *output_signature, const DWORD *byte_code, DWORD constf_size)
454 {
455 unsigned int cur_loop_depth = 0, max_loop_depth = 0;
456 void *fe_data = shader->frontend_data;
457 struct wined3d_shader_version shader_version;
458 const DWORD *ptr = byte_code;
459
460 memset(reg_maps, 0, sizeof(*reg_maps));
461 reg_maps->min_rel_offset = ~0U;
462
463 fe->shader_read_header(fe_data, &ptr, &shader_version);
464 reg_maps->shader_version = shader_version;
465
466 reg_maps->constf = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
467 sizeof(*reg_maps->constf) * ((constf_size + 31) / 32));
468 if (!reg_maps->constf)
469 {
470 ERR("Failed to allocate constant map memory.\n");
471 return E_OUTOFMEMORY;
472 }
473
474 while (!fe->shader_is_end(fe_data, &ptr))
475 {
476 struct wined3d_shader_instruction ins;
477 const char *comment;
478 UINT comment_size;
479 UINT param_size;
480
481 /* Skip comments. */
482 fe->shader_read_comment(&ptr, &comment, &comment_size);
483 if (comment) continue;
484
485 /* Fetch opcode. */
486 fe->shader_read_opcode(fe_data, &ptr, &ins, &param_size);
487
488 /* Unhandled opcode, and its parameters. */
489 if (ins.handler_idx == WINED3DSIH_TABLE_SIZE)
490 {
491 TRACE("Skipping unrecognized instruction.\n");
492 ptr += param_size;
493 continue;
494 }
495
496 /* Handle declarations. */
497 if (ins.handler_idx == WINED3DSIH_DCL)
498 {
499 struct wined3d_shader_semantic semantic;
500
501 fe->shader_read_semantic(&ptr, &semantic);
502
503 switch (semantic.reg.reg.type)
504 {
505 /* Mark input registers used. */
506 case WINED3DSPR_INPUT:
507 reg_maps->input_registers |= 1 << semantic.reg.reg.idx;
508 shader_signature_from_semantic(&input_signature[semantic.reg.reg.idx], &semantic);
509 break;
510
511 /* Vertex shader: mark 3.0 output registers used, save token. */
512 case WINED3DSPR_OUTPUT:
513 reg_maps->output_registers |= 1 << semantic.reg.reg.idx;
514 shader_signature_from_semantic(&output_signature[semantic.reg.reg.idx], &semantic);
515 if (semantic.usage == WINED3DDECLUSAGE_FOG) reg_maps->fog = 1;
516 break;
517
518 /* Save sampler usage token. */
519 case WINED3DSPR_SAMPLER:
520 reg_maps->sampler_type[semantic.reg.reg.idx] = semantic.sampler_type;
521 break;
522
523 default:
524 TRACE("Not recording DCL register type %#x.\n", semantic.reg.reg.type);
525 break;
526 }
527 }
528 else if (ins.handler_idx == WINED3DSIH_DEF)
529 {
530 struct wined3d_shader_src_param rel_addr;
531 struct wined3d_shader_dst_param dst;
532
533 local_constant *lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant));
534 if (!lconst) return E_OUTOFMEMORY;
535
536 fe->shader_read_dst_param(fe_data, &ptr, &dst, &rel_addr);
537 lconst->idx = dst.reg.idx;
538
539 memcpy(lconst->value, ptr, 4 * sizeof(DWORD));
540 ptr += 4;
541
542 /* In pixel shader 1.X shaders, the constants are clamped between [-1;1] */
543 if (shader_version.major == 1 && shader_version.type == WINED3D_SHADER_TYPE_PIXEL)
544 {
545 float *value = (float *)lconst->value;
546 if (value[0] < -1.0f) value[0] = -1.0f;
547 else if (value[0] > 1.0f) value[0] = 1.0f;
548 if (value[1] < -1.0f) value[1] = -1.0f;
549 else if (value[1] > 1.0f) value[1] = 1.0f;
550 if (value[2] < -1.0f) value[2] = -1.0f;
551 else if (value[2] > 1.0f) value[2] = 1.0f;
552 if (value[3] < -1.0f) value[3] = -1.0f;
553 else if (value[3] > 1.0f) value[3] = 1.0f;
554 }
555
556 list_add_head(&shader->constantsF, &lconst->entry);
557 }
558 else if (ins.handler_idx == WINED3DSIH_DEFI)
559 {
560 struct wined3d_shader_src_param rel_addr;
561 struct wined3d_shader_dst_param dst;
562
563 local_constant *lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant));
564 if (!lconst) return E_OUTOFMEMORY;
565
566 fe->shader_read_dst_param(fe_data, &ptr, &dst, &rel_addr);
567 lconst->idx = dst.reg.idx;
568
569 memcpy(lconst->value, ptr, 4 * sizeof(DWORD));
570 ptr += 4;
571
572 list_add_head(&shader->constantsI, &lconst->entry);
573 reg_maps->local_int_consts |= (1 << dst.reg.idx);
574 }
575 else if (ins.handler_idx == WINED3DSIH_DEFB)
576 {
577 struct wined3d_shader_src_param rel_addr;
578 struct wined3d_shader_dst_param dst;
579
580 local_constant *lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant));
581 if (!lconst) return E_OUTOFMEMORY;
582
583 fe->shader_read_dst_param(fe_data, &ptr, &dst, &rel_addr);
584 lconst->idx = dst.reg.idx;
585
586 memcpy(lconst->value, ptr, sizeof(DWORD));
587 ++ptr;
588
589 list_add_head(&shader->constantsB, &lconst->entry);
590 reg_maps->local_bool_consts |= (1 << dst.reg.idx);
591 }
592 /* If there's a loop in the shader. */
593 else if (ins.handler_idx == WINED3DSIH_LOOP
594 || ins.handler_idx == WINED3DSIH_REP)
595 {
596 struct wined3d_shader_src_param src, rel_addr;
597
598 fe->shader_read_src_param(fe_data, &ptr, &src, &rel_addr);
599
600 /* Rep and Loop always use an integer constant for the control parameters. */
601 if (ins.handler_idx == WINED3DSIH_REP)
602 {
603 reg_maps->integer_constants |= 1 << src.reg.idx;
604 }
605 else
606 {
607 fe->shader_read_src_param(fe_data, &ptr, &src, &rel_addr);
608 reg_maps->integer_constants |= 1 << src.reg.idx;
609 }
610
611 cur_loop_depth++;
612 if (cur_loop_depth > max_loop_depth) max_loop_depth = cur_loop_depth;
613 }
614 else if (ins.handler_idx == WINED3DSIH_ENDLOOP
615 || ins.handler_idx == WINED3DSIH_ENDREP)
616 {
617 cur_loop_depth--;
618 }
619 /* For subroutine prototypes. */
620 else if (ins.handler_idx == WINED3DSIH_LABEL)
621 {
622 struct wined3d_shader_src_param src, rel_addr;
623
624 fe->shader_read_src_param(fe_data, &ptr, &src, &rel_addr);
625 reg_maps->labels |= 1 << src.reg.idx;
626 }
627 /* Set texture, address, temporary registers. */
628 else
629 {
630 BOOL color0_mov = FALSE;
631 unsigned int i, limit;
632
633 /* This will loop over all the registers and try to
634 * make a bitmask of the ones we're interested in.
635 *
636 * Relative addressing tokens are ignored, but that's
637 * okay, since we'll catch any address registers when
638 * they are initialized (required by spec). */
639 for (i = 0; i < ins.dst_count; ++i)
640 {
641 struct wined3d_shader_src_param dst_rel_addr;
642 struct wined3d_shader_dst_param dst_param;
643
644 fe->shader_read_dst_param(fe_data, &ptr, &dst_param, &dst_rel_addr);
645
646 shader_record_register_usage(shader, reg_maps, &dst_param.reg, shader_version.type);
647
648 /* WINED3DSPR_TEXCRDOUT is the same as WINED3DSPR_OUTPUT. _OUTPUT can be > MAX_REG_TEXCRD and
649 * is used in >= 3.0 shaders. Filter 3.0 shaders to prevent overflows, and also filter pixel
650 * shaders because TECRDOUT isn't used in them, but future register types might cause issues */
651 if (shader_version.type == WINED3D_SHADER_TYPE_VERTEX && shader_version.major < 3)
652 {
653 UINT idx = dst_param.reg.idx;
654
655 switch (dst_param.reg.type)
656 {
657 case WINED3DSPR_RASTOUT:
658 switch (idx)
659 {
660 case 0: /* oPos */
661 reg_maps->output_registers |= 1 << 10;
662 shader_signature_from_usage(&output_signature[10],
663 WINED3DDECLUSAGE_POSITION, 0, 10, WINED3DSP_WRITEMASK_ALL);
664 break;
665
666 case 1: /* oFog */
667 reg_maps->output_registers |= 1 << 11;
668 shader_signature_from_usage(&output_signature[11],
669 WINED3DDECLUSAGE_FOG, 0, 11, WINED3DSP_WRITEMASK_0);
670 break;
671
672 case 2: /* oPts */
673 reg_maps->output_registers |= 1 << 11;
674 shader_signature_from_usage(&output_signature[11],
675 WINED3DDECLUSAGE_PSIZE, 0, 11, WINED3DSP_WRITEMASK_1);
676 break;
677 }
678 break;
679
680 case WINED3DSPR_ATTROUT:
681 if (idx < 2)
682 {
683 idx += 8;
684 if (reg_maps->output_registers & (1 << idx))
685 {
686 output_signature[idx].mask |= dst_param.write_mask;
687 }
688 else
689 {
690 reg_maps->output_registers |= 1 << idx;
691 shader_signature_from_usage(&output_signature[idx],
692 WINED3DDECLUSAGE_COLOR, idx - 8, idx, dst_param.write_mask);
693 }
694 }
695 break;
696
697 case WINED3DSPR_TEXCRDOUT:
698
699 reg_maps->texcoord_mask[idx] |= dst_param.write_mask;
700 if (reg_maps->output_registers & (1 << idx))
701 {
702 output_signature[idx].mask |= dst_param.write_mask;
703 }
704 else
705 {
706 reg_maps->output_registers |= 1 << idx;
707 shader_signature_from_usage(&output_signature[idx],
708 WINED3DDECLUSAGE_TEXCOORD, idx, idx, dst_param.write_mask);
709 }
710 break;
711
712 default:
713 break;
714 }
715 }
716
717 if (shader_version.type == WINED3D_SHADER_TYPE_PIXEL)
718 {
719 if (dst_param.reg.type == WINED3DSPR_COLOROUT && !dst_param.reg.idx)
720 {
721 /* Many 2.0 and 3.0 pixel shaders end with a MOV from a temp register to
722 * COLOROUT 0. If we know this in advance, the ARB shader backend can skip
723 * the mov and perform the sRGB write correction from the source register.
724 *
725 * However, if the mov is only partial, we can't do this, and if the write
726 * comes from an instruction other than MOV it is hard to do as well. If
727 * COLOROUT 0 is overwritten partially later, the marker is dropped again. */
728 shader->u.ps.color0_mov = FALSE;
729 if (ins.handler_idx == WINED3DSIH_MOV
730 && dst_param.write_mask == WINED3DSP_WRITEMASK_ALL)
731 {
732 /* Used later when the source register is read. */
733 color0_mov = TRUE;
734 }
735 }
736 /* Also drop the MOV marker if the source register is overwritten prior to the shader
737 * end
738 */
739 else if (dst_param.reg.type == WINED3DSPR_TEMP
740 && dst_param.reg.idx == shader->u.ps.color0_reg)
741 {
742 shader->u.ps.color0_mov = FALSE;
743 }
744 }
745
746 /* Declare 1.x samplers implicitly, based on the destination reg. number. */
747 if (shader_version.major == 1
748 && (ins.handler_idx == WINED3DSIH_TEX
749 || ins.handler_idx == WINED3DSIH_TEXBEM
750 || ins.handler_idx == WINED3DSIH_TEXBEML
751 || ins.handler_idx == WINED3DSIH_TEXDP3TEX
752 || ins.handler_idx == WINED3DSIH_TEXM3x2TEX
753 || ins.handler_idx == WINED3DSIH_TEXM3x3SPEC
754 || ins.handler_idx == WINED3DSIH_TEXM3x3TEX
755 || ins.handler_idx == WINED3DSIH_TEXM3x3VSPEC
756 || ins.handler_idx == WINED3DSIH_TEXREG2AR
757 || ins.handler_idx == WINED3DSIH_TEXREG2GB
758 || ins.handler_idx == WINED3DSIH_TEXREG2RGB))
759 {
760 /* Fake sampler usage, only set reserved bit and type. */
761 DWORD sampler_code = dst_param.reg.idx;
762
763 TRACE("Setting fake 2D sampler for 1.x pixelshader.\n");
764 reg_maps->sampler_type[sampler_code] = WINED3DSTT_2D;
765
766 /* texbem is only valid with < 1.4 pixel shaders */
767 if (ins.handler_idx == WINED3DSIH_TEXBEM
768 || ins.handler_idx == WINED3DSIH_TEXBEML)
769 {
770 reg_maps->bumpmat |= 1 << dst_param.reg.idx;
771 if (ins.handler_idx == WINED3DSIH_TEXBEML)
772 {
773 reg_maps->luminanceparams |= 1 << dst_param.reg.idx;
774 }
775 }
776 }
777 else if (ins.handler_idx == WINED3DSIH_BEM)
778 {
779 reg_maps->bumpmat |= 1 << dst_param.reg.idx;
780 }
781 }
782
783 if (ins.handler_idx == WINED3DSIH_NRM) reg_maps->usesnrm = 1;
784 else if (ins.handler_idx == WINED3DSIH_DSY) reg_maps->usesdsy = 1;
785 else if (ins.handler_idx == WINED3DSIH_DSX) reg_maps->usesdsx = 1;
786 else if (ins.handler_idx == WINED3DSIH_TEXLDD) reg_maps->usestexldd = 1;
787 else if (ins.handler_idx == WINED3DSIH_TEXLDL) reg_maps->usestexldl = 1;
788 else if (ins.handler_idx == WINED3DSIH_MOVA) reg_maps->usesmova = 1;
789 else if (ins.handler_idx == WINED3DSIH_IFC) reg_maps->usesifc = 1;
790 else if (ins.handler_idx == WINED3DSIH_CALL) reg_maps->usescall = 1;
791 else if (ins.handler_idx == WINED3DSIH_POW) reg_maps->usespow = 1;
792
793 limit = ins.src_count + (ins.predicate ? 1 : 0);
794 for (i = 0; i < limit; ++i)
795 {
796 struct wined3d_shader_src_param src_param, src_rel_addr;
797 unsigned int count;
798
799 fe->shader_read_src_param(fe_data, &ptr, &src_param, &src_rel_addr);
800 count = get_instr_extra_regcount(ins.handler_idx, i);
801
802 shader_record_register_usage(shader, reg_maps, &src_param.reg, shader_version.type);
803 while (count)
804 {
805 ++src_param.reg.idx;
806 shader_record_register_usage(shader, reg_maps, &src_param.reg, shader_version.type);
807 --count;
808 }
809
810 if (color0_mov)
811 {
812 if (src_param.reg.type == WINED3DSPR_TEMP
813 && src_param.swizzle == WINED3DSP_NOSWIZZLE)
814 {
815 shader->u.ps.color0_mov = TRUE;
816 shader->u.ps.color0_reg = src_param.reg.idx;
817 }
818 }
819 }
820 }
821 }
822 reg_maps->loop_depth = max_loop_depth;
823
824 /* PS before 2.0 don't have explicit color outputs. Instead the value of
825 * R0 is written to the render target. */
826 if (shader_version.major < 2 && shader_version.type == WINED3D_SHADER_TYPE_PIXEL)
827 reg_maps->rt_mask |= (1 << 0);
828
829 shader->functionLength = ((const char *)ptr - (const char *)byte_code);
830
831 return WINED3D_OK;
832 }
833
834 unsigned int shader_find_free_input_register(const struct wined3d_shader_reg_maps *reg_maps, unsigned int max)
835 {
836 DWORD map = 1 << max;
837 map |= map - 1;
838 map &= reg_maps->shader_version.major < 3 ? ~reg_maps->texcoord : ~reg_maps->input_registers;
839
840 return wined3d_log2i(map);
841 }
842
843 static void shader_dump_decl_usage(const struct wined3d_shader_semantic *semantic,
844 const struct wined3d_shader_version *shader_version)
845 {
846 TRACE("dcl");
847
848 if (semantic->reg.reg.type == WINED3DSPR_SAMPLER)
849 {
850 switch (semantic->sampler_type)
851 {
852 case WINED3DSTT_2D: TRACE("_2d"); break;
853 case WINED3DSTT_CUBE: TRACE("_cube"); break;
854 case WINED3DSTT_VOLUME: TRACE("_volume"); break;
855 default: TRACE("_unknown_ttype(0x%08x)", semantic->sampler_type);
856 }
857 }
858 else
859 {
860 /* Pixel shaders 3.0 don't have usage semantics. */
861 if (shader_version->major < 3 && shader_version->type == WINED3D_SHADER_TYPE_PIXEL) return;
862 else TRACE("_");
863
864 switch (semantic->usage)
865 {
866 case WINED3DDECLUSAGE_POSITION:
867 TRACE("position%u", semantic->usage_idx);
868 break;
869
870 case WINED3DDECLUSAGE_BLENDINDICES:
871 TRACE("blend");
872 break;
873
874 case WINED3DDECLUSAGE_BLENDWEIGHT:
875 TRACE("weight");
876 break;
877
878 case WINED3DDECLUSAGE_NORMAL:
879 TRACE("normal%u", semantic->usage_idx);
880 break;
881
882 case WINED3DDECLUSAGE_PSIZE:
883 TRACE("psize");
884 break;
885
886 case WINED3DDECLUSAGE_COLOR:
887 if (!semantic->usage_idx) TRACE("color");
888 else TRACE("specular%u", (semantic->usage_idx - 1));
889 break;
890
891 case WINED3DDECLUSAGE_TEXCOORD:
892 TRACE("texture%u", semantic->usage_idx);
893 break;
894
895 case WINED3DDECLUSAGE_TANGENT:
896 TRACE("tangent");
897 break;
898
899 case WINED3DDECLUSAGE_BINORMAL:
900 TRACE("binormal");
901 break;
902
903 case WINED3DDECLUSAGE_TESSFACTOR:
904 TRACE("tessfactor");
905 break;
906
907 case WINED3DDECLUSAGE_POSITIONT:
908 TRACE("positionT%u", semantic->usage_idx);
909 break;
910
911 case WINED3DDECLUSAGE_FOG:
912 TRACE("fog");
913 break;
914
915 case WINED3DDECLUSAGE_DEPTH:
916 TRACE("depth");
917 break;
918
919 case WINED3DDECLUSAGE_SAMPLE:
920 TRACE("sample");
921 break;
922
923 default:
924 FIXME("unknown_semantics(0x%08x)", semantic->usage);
925 }
926 }
927 }
928
929 static void shader_dump_register(const struct wined3d_shader_register *reg,
930 const struct wined3d_shader_version *shader_version)
931 {
932 static const char * const rastout_reg_names[] = {"oPos", "oFog", "oPts"};
933 static const char * const misctype_reg_names[] = {"vPos", "vFace"};
934 UINT offset = reg->idx;
935
936 switch (reg->type)
937 {
938 case WINED3DSPR_TEMP:
939 TRACE("r");
940 break;
941
942 case WINED3DSPR_INPUT:
943 TRACE("v");
944 break;
945
946 case WINED3DSPR_CONST:
947 case WINED3DSPR_CONST2:
948 case WINED3DSPR_CONST3:
949 case WINED3DSPR_CONST4:
950 TRACE("c");
951 offset = shader_get_float_offset(reg->type, reg->idx);
952 break;
953
954 case WINED3DSPR_TEXTURE: /* vs: case WINED3DSPR_ADDR */
955 TRACE("%c", shader_version->type == WINED3D_SHADER_TYPE_PIXEL ? 't' : 'a');
956 break;
957
958 case WINED3DSPR_RASTOUT:
959 TRACE("%s", rastout_reg_names[reg->idx]);
960 break;
961
962 case WINED3DSPR_COLOROUT:
963 TRACE("oC");
964 break;
965
966 case WINED3DSPR_DEPTHOUT:
967 TRACE("oDepth");
968 break;
969
970 case WINED3DSPR_ATTROUT:
971 TRACE("oD");
972 break;
973
974 case WINED3DSPR_TEXCRDOUT:
975 /* Vertex shaders >= 3.0 use general purpose output registers
976 * (WINED3DSPR_OUTPUT), which can include an address token. */
977 if (shader_version->major >= 3) TRACE("o");
978 else TRACE("oT");
979 break;
980
981 case WINED3DSPR_CONSTINT:
982 TRACE("i");
983 break;
984
985 case WINED3DSPR_CONSTBOOL:
986 TRACE("b");
987 break;
988
989 case WINED3DSPR_LABEL:
990 TRACE("l");
991 break;
992
993 case WINED3DSPR_LOOP:
994 TRACE("aL");
995 break;
996
997 case WINED3DSPR_SAMPLER:
998 TRACE("s");
999 break;
1000
1001 case WINED3DSPR_MISCTYPE:
1002 if (reg->idx > 1) FIXME("Unhandled misctype register %u.\n", reg->idx);
1003 else TRACE("%s", misctype_reg_names[reg->idx]);
1004 break;
1005
1006 case WINED3DSPR_PREDICATE:
1007 TRACE("p");
1008 break;
1009
1010 case WINED3DSPR_IMMCONST:
1011 TRACE("l");
1012 break;
1013
1014 case WINED3DSPR_CONSTBUFFER:
1015 TRACE("cb");
1016 break;
1017
1018 case WINED3DSPR_NULL:
1019 TRACE("null");
1020 break;
1021
1022 case WINED3DSPR_RESOURCE:
1023 TRACE("t");
1024 break;
1025
1026 default:
1027 TRACE("unhandled_rtype(%#x)", reg->type);
1028 break;
1029 }
1030
1031 if (reg->type == WINED3DSPR_IMMCONST)
1032 {
1033 TRACE("(");
1034 switch (reg->immconst_type)
1035 {
1036 case WINED3D_IMMCONST_SCALAR:
1037 TRACE("%.8e", *(const float *)reg->immconst_data);
1038 break;
1039
1040 case WINED3D_IMMCONST_VEC4:
1041 TRACE("%.8e, %.8e, %.8e, %.8e",
1042 *(const float *)&reg->immconst_data[0], *(const float *)&reg->immconst_data[1],
1043 *(const float *)&reg->immconst_data[2], *(const float *)&reg->immconst_data[3]);
1044 break;
1045
1046 default:
1047 TRACE("<unhandled immconst_type %#x>", reg->immconst_type);
1048 break;
1049 }
1050 TRACE(")");
1051 }
1052 else if (reg->type != WINED3DSPR_RASTOUT
1053 && reg->type != WINED3DSPR_MISCTYPE
1054 && reg->type != WINED3DSPR_NULL)
1055 {
1056 if (reg->array_idx != ~0U)
1057 {
1058 TRACE("%u[%u", offset, reg->array_idx);
1059 if (reg->rel_addr)
1060 {
1061 TRACE(" + ");
1062 shader_dump_src_param(reg->rel_addr, shader_version);
1063 }
1064 TRACE("]");
1065 }
1066 else
1067 {
1068 if (reg->rel_addr)
1069 {
1070 TRACE("[");
1071 shader_dump_src_param(reg->rel_addr, shader_version);
1072 TRACE(" + ");
1073 }
1074 TRACE("%u", offset);
1075 if (reg->rel_addr) TRACE("]");
1076 }
1077 }
1078 }
1079
1080 void shader_dump_dst_param(const struct wined3d_shader_dst_param *param,
1081 const struct wined3d_shader_version *shader_version)
1082 {
1083 DWORD write_mask = param->write_mask;
1084
1085 shader_dump_register(&param->reg, shader_version);
1086
1087 if (write_mask && write_mask != WINED3DSP_WRITEMASK_ALL)
1088 {
1089 static const char *write_mask_chars = "xyzw";
1090
1091 TRACE(".");
1092 if (write_mask & WINED3DSP_WRITEMASK_0) TRACE("%c", write_mask_chars[0]);
1093 if (write_mask & WINED3DSP_WRITEMASK_1) TRACE("%c", write_mask_chars[1]);
1094 if (write_mask & WINED3DSP_WRITEMASK_2) TRACE("%c", write_mask_chars[2]);
1095 if (write_mask & WINED3DSP_WRITEMASK_3) TRACE("%c", write_mask_chars[3]);
1096 }
1097 }
1098
1099 void shader_dump_src_param(const struct wined3d_shader_src_param *param,
1100 const struct wined3d_shader_version *shader_version)
1101 {
1102 DWORD src_modifier = param->modifiers;
1103 DWORD swizzle = param->swizzle;
1104
1105 if (src_modifier == WINED3DSPSM_NEG
1106 || src_modifier == WINED3DSPSM_BIASNEG
1107 || src_modifier == WINED3DSPSM_SIGNNEG
1108 || src_modifier == WINED3DSPSM_X2NEG
1109 || src_modifier == WINED3DSPSM_ABSNEG)
1110 TRACE("-");
1111 else if (src_modifier == WINED3DSPSM_COMP)
1112 TRACE("1-");
1113 else if (src_modifier == WINED3DSPSM_NOT)
1114 TRACE("!");
1115
1116 if (src_modifier == WINED3DSPSM_ABS || src_modifier == WINED3DSPSM_ABSNEG)
1117 TRACE("abs(");
1118
1119 shader_dump_register(&param->reg, shader_version);
1120
1121 if (src_modifier)
1122 {
1123 switch (src_modifier)
1124 {
1125 case WINED3DSPSM_NONE: break;
1126 case WINED3DSPSM_NEG: break;
1127 case WINED3DSPSM_NOT: break;
1128 case WINED3DSPSM_BIAS: TRACE("_bias"); break;
1129 case WINED3DSPSM_BIASNEG: TRACE("_bias"); break;
1130 case WINED3DSPSM_SIGN: TRACE("_bx2"); break;
1131 case WINED3DSPSM_SIGNNEG: TRACE("_bx2"); break;
1132 case WINED3DSPSM_COMP: break;
1133 case WINED3DSPSM_X2: TRACE("_x2"); break;
1134 case WINED3DSPSM_X2NEG: TRACE("_x2"); break;
1135 case WINED3DSPSM_DZ: TRACE("_dz"); break;
1136 case WINED3DSPSM_DW: TRACE("_dw"); break;
1137 case WINED3DSPSM_ABSNEG: TRACE(")"); break;
1138 case WINED3DSPSM_ABS: TRACE(")"); break;
1139 default: TRACE("_unknown_modifier(%#x)", src_modifier);
1140 }
1141 }
1142
1143 if (swizzle != WINED3DSP_NOSWIZZLE)
1144 {
1145 static const char *swizzle_chars = "xyzw";
1146 DWORD swizzle_x = swizzle & 0x03;
1147 DWORD swizzle_y = (swizzle >> 2) & 0x03;
1148 DWORD swizzle_z = (swizzle >> 4) & 0x03;
1149 DWORD swizzle_w = (swizzle >> 6) & 0x03;
1150
1151 if (swizzle_x == swizzle_y
1152 && swizzle_x == swizzle_z
1153 && swizzle_x == swizzle_w)
1154 {
1155 TRACE(".%c", swizzle_chars[swizzle_x]);
1156 }
1157 else
1158 {
1159 TRACE(".%c%c%c%c", swizzle_chars[swizzle_x], swizzle_chars[swizzle_y],
1160 swizzle_chars[swizzle_z], swizzle_chars[swizzle_w]);
1161 }
1162 }
1163 }
1164
1165 /* Shared code in order to generate the bulk of the shader string.
1166 * NOTE: A description of how to parse tokens can be found on MSDN. */
1167 void shader_generate_main(const struct wined3d_shader *shader, struct wined3d_shader_buffer *buffer,
1168 const struct wined3d_shader_reg_maps *reg_maps, const DWORD *byte_code, void *backend_ctx)
1169 {
1170 struct wined3d_device *device = shader->device;
1171 const struct wined3d_shader_frontend *fe = shader->frontend;
1172 void *fe_data = shader->frontend_data;
1173 struct wined3d_shader_src_param dst_rel_addr[2];
1174 struct wined3d_shader_src_param src_rel_addr[4];
1175 struct wined3d_shader_dst_param dst_param[2];
1176 struct wined3d_shader_src_param src_param[4];
1177 struct wined3d_shader_version shader_version;
1178 struct wined3d_shader_loop_state loop_state;
1179 struct wined3d_shader_instruction ins;
1180 struct wined3d_shader_tex_mx tex_mx;
1181 struct wined3d_shader_context ctx;
1182 const DWORD *ptr = byte_code;
1183 DWORD i;
1184
1185 /* Initialize current parsing state. */
1186 tex_mx.current_row = 0;
1187 loop_state.current_depth = 0;
1188 loop_state.current_reg = 0;
1189
1190 ctx.shader = shader;
1191 ctx.gl_info = &device->adapter->gl_info;
1192 ctx.reg_maps = reg_maps;
1193 ctx.buffer = buffer;
1194 ctx.tex_mx = &tex_mx;
1195 ctx.loop_state = &loop_state;
1196 ctx.backend_data = backend_ctx;
1197
1198 ins.ctx = &ctx;
1199 ins.dst = dst_param;
1200 ins.src = src_param;
1201
1202 fe->shader_read_header(fe_data, &ptr, &shader_version);
1203
1204 while (!fe->shader_is_end(fe_data, &ptr))
1205 {
1206 const char *comment;
1207 UINT comment_size;
1208 UINT param_size;
1209
1210 /* Skip comment tokens. */
1211 fe->shader_read_comment(&ptr, &comment, &comment_size);
1212 if (comment) continue;
1213
1214 /* Read opcode. */
1215 fe->shader_read_opcode(fe_data, &ptr, &ins, &param_size);
1216
1217 /* Unknown opcode and its parameters. */
1218 if (ins.handler_idx == WINED3DSIH_TABLE_SIZE)
1219 {
1220 TRACE("Skipping unrecognized instruction.\n");
1221 ptr += param_size;
1222 continue;
1223 }
1224
1225 /* Nothing to do. */
1226 if (ins.handler_idx == WINED3DSIH_DCL
1227 || ins.handler_idx == WINED3DSIH_NOP
1228 || ins.handler_idx == WINED3DSIH_DEF
1229 || ins.handler_idx == WINED3DSIH_DEFI
1230 || ins.handler_idx == WINED3DSIH_DEFB
1231 || ins.handler_idx == WINED3DSIH_PHASE)
1232 {
1233 ptr += param_size;
1234 continue;
1235 }
1236
1237 /* Destination tokens */
1238 for (i = 0; i < ins.dst_count; ++i)
1239 {
1240 fe->shader_read_dst_param(fe_data, &ptr, &dst_param[i], &dst_rel_addr[i]);
1241 }
1242
1243 /* Predication token */
1244 if (ins.predicate)
1245 {
1246 FIXME("Predicates not implemented.\n");
1247 ins.predicate = *ptr++;
1248 }
1249
1250 /* Other source tokens */
1251 for (i = 0; i < ins.src_count; ++i)
1252 {
1253 fe->shader_read_src_param(fe_data, &ptr, &src_param[i], &src_rel_addr[i]);
1254 }
1255
1256 /* Call appropriate function for output target */
1257 device->shader_backend->shader_handle_instruction(&ins);
1258 }
1259 }
1260
1261 static void shader_dump_ins_modifiers(const struct wined3d_shader_dst_param *dst)
1262 {
1263 DWORD mmask = dst->modifiers;
1264
1265 switch (dst->shift)
1266 {
1267 case 0: break;
1268 case 13: TRACE("_d8"); break;
1269 case 14: TRACE("_d4"); break;
1270 case 15: TRACE("_d2"); break;
1271 case 1: TRACE("_x2"); break;
1272 case 2: TRACE("_x4"); break;
1273 case 3: TRACE("_x8"); break;
1274 default: TRACE("_unhandled_shift(%d)", dst->shift); break;
1275 }
1276
1277 if (mmask & WINED3DSPDM_SATURATE) TRACE("_sat");
1278 if (mmask & WINED3DSPDM_PARTIALPRECISION) TRACE("_pp");
1279 if (mmask & WINED3DSPDM_MSAMPCENTROID) TRACE("_centroid");
1280
1281 mmask &= ~(WINED3DSPDM_SATURATE | WINED3DSPDM_PARTIALPRECISION | WINED3DSPDM_MSAMPCENTROID);
1282 if (mmask) FIXME("_unrecognized_modifier(%#x)", mmask);
1283 }
1284
1285 static void shader_trace_init(const struct wined3d_shader_frontend *fe, void *fe_data, const DWORD *byte_code)
1286 {
1287 struct wined3d_shader_version shader_version;
1288 const DWORD *ptr = byte_code;
1289 const char *type_prefix;
1290 DWORD i;
1291
1292 TRACE("Parsing %p.\n", byte_code);
1293
1294 fe->shader_read_header(fe_data, &ptr, &shader_version);
1295
1296 switch (shader_version.type)
1297 {
1298 case WINED3D_SHADER_TYPE_VERTEX:
1299 type_prefix = "vs";
1300 break;
1301
1302 case WINED3D_SHADER_TYPE_GEOMETRY:
1303 type_prefix = "gs";
1304 break;
1305
1306 case WINED3D_SHADER_TYPE_PIXEL:
1307 type_prefix = "ps";
1308 break;
1309
1310 default:
1311 FIXME("Unhandled shader type %#x.\n", shader_version.type);
1312 type_prefix = "unknown";
1313 break;
1314 }
1315
1316 TRACE("%s_%u_%u\n", type_prefix, shader_version.major, shader_version.minor);
1317
1318 while (!fe->shader_is_end(fe_data, &ptr))
1319 {
1320 struct wined3d_shader_instruction ins;
1321 const char *comment;
1322 UINT comment_size;
1323 UINT param_size;
1324
1325 /* comment */
1326 fe->shader_read_comment(&ptr, &comment, &comment_size);
1327 if (comment)
1328 {
1329 if (comment_size > 4 && *(const DWORD *)comment == WINEMAKEFOURCC('T', 'E', 'X', 'T'))
1330 {
1331 const char *end = comment + comment_size;
1332 const char *ptr = comment + 4;
1333 const char *line = ptr;
1334
1335 TRACE("// TEXT\n");
1336 while (ptr != end)
1337 {
1338 if (*ptr == '\n')
1339 {
1340 UINT len = ptr - line;
1341 if (len && *(ptr - 1) == '\r') --len;
1342 TRACE("// %s\n", debugstr_an(line, len));
1343 line = ++ptr;
1344 }
1345 else ++ptr;
1346 }
1347 if (line != ptr) TRACE("// %s\n", debugstr_an(line, ptr - line));
1348 }
1349 else TRACE("// %s\n", debugstr_an(comment, comment_size));
1350 continue;
1351 }
1352
1353 fe->shader_read_opcode(fe_data, &ptr, &ins, &param_size);
1354 if (ins.handler_idx == WINED3DSIH_TABLE_SIZE)
1355 {
1356 TRACE("Skipping unrecognized instruction.\n");
1357 ptr += param_size;
1358 continue;
1359 }
1360
1361 if (ins.handler_idx == WINED3DSIH_DCL)
1362 {
1363 struct wined3d_shader_semantic semantic;
1364
1365 fe->shader_read_semantic(&ptr, &semantic);
1366
1367 shader_dump_decl_usage(&semantic, &shader_version);
1368 shader_dump_ins_modifiers(&semantic.reg);
1369 TRACE(" ");
1370 shader_dump_dst_param(&semantic.reg, &shader_version);
1371 }
1372 else if (ins.handler_idx == WINED3DSIH_DEF)
1373 {
1374 struct wined3d_shader_src_param rel_addr;
1375 struct wined3d_shader_dst_param dst;
1376
1377 fe->shader_read_dst_param(fe_data, &ptr, &dst, &rel_addr);
1378
1379 TRACE("def c%u = %f, %f, %f, %f", shader_get_float_offset(dst.reg.type, dst.reg.idx),
1380 *(const float *)(ptr),
1381 *(const float *)(ptr + 1),
1382 *(const float *)(ptr + 2),
1383 *(const float *)(ptr + 3));
1384 ptr += 4;
1385 }
1386 else if (ins.handler_idx == WINED3DSIH_DEFI)
1387 {
1388 struct wined3d_shader_src_param rel_addr;
1389 struct wined3d_shader_dst_param dst;
1390
1391 fe->shader_read_dst_param(fe_data, &ptr, &dst, &rel_addr);
1392
1393 TRACE("defi i%u = %d, %d, %d, %d", dst.reg.idx,
1394 *(ptr),
1395 *(ptr + 1),
1396 *(ptr + 2),
1397 *(ptr + 3));
1398 ptr += 4;
1399 }
1400 else if (ins.handler_idx == WINED3DSIH_DEFB)
1401 {
1402 struct wined3d_shader_src_param rel_addr;
1403 struct wined3d_shader_dst_param dst;
1404
1405 fe->shader_read_dst_param(fe_data, &ptr, &dst, &rel_addr);
1406
1407 TRACE("defb b%u = %s", dst.reg.idx, *ptr ? "true" : "false");
1408 ++ptr;
1409 }
1410 else
1411 {
1412 struct wined3d_shader_src_param dst_rel_addr[2];
1413 struct wined3d_shader_src_param src_rel_addr;
1414 struct wined3d_shader_dst_param dst_param[2];
1415 struct wined3d_shader_src_param src_param;
1416
1417 for (i = 0; i < ins.dst_count; ++i)
1418 {
1419 fe->shader_read_dst_param(fe_data, &ptr, &dst_param[i], &dst_rel_addr[i]);
1420 }
1421
1422 /* Print out predication source token first - it follows
1423 * the destination token. */
1424 if (ins.predicate)
1425 {
1426 fe->shader_read_src_param(fe_data, &ptr, &src_param, &src_rel_addr);
1427 TRACE("(");
1428 shader_dump_src_param(&src_param, &shader_version);
1429 TRACE(") ");
1430 }
1431
1432 /* PixWin marks instructions with the coissue flag with a '+' */
1433 if (ins.coissue) TRACE("+");
1434
1435 TRACE("%s", shader_opcode_names[ins.handler_idx]);
1436
1437 if (ins.handler_idx == WINED3DSIH_IFC
1438 || ins.handler_idx == WINED3DSIH_BREAKC)
1439 {
1440 switch (ins.flags)
1441 {
1442 case COMPARISON_GT: TRACE("_gt"); break;
1443 case COMPARISON_EQ: TRACE("_eq"); break;
1444 case COMPARISON_GE: TRACE("_ge"); break;
1445 case COMPARISON_LT: TRACE("_lt"); break;
1446 case COMPARISON_NE: TRACE("_ne"); break;
1447 case COMPARISON_LE: TRACE("_le"); break;
1448 default: TRACE("_(%u)", ins.flags);
1449 }
1450 }
1451 else if (ins.handler_idx == WINED3DSIH_TEX
1452 && shader_version.major >= 2
1453 && (ins.flags & WINED3DSI_TEXLD_PROJECT))
1454 {
1455 TRACE("p");
1456 }
1457
1458 /* We already read the destination tokens, print them. */
1459 for (i = 0; i < ins.dst_count; ++i)
1460 {
1461 shader_dump_ins_modifiers(&dst_param[i]);
1462 TRACE(!i ? " " : ", ");
1463 shader_dump_dst_param(&dst_param[i], &shader_version);
1464 }
1465
1466 /* Other source tokens */
1467 for (i = ins.dst_count; i < (ins.dst_count + ins.src_count); ++i)
1468 {
1469 fe->shader_read_src_param(fe_data, &ptr, &src_param, &src_rel_addr);
1470 TRACE(!i ? " " : ", ");
1471 shader_dump_src_param(&src_param, &shader_version);
1472 }
1473 }
1474 TRACE("\n");
1475 }
1476 }
1477
1478 static void shader_cleanup(struct wined3d_shader *shader)
1479 {
1480 shader->device->shader_backend->shader_destroy(shader);
1481 HeapFree(GetProcessHeap(), 0, shader->reg_maps.constf);
1482 HeapFree(GetProcessHeap(), 0, shader->function);
1483 shader_delete_constant_list(&shader->constantsF);
1484 shader_delete_constant_list(&shader->constantsB);
1485 shader_delete_constant_list(&shader->constantsI);
1486 list_remove(&shader->shader_list_entry);
1487
1488 if (shader->frontend && shader->frontend_data)
1489 shader->frontend->shader_free(shader->frontend_data);
1490 }
1491
1492 static void shader_none_handle_instruction(const struct wined3d_shader_instruction *ins) {}
1493 static void shader_none_select(const struct wined3d_context *context, BOOL usePS, BOOL useVS) {}
1494 static void shader_none_select_depth_blt(void *shader_priv, const struct wined3d_gl_info *gl_info,
1495 enum tex_types tex_type, const SIZE *ds_mask_size) {}
1496 static void shader_none_deselect_depth_blt(void *shader_priv, const struct wined3d_gl_info *gl_info) {}
1497 static void shader_none_update_float_vertex_constants(struct wined3d_device *device, UINT start, UINT count) {}
1498 static void shader_none_update_float_pixel_constants(struct wined3d_device *device, UINT start, UINT count) {}
1499 static void shader_none_load_constants(const struct wined3d_context *context, char usePS, char useVS) {}
1500 static void shader_none_load_np2fixup_constants(void *shader_priv,
1501 const struct wined3d_gl_info *gl_info, const struct wined3d_state *state) {}
1502 static void shader_none_destroy(struct wined3d_shader *shader) {}
1503 static HRESULT shader_none_alloc(struct wined3d_device *device) {return WINED3D_OK;}
1504 static void shader_none_free(struct wined3d_device *device) {}
1505 static BOOL shader_none_dirty_const(void) {return FALSE;}
1506
1507 static void shader_none_get_caps(const struct wined3d_gl_info *gl_info, struct shader_caps *caps)
1508 {
1509 /* Set the shader caps to 0 for the none shader backend */
1510 caps->VertexShaderVersion = 0;
1511 caps->MaxVertexShaderConst = 0;
1512 caps->PixelShaderVersion = 0;
1513 caps->PixelShader1xMaxValue = 0.0f;
1514 caps->MaxPixelShaderConst = 0;
1515 caps->VSClipping = FALSE;
1516 }
1517
1518 static BOOL shader_none_color_fixup_supported(struct color_fixup_desc fixup)
1519 {
1520 if (TRACE_ON(d3d_shader) && TRACE_ON(d3d))
1521 {
1522 TRACE("Checking support for fixup:\n");
1523 dump_color_fixup_desc(fixup);
1524 }
1525
1526 /* Faked to make some apps happy. */
1527 if (!is_complex_fixup(fixup))
1528 {
1529 TRACE("[OK]\n");
1530 return TRUE;
1531 }
1532
1533 TRACE("[FAILED]\n");
1534 return FALSE;
1535 }
1536
1537 const struct wined3d_shader_backend_ops none_shader_backend =
1538 {
1539 shader_none_handle_instruction,
1540 shader_none_select,
1541 shader_none_select_depth_blt,
1542 shader_none_deselect_depth_blt,
1543 shader_none_update_float_vertex_constants,
1544 shader_none_update_float_pixel_constants,
1545 shader_none_load_constants,
1546 shader_none_load_np2fixup_constants,
1547 shader_none_destroy,
1548 shader_none_alloc,
1549 shader_none_free,
1550 shader_none_dirty_const,
1551 shader_none_get_caps,
1552 shader_none_color_fixup_supported,
1553 };
1554
1555 static HRESULT shader_set_function(struct wined3d_shader *shader, const DWORD *byte_code,
1556 const struct wined3d_shader_signature *output_signature, DWORD float_const_count)
1557 {
1558 struct wined3d_shader_reg_maps *reg_maps = &shader->reg_maps;
1559 const struct wined3d_shader_frontend *fe;
1560 HRESULT hr;
1561
1562 TRACE("shader %p, byte_code %p, output_signature %p, float_const_count %u.\n",
1563 shader, byte_code, output_signature, float_const_count);
1564
1565 fe = shader_select_frontend(*byte_code);
1566 if (!fe)
1567 {
1568 FIXME("Unable to find frontend for shader.\n");
1569 return WINED3DERR_INVALIDCALL;
1570 }
1571 shader->frontend = fe;
1572 shader->frontend_data = fe->shader_init(byte_code, output_signature);
1573 if (!shader->frontend_data)
1574 {
1575 FIXME("Failed to initialize frontend.\n");
1576 return WINED3DERR_INVALIDCALL;
1577 }
1578
1579 /* First pass: trace shader. */
1580 if (TRACE_ON(d3d_shader))
1581 shader_trace_init(fe, shader->frontend_data, byte_code);
1582
1583 /* Initialize immediate constant lists. */
1584 list_init(&shader->constantsF);
1585 list_init(&shader->constantsB);
1586 list_init(&shader->constantsI);
1587
1588 /* Second pass: figure out which registers are used, what the semantics are, etc. */
1589 hr = shader_get_registers_used(shader, fe,
1590 reg_maps, shader->input_signature, shader->output_signature,
1591 byte_code, float_const_count);
1592 if (FAILED(hr)) return hr;
1593
1594 shader->function = HeapAlloc(GetProcessHeap(), 0, shader->functionLength);
1595 if (!shader->function)
1596 return E_OUTOFMEMORY;
1597 memcpy(shader->function, byte_code, shader->functionLength);
1598
1599 return WINED3D_OK;
1600 }
1601
1602 ULONG CDECL wined3d_shader_incref(struct wined3d_shader *shader)
1603 {
1604 ULONG refcount = InterlockedIncrement(&shader->ref);
1605
1606 TRACE("%p increasing refcount to %u.\n", shader, refcount);
1607
1608 return refcount;
1609 }
1610
1611 /* Do not call while under the GL lock. */
1612 ULONG CDECL wined3d_shader_decref(struct wined3d_shader *shader)
1613 {
1614 ULONG refcount = InterlockedDecrement(&shader->ref);
1615
1616 TRACE("%p decreasing refcount to %u.\n", shader, refcount);
1617
1618 if (!refcount)
1619 {
1620 shader_cleanup(shader);
1621 shader->parent_ops->wined3d_object_destroyed(shader->parent);
1622 HeapFree(GetProcessHeap(), 0, shader);
1623 }
1624
1625 return refcount;
1626 }
1627
1628 void * CDECL wined3d_shader_get_parent(const struct wined3d_shader *shader)
1629 {
1630 TRACE("shader %p.\n", shader);
1631
1632 return shader->parent;
1633 }
1634
1635 HRESULT CDECL wined3d_shader_get_byte_code(const struct wined3d_shader *shader,
1636 void *byte_code, UINT *byte_code_size)
1637 {
1638 TRACE("shader %p, byte_code %p, byte_code_size %p.\n", shader, byte_code, byte_code_size);
1639
1640 if (!byte_code)
1641 {
1642 *byte_code_size = shader->functionLength;
1643 return WINED3D_OK;
1644 }
1645
1646 if (*byte_code_size < shader->functionLength)
1647 {
1648 /* MSDN claims (for d3d8 at least) that if *byte_code_size is smaller
1649 * than the required size we should write the required size and
1650 * return D3DERR_MOREDATA. That's not actually true. */
1651 return WINED3DERR_INVALIDCALL;
1652 }
1653
1654 memcpy(byte_code, shader->function, shader->functionLength);
1655
1656 return WINED3D_OK;
1657 }
1658
1659 /* Set local constants for d3d8 shaders. */
1660 HRESULT CDECL wined3d_shader_set_local_constants_float(struct wined3d_shader *shader,
1661 UINT start_idx, const float *src_data, UINT count)
1662 {
1663 UINT end_idx = start_idx + count;
1664 UINT i;
1665
1666 TRACE("shader %p, start_idx %u, src_data %p, count %u.\n", shader, start_idx, src_data, count);
1667
1668 if (end_idx > shader->limits.constant_float)
1669 {
1670 WARN("end_idx %u > float constants limit %u.\n",
1671 end_idx, shader->limits.constant_float);
1672 end_idx = shader->limits.constant_float;
1673 }
1674
1675 for (i = start_idx; i < end_idx; ++i)
1676 {
1677 struct local_constant *lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant));
1678 if (!lconst)
1679 return E_OUTOFMEMORY;
1680
1681 lconst->idx = i;
1682 memcpy(lconst->value, src_data + (i - start_idx) * 4 /* 4 components */, 4 * sizeof(float));
1683 list_add_head(&shader->constantsF, &lconst->entry);
1684 }
1685
1686 return WINED3D_OK;
1687 }
1688
1689 void find_vs_compile_args(const struct wined3d_state *state,
1690 const struct wined3d_shader *shader, struct vs_compile_args *args)
1691 {
1692 args->fog_src = state->render_states[WINED3DRS_FOGTABLEMODE]
1693 == WINED3DFOG_NONE ? VS_FOG_COORD : VS_FOG_Z;
1694 args->clip_enabled = state->render_states[WINED3DRS_CLIPPING]
1695 && state->render_states[WINED3DRS_CLIPPLANEENABLE];
1696 args->swizzle_map = shader->device->strided_streams.swizzle_map;
1697 }
1698
1699 static BOOL match_usage(BYTE usage1, BYTE usage_idx1, BYTE usage2, BYTE usage_idx2)
1700 {
1701 if (usage_idx1 != usage_idx2) return FALSE;
1702 if (usage1 == usage2) return TRUE;
1703 if (usage1 == WINED3DDECLUSAGE_POSITION && usage2 == WINED3DDECLUSAGE_POSITIONT) return TRUE;
1704 if (usage2 == WINED3DDECLUSAGE_POSITION && usage1 == WINED3DDECLUSAGE_POSITIONT) return TRUE;
1705
1706 return FALSE;
1707 }
1708
1709 BOOL vshader_get_input(const struct wined3d_shader *shader,
1710 BYTE usage_req, BYTE usage_idx_req, unsigned int *regnum)
1711 {
1712 WORD map = shader->reg_maps.input_registers;
1713 unsigned int i;
1714
1715 for (i = 0; map; map >>= 1, ++i)
1716 {
1717 if (!(map & 1)) continue;
1718
1719 if (match_usage(shader->u.vs.attributes[i].usage,
1720 shader->u.vs.attributes[i].usage_idx, usage_req, usage_idx_req))
1721 {
1722 *regnum = i;
1723 return TRUE;
1724 }
1725 }
1726 return FALSE;
1727 }
1728
1729 static void vertexshader_set_limits(struct wined3d_shader *shader)
1730 {
1731 DWORD shader_version = WINED3D_SHADER_VERSION(shader->reg_maps.shader_version.major,
1732 shader->reg_maps.shader_version.minor);
1733 struct wined3d_device *device = shader->device;
1734
1735 shader->limits.texcoord = 0;
1736 shader->limits.attributes = 16;
1737 shader->limits.packed_input = 0;
1738
1739 switch (shader_version)
1740 {
1741 case WINED3D_SHADER_VERSION(1, 0):
1742 case WINED3D_SHADER_VERSION(1, 1):
1743 shader->limits.temporary = 12;
1744 shader->limits.constant_bool = 0;
1745 shader->limits.constant_int = 0;
1746 shader->limits.address = 1;
1747 shader->limits.packed_output = 12;
1748 shader->limits.sampler = 0;
1749 shader->limits.label = 0;
1750 /* TODO: vs_1_1 has a minimum of 96 constants. What happens when
1751 * a vs_1_1 shader is used on a vs_3_0 capable card that has 256
1752 * constants? */
1753 shader->limits.constant_float = min(256, device->d3d_vshader_constantF);
1754 break;
1755
1756 case WINED3D_SHADER_VERSION(2, 0):
1757 case WINED3D_SHADER_VERSION(2, 1):
1758 shader->limits.temporary = 12;
1759 shader->limits.constant_bool = 16;
1760 shader->limits.constant_int = 16;
1761 shader->limits.address = 1;
1762 shader->limits.packed_output = 12;
1763 shader->limits.sampler = 0;
1764 shader->limits.label = 16;
1765 shader->limits.constant_float = min(256, device->d3d_vshader_constantF);
1766 break;
1767
1768 case WINED3D_SHADER_VERSION(4, 0):
1769 FIXME("Using 3.0 limits for 4.0 shader.\n");
1770 /* Fall through. */
1771
1772 case WINED3D_SHADER_VERSION(3, 0):
1773 shader->limits.temporary = 32;
1774 shader->limits.constant_bool = 32;
1775 shader->limits.constant_int = 32;
1776 shader->limits.address = 1;
1777 shader->limits.packed_output = 12;
1778 shader->limits.sampler = 4;
1779 shader->limits.label = 16; /* FIXME: 2048 */
1780 /* DX10 cards on Windows advertise a d3d9 constant limit of 256
1781 * even though they are capable of supporting much more (GL
1782 * drivers advertise 1024). d3d9.dll and d3d8.dll clamp the
1783 * wined3d-advertised maximum. Clamp the constant limit for <= 3.0
1784 * shaders to 256. */
1785 shader->limits.constant_float = min(256, device->d3d_vshader_constantF);
1786 break;
1787
1788 default:
1789 shader->limits.temporary = 12;
1790 shader->limits.constant_bool = 16;
1791 shader->limits.constant_int = 16;
1792 shader->limits.address = 1;
1793 shader->limits.packed_output = 12;
1794 shader->limits.sampler = 0;
1795 shader->limits.label = 16;
1796 shader->limits.constant_float = min(256, device->d3d_vshader_constantF);
1797 FIXME("Unrecognized vertex shader version \"%u.%u\".\n",
1798 shader->reg_maps.shader_version.major,
1799 shader->reg_maps.shader_version.minor);
1800 }
1801 }
1802
1803 static HRESULT vertexshader_init(struct wined3d_shader *shader, struct wined3d_device *device,
1804 const DWORD *byte_code, const struct wined3d_shader_signature *output_signature,
1805 void *parent, const struct wined3d_parent_ops *parent_ops)
1806 {
1807 struct wined3d_shader_reg_maps *reg_maps = &shader->reg_maps;
1808 unsigned int i;
1809 HRESULT hr;
1810 WORD map;
1811
1812 if (!byte_code) return WINED3DERR_INVALIDCALL;
1813
1814 shader_init(shader, device, parent, parent_ops);
1815 hr = shader_set_function(shader, byte_code, output_signature, device->d3d_vshader_constantF);
1816 if (FAILED(hr))
1817 {
1818 WARN("Failed to set function, hr %#x.\n", hr);
1819 shader_cleanup(shader);
1820 return hr;
1821 }
1822
1823 map = reg_maps->input_registers;
1824 for (i = 0; map; map >>= 1, ++i)
1825 {
1826 if (!(map & 1) || !shader->input_signature[i].semantic_name)
1827 continue;
1828
1829 shader->u.vs.attributes[i].usage =
1830 shader_usage_from_semantic_name(shader->input_signature[i].semantic_name);
1831 shader->u.vs.attributes[i].usage_idx = shader->input_signature[i].semantic_idx;
1832 }
1833
1834 if (output_signature)
1835 {
1836 for (i = 0; i < output_signature->element_count; ++i)
1837 {
1838 struct wined3d_shader_signature_element *e = &output_signature->elements[i];
1839 reg_maps->output_registers |= 1 << e->register_idx;
1840 shader->output_signature[e->register_idx] = *e;
1841 }
1842 }
1843
1844 vertexshader_set_limits(shader);
1845
1846 shader->load_local_constsF = reg_maps->usesrelconstF
1847 && !list_empty(&shader->constantsF);
1848
1849 return WINED3D_OK;
1850 }
1851
1852 static HRESULT geometryshader_init(struct wined3d_shader *shader, struct wined3d_device *device,
1853 const DWORD *byte_code, const struct wined3d_shader_signature *output_signature,
1854 void *parent, const struct wined3d_parent_ops *parent_ops)
1855 {
1856 HRESULT hr;
1857
1858 shader_init(shader, device, parent, parent_ops);
1859 hr = shader_set_function(shader, byte_code, output_signature, 0);
1860 if (FAILED(hr))
1861 {
1862 WARN("Failed to set function, hr %#x.\n", hr);
1863 shader_cleanup(shader);
1864 return hr;
1865 }
1866
1867 shader->load_local_constsF = FALSE;
1868
1869 return WINED3D_OK;
1870 }
1871
1872 void find_ps_compile_args(const struct wined3d_state *state,
1873 const struct wined3d_shader *shader, struct ps_compile_args *args)
1874 {
1875 struct wined3d_device *device = shader->device;
1876 const struct wined3d_texture *texture;
1877 UINT i;
1878
1879 memset(args, 0, sizeof(*args)); /* FIXME: Make sure all bits are set. */
1880 if (state->render_states[WINED3DRS_SRGBWRITEENABLE])
1881 {
1882 const struct wined3d_surface *rt = state->fb->render_targets[0];
1883 if (rt->resource.format->flags & WINED3DFMT_FLAG_SRGB_WRITE) args->srgb_correction = 1;
1884 }
1885
1886 if (shader->reg_maps.shader_version.major == 1
1887 && shader->reg_maps.shader_version.minor <= 3)
1888 {
1889 for (i = 0; i < 4; ++i)
1890 {
1891 DWORD flags = state->texture_states[i][WINED3DTSS_TEXTURETRANSFORMFLAGS];
1892 DWORD tex_transform = flags & ~WINED3DTTFF_PROJECTED;
1893 if (flags & WINED3DTTFF_PROJECTED)
1894 tex_transform |= WINED3D_PSARGS_PROJECTED;
1895 args->tex_transform |= tex_transform << i * WINED3D_PSARGS_TEXTRANSFORM_SHIFT;
1896 }
1897 }
1898
1899 for (i = 0; i < MAX_FRAGMENT_SAMPLERS; ++i)
1900 {
1901 if (!shader->reg_maps.sampler_type[i])
1902 continue;
1903
1904 texture = state->textures[i];
1905 if (!texture)
1906 {
1907 args->color_fixup[i] = COLOR_FIXUP_IDENTITY;
1908 continue;
1909 }
1910 args->color_fixup[i] = texture->resource.format->color_fixup;
1911
1912 if (texture->resource.format->flags & WINED3DFMT_FLAG_SHADOW)
1913 args->shadow |= 1 << i;
1914
1915 /* Flag samplers that need NP2 texcoord fixup. */
1916 if (!(texture->flags & WINED3D_TEXTURE_POW2_MAT_IDENT))
1917 args->np2_fixup |= (1 << i);
1918 }
1919 if (shader->reg_maps.shader_version.major >= 3)
1920 {
1921 if (device->strided_streams.position_transformed)
1922 {
1923 args->vp_mode = pretransformed;
1924 }
1925 else if (use_vs(state))
1926 {
1927 args->vp_mode = vertexshader;
1928 }
1929 else
1930 {
1931 args->vp_mode = fixedfunction;
1932 }
1933 args->fog = FOG_OFF;
1934 }
1935 else
1936 {
1937 args->vp_mode = vertexshader;
1938 if (state->render_states[WINED3DRS_FOGENABLE])
1939 {
1940 switch (state->render_states[WINED3DRS_FOGTABLEMODE])
1941 {
1942 case WINED3DFOG_NONE:
1943 if (device->strided_streams.position_transformed || use_vs(state))
1944 {
1945 args->fog = FOG_LINEAR;
1946 break;
1947 }
1948
1949 switch (state->render_states[WINED3DRS_FOGVERTEXMODE])
1950 {
1951 case WINED3DFOG_NONE: /* Fall through. */
1952 case WINED3DFOG_LINEAR: args->fog = FOG_LINEAR; break;
1953 case WINED3DFOG_EXP: args->fog = FOG_EXP; break;
1954 case WINED3DFOG_EXP2: args->fog = FOG_EXP2; break;
1955 }
1956 break;
1957
1958 case WINED3DFOG_LINEAR: args->fog = FOG_LINEAR; break;
1959 case WINED3DFOG_EXP: args->fog = FOG_EXP; break;
1960 case WINED3DFOG_EXP2: args->fog = FOG_EXP2; break;
1961 }
1962 }
1963 else
1964 {
1965 args->fog = FOG_OFF;
1966 }
1967 }
1968 }
1969
1970 static void pixelshader_set_limits(struct wined3d_shader *shader)
1971 {
1972 DWORD shader_version = WINED3D_SHADER_VERSION(shader->reg_maps.shader_version.major,
1973 shader->reg_maps.shader_version.minor);
1974
1975 shader->limits.attributes = 0;
1976 shader->limits.address = 0;
1977 shader->limits.packed_output = 0;
1978
1979 switch (shader_version)
1980 {
1981 case WINED3D_SHADER_VERSION(1, 0):
1982 case WINED3D_SHADER_VERSION(1, 1):
1983 case WINED3D_SHADER_VERSION(1, 2):
1984 case WINED3D_SHADER_VERSION(1, 3):
1985 shader->limits.temporary = 2;
1986 shader->limits.constant_float = 8;
1987 shader->limits.constant_int = 0;
1988 shader->limits.constant_bool = 0;
1989 shader->limits.texcoord = 4;
1990 shader->limits.sampler = 4;
1991 shader->limits.packed_input = 0;
1992 shader->limits.label = 0;
1993 break;
1994
1995 case WINED3D_SHADER_VERSION(1, 4):
1996 shader->limits.temporary = 6;
1997 shader->limits.constant_float = 8;
1998 shader->limits.constant_int = 0;
1999 shader->limits.constant_bool = 0;
2000 shader->limits.texcoord = 6;
2001 shader->limits.sampler = 6;
2002 shader->limits.packed_input = 0;
2003 shader->limits.label = 0;
2004 break;
2005
2006 /* FIXME: Temporaries must match D3DPSHADERCAPS2_0.NumTemps. */
2007 case WINED3D_SHADER_VERSION(2, 0):
2008 shader->limits.temporary = 32;
2009 shader->limits.constant_float = 32;
2010 shader->limits.constant_int = 16;
2011 shader->limits.constant_bool = 16;
2012 shader->limits.texcoord = 8;
2013 shader->limits.sampler = 16;
2014 shader->limits.packed_input = 0;
2015 break;
2016
2017 case WINED3D_SHADER_VERSION(2, 1):
2018 shader->limits.temporary = 32;
2019 shader->limits.constant_float = 32;
2020 shader->limits.constant_int = 16;
2021 shader->limits.constant_bool = 16;
2022 shader->limits.texcoord = 8;
2023 shader->limits.sampler = 16;
2024 shader->limits.packed_input = 0;
2025 shader->limits.label = 16;
2026 break;
2027
2028 case WINED3D_SHADER_VERSION(4, 0):
2029 FIXME("Using 3.0 limits for 4.0 shader.\n");
2030 /* Fall through. */
2031
2032 case WINED3D_SHADER_VERSION(3, 0):
2033 shader->limits.temporary = 32;
2034 shader->limits.constant_float = 224;
2035 shader->limits.constant_int = 16;
2036 shader->limits.constant_bool = 16;
2037 shader->limits.texcoord = 0;
2038 shader->limits.sampler = 16;
2039 shader->limits.packed_input = 12;
2040 shader->limits.label = 16; /* FIXME: 2048 */
2041 break;
2042
2043 default:
2044 shader->limits.temporary = 32;
2045 shader->limits.constant_float = 32;
2046 shader->limits.constant_int = 16;
2047 shader->limits.constant_bool = 16;
2048 shader->limits.texcoord = 8;
2049 shader->limits.sampler = 16;
2050 shader->limits.packed_input = 0;
2051 shader->limits.label = 0;
2052 FIXME("Unrecognized pixel shader version %u.%u\n",
2053 shader->reg_maps.shader_version.major,
2054 shader->reg_maps.shader_version.minor);
2055 }
2056 }
2057
2058 static HRESULT pixelshader_init(struct wined3d_shader *shader, struct wined3d_device *device,
2059 const DWORD *byte_code, const struct wined3d_shader_signature *output_signature,
2060 void *parent, const struct wined3d_parent_ops *parent_ops)
2061 {
2062 const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
2063 unsigned int i, highest_reg_used = 0, num_regs_used = 0;
2064 HRESULT hr;
2065
2066 if (!byte_code) return WINED3DERR_INVALIDCALL;
2067
2068 shader_init(shader, device, parent, parent_ops);
2069 hr = shader_set_function(shader, byte_code, output_signature, device->d3d_pshader_constantF);
2070 if (FAILED(hr))
2071 {
2072 WARN("Failed to set function, hr %#x.\n", hr);
2073 shader_cleanup(shader);
2074 return hr;
2075 }
2076
2077 pixelshader_set_limits(shader);
2078
2079 for (i = 0; i < MAX_REG_INPUT; ++i)
2080 {
2081 if (shader->u.ps.input_reg_used[i])
2082 {
2083 ++num_regs_used;
2084 highest_reg_used = i;
2085 }
2086 }
2087
2088 /* Don't do any register mapping magic if it is not needed, or if we can't
2089 * achieve anything anyway */
2090 if (highest_reg_used < (gl_info->limits.glsl_varyings / 4)
2091 || num_regs_used > (gl_info->limits.glsl_varyings / 4))
2092 {
2093 if (num_regs_used > (gl_info->limits.glsl_varyings / 4))
2094 {
2095 /* This happens with relative addressing. The input mapper function
2096 * warns about this if the higher registers are declared too, so
2097 * don't write a FIXME here */
2098 WARN("More varying registers used than supported\n");
2099 }
2100
2101 for (i = 0; i < MAX_REG_INPUT; ++i)
2102 {
2103 shader->u.ps.input_reg_map[i] = i;
2104 }
2105
2106 shader->u.ps.declared_in_count = highest_reg_used + 1;
2107 }
2108 else
2109 {
2110 shader->u.ps.declared_in_count = 0;
2111 for (i = 0; i < MAX_REG_INPUT; ++i)
2112 {
2113 if (shader->u.ps.input_reg_used[i])
2114 shader->u.ps.input_reg_map[i] = shader->u.ps.declared_in_count++;
2115 else shader->u.ps.input_reg_map[i] = ~0U;
2116 }
2117 }
2118
2119 shader->load_local_constsF = FALSE;
2120
2121 return WINED3D_OK;
2122 }
2123
2124 void pixelshader_update_samplers(struct wined3d_shader_reg_maps *reg_maps, struct wined3d_texture * const *textures)
2125 {
2126 WINED3DSAMPLER_TEXTURE_TYPE *sampler_type = reg_maps->sampler_type;
2127 unsigned int i;
2128
2129 if (reg_maps->shader_version.major != 1) return;
2130
2131 for (i = 0; i < max(MAX_FRAGMENT_SAMPLERS, MAX_VERTEX_SAMPLERS); ++i)
2132 {
2133 /* We don't sample from this sampler. */
2134 if (!sampler_type[i]) continue;
2135
2136 if (!textures[i])
2137 {
2138 WARN("No texture bound to sampler %u, using 2D.\n", i);
2139 sampler_type[i] = WINED3DSTT_2D;
2140 continue;
2141 }
2142
2143 switch (textures[i]->target)
2144 {
2145 case GL_TEXTURE_RECTANGLE_ARB:
2146 case GL_TEXTURE_2D:
2147 /* We have to select between texture rectangles and 2D
2148 * textures later because 2.0 and 3.0 shaders only have
2149 * WINED3DSTT_2D as well. */
2150 sampler_type[i] = WINED3DSTT_2D;
2151 break;
2152
2153 case GL_TEXTURE_3D:
2154 sampler_type[i] = WINED3DSTT_VOLUME;
2155 break;
2156
2157 case GL_TEXTURE_CUBE_MAP_ARB:
2158 sampler_type[i] = WINED3DSTT_CUBE;
2159 break;
2160
2161 default:
2162 FIXME("Unrecognized texture type %#x, using 2D.\n", textures[i]->target);
2163 sampler_type[i] = WINED3DSTT_2D;
2164 }
2165 }
2166 }
2167
2168 HRESULT CDECL wined3d_shader_create_gs(struct wined3d_device *device, const DWORD *byte_code,
2169 const struct wined3d_shader_signature *output_signature, void *parent,
2170 const struct wined3d_parent_ops *parent_ops, struct wined3d_shader **shader)
2171 {
2172 struct wined3d_shader *object;
2173 HRESULT hr;
2174
2175 TRACE("device %p, byte_code %p, output_signature %p, parent %p, parent_ops %p, shader %p.\n",
2176 device, byte_code, output_signature, parent, parent_ops, shader);
2177
2178 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
2179 if (!object)
2180 {
2181 ERR("Failed to allocate shader memory.\n");
2182 return E_OUTOFMEMORY;
2183 }
2184
2185 hr = geometryshader_init(object, device, byte_code, output_signature, parent, parent_ops);
2186 if (FAILED(hr))
2187 {
2188 WARN("Failed to initialize geometry shader, hr %#x.\n", hr);
2189 HeapFree(GetProcessHeap(), 0, object);
2190 return hr;
2191 }
2192
2193 TRACE("Created geometry shader %p.\n", object);
2194 *shader = object;
2195
2196 return WINED3D_OK;
2197 }
2198
2199 HRESULT CDECL wined3d_shader_create_ps(struct wined3d_device *device, const DWORD *byte_code,
2200 const struct wined3d_shader_signature *output_signature, void *parent,
2201 const struct wined3d_parent_ops *parent_ops, struct wined3d_shader **shader)
2202 {
2203 struct wined3d_shader *object;
2204 HRESULT hr;
2205
2206 TRACE("device %p, byte_code %p, output_signature %p, parent %p, parent_ops %p, shader %p.\n",
2207 device, byte_code, output_signature, parent, parent_ops, shader);
2208
2209 if (device->ps_selected_mode == SHADER_NONE)
2210 return WINED3DERR_INVALIDCALL;
2211
2212 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
2213 if (!object)
2214 {
2215 ERR("Failed to allocate shader memory.\n");
2216 return E_OUTOFMEMORY;
2217 }
2218
2219 hr = pixelshader_init(object, device, byte_code, output_signature, parent, parent_ops);
2220 if (FAILED(hr))
2221 {
2222 WARN("Failed to initialize pixel shader, hr %#x.\n", hr);
2223 HeapFree(GetProcessHeap(), 0, object);
2224 return hr;
2225 }
2226
2227 TRACE("Created pixel shader %p.\n", object);
2228 *shader = object;
2229
2230 return WINED3D_OK;
2231 }
2232
2233 HRESULT CDECL wined3d_shader_create_vs(struct wined3d_device *device, const DWORD *byte_code,
2234 const struct wined3d_shader_signature *output_signature, void *parent,
2235 const struct wined3d_parent_ops *parent_ops, struct wined3d_shader **shader)
2236 {
2237 struct wined3d_shader *object;
2238 HRESULT hr;
2239
2240 TRACE("device %p, byte_code %p, output_signature %p, parent %p, parent_ops %p, shader %p.\n",
2241 device, byte_code, output_signature, parent, parent_ops, shader);
2242
2243 if (device->vs_selected_mode == SHADER_NONE)
2244 return WINED3DERR_INVALIDCALL;
2245
2246 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
2247 if (!object)
2248 {
2249 ERR("Failed to allocate shader memory.\n");
2250 return E_OUTOFMEMORY;
2251 }
2252
2253 hr = vertexshader_init(object, device, byte_code, output_signature, parent, parent_ops);
2254 if (FAILED(hr))
2255 {
2256 WARN("Failed to initialize vertex shader, hr %#x.\n", hr);
2257 HeapFree(GetProcessHeap(), 0, object);
2258 return hr;
2259 }
2260
2261 TRACE("Created vertex shader %p.\n", object);
2262 *shader = object;
2263
2264 return WINED3D_OK;
2265 }
Maarten's multimedia branch