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