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