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