?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push 449d6a3aabb36101ab68dc5159ee54c4adc03034
[wine/hacks.git] / dlls / wined3d / baseshader.c
blob555929ca0efce946acaa885a3f9029647f77a26a
1 /*
2 * shaders implementation
3 *
4 * Copyright 2002-2003 Jason Edmeades
5 * Copyright 2002-2003 Raphael Junqueira
6 * Copyright 2004 Christian Costa
7 * Copyright 2005 Oliver Stieber
8 * Copyright 2006 Ivan Gyurdiev
9 *
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 */
24
25 #include "config.h"
26 #include <string.h>
27 #include <stdio.h>
28 #include "wined3d_private.h"
29
30 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
31
32 #define GLNAME_REQUIRE_GLSL ((const char *)1)
33
34 static inline BOOL shader_is_version_token(DWORD token) {
35 return shader_is_pshader_version(token) ||
36 shader_is_vshader_version(token);
37 }
38
39 int shader_addline(
40 SHADER_BUFFER* buffer,
41 const char *format, ...) {
42
43 char* base = buffer->buffer + buffer->bsize;
44 int rc;
45
46 va_list args;
47 va_start(args, format);
48 rc = vsnprintf(base, SHADER_PGMSIZE - 1 - buffer->bsize, format, args);
49 va_end(args);
50
51 if (rc < 0 || /* C89 */
52 rc > SHADER_PGMSIZE - 1 - buffer->bsize) { /* C99 */
53
54 ERR("The buffer allocated for the shader program string "
55 "is too small at %d bytes.\n", SHADER_PGMSIZE);
56 buffer->bsize = SHADER_PGMSIZE - 1;
57 return -1;
58 }
59
60 if (buffer->newline) {
61 TRACE("GL HW (%u, %u) : %s", buffer->lineNo + 1, buffer->bsize, base);
62 buffer->newline = FALSE;
63 } else {
64 TRACE("%s", base);
65 }
66
67 buffer->bsize += rc;
68 if (buffer->buffer[buffer->bsize-1] == '\n') {
69 buffer->lineNo++;
70 buffer->newline = TRUE;
71 }
72 return 0;
73 }
74
75 const SHADER_OPCODE* shader_get_opcode(
76 IWineD3DBaseShader *iface, const DWORD code) {
77
78 IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl*) iface;
79
80 DWORD i = 0;
81 DWORD hex_version = This->baseShader.hex_version;
82 const SHADER_OPCODE *shader_ins = This->baseShader.shader_ins;
83
84 /** TODO: use dichotomic search */
85 while (NULL != shader_ins[i].name) {
86 if (((code & WINED3DSI_OPCODE_MASK) == shader_ins[i].opcode) &&
87 (((hex_version >= shader_ins[i].min_version) && (hex_version <= shader_ins[i].max_version)) ||
88 ((shader_ins[i].min_version == 0) && (shader_ins[i].max_version == 0)))) {
89 return &shader_ins[i];
90 }
91 ++i;
92 }
93 FIXME("Unsupported opcode %#x(%d) masked %#x, shader version %#x\n",
94 code, code, code & WINED3DSI_OPCODE_MASK, hex_version);
95 return NULL;
96 }
97
98 /* Read a parameter opcode from the input stream,
99 * and possibly a relative addressing token.
100 * Return the number of tokens read */
101 int shader_get_param(
102 IWineD3DBaseShader* iface,
103 const DWORD* pToken,
104 DWORD* param,
105 DWORD* addr_token) {
106
107 /* PS >= 3.0 have relative addressing (with token)
108 * VS >= 2.0 have relative addressing (with token)
109 * VS >= 1.0 < 2.0 have relative addressing (without token)
110 * The version check below should work in general */
111
112 IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
113 char rel_token = WINED3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) >= 2 &&
114 ((*pToken & WINED3DSHADER_ADDRESSMODE_MASK) == WINED3DSHADER_ADDRMODE_RELATIVE);
115
116 *param = *pToken;
117 *addr_token = rel_token? *(pToken + 1): 0;
118 return rel_token? 2:1;
119 }
120
121 /* Return the number of parameters to skip for an opcode */
122 static inline int shader_skip_opcode(
123 IWineD3DBaseShaderImpl* This,
124 const SHADER_OPCODE* curOpcode,
125 DWORD opcode_token) {
126
127 /* Shaders >= 2.0 may contain address tokens, but fortunately they
128 * have a useful legnth mask - use it here. Shaders 1.0 contain no such tokens */
129
130 return (WINED3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) >= 2)?
131 ((opcode_token & WINED3DSI_INSTLENGTH_MASK) >> WINED3DSI_INSTLENGTH_SHIFT):
132 curOpcode->num_params;
133 }
134
135 /* Read the parameters of an unrecognized opcode from the input stream
136 * Return the number of tokens read.
137 *
138 * Note: This function assumes source or destination token format.
139 * It will not work with specially-formatted tokens like DEF or DCL,
140 * but hopefully those would be recognized */
141
142 int shader_skip_unrecognized(
143 IWineD3DBaseShader* iface,
144 const DWORD* pToken) {
145
146 int tokens_read = 0;
147 int i = 0;
148
149 /* TODO: Think of a good name for 0x80000000 and replace it with a constant */
150 while (*pToken & 0x80000000) {
151
152 DWORD param, addr_token;
153 tokens_read += shader_get_param(iface, pToken, &param, &addr_token);
154 pToken += tokens_read;
155
156 FIXME("Unrecognized opcode param: token=%08x "
157 "addr_token=%08x name=", param, addr_token);
158 shader_dump_param(iface, param, addr_token, i);
159 FIXME("\n");
160 ++i;
161 }
162 return tokens_read;
163 }
164
165 /* Convert floating point offset relative
166 * to a register file to an absolute offset for float constants */
167
168 unsigned int shader_get_float_offset(const DWORD reg) {
169
170 unsigned int regnum = reg & WINED3DSP_REGNUM_MASK;
171 int regtype = shader_get_regtype(reg);
172
173 switch (regtype) {
174 case WINED3DSPR_CONST: return regnum;
175 case WINED3DSPR_CONST2: return 2048 + regnum;
176 case WINED3DSPR_CONST3: return 4096 + regnum;
177 case WINED3DSPR_CONST4: return 6144 + regnum;
178 default:
179 FIXME("Unsupported register type: %d\n", regtype);
180 return regnum;
181 }
182 }
183
184 /* Note that this does not count the loop register
185 * as an address register. */
186
187 HRESULT shader_get_registers_used(
188 IWineD3DBaseShader *iface,
189 shader_reg_maps* reg_maps,
190 semantic* semantics_in,
191 semantic* semantics_out,
192 CONST DWORD* pToken,
193 IWineD3DStateBlockImpl *stateBlock) {
194
195 IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
196
197 /* There are some minor differences between pixel and vertex shaders */
198 char pshader = shader_is_pshader_version(This->baseShader.hex_version);
199
200 reg_maps->bumpmat = -1;
201 reg_maps->luminanceparams = -1;
202
203 if (pToken == NULL)
204 return WINED3D_OK;
205
206 while (WINED3DVS_END() != *pToken) {
207 CONST SHADER_OPCODE* curOpcode;
208 DWORD opcode_token;
209
210 /* Skip version */
211 if (shader_is_version_token(*pToken)) {
212 ++pToken;
213 continue;
214
215 /* Skip comments */
216 } else if (shader_is_comment(*pToken)) {
217 DWORD comment_len = (*pToken & WINED3DSI_COMMENTSIZE_MASK) >> WINED3DSI_COMMENTSIZE_SHIFT;
218 ++pToken;
219 pToken += comment_len;
220 continue;
221 }
222
223 /* Fetch opcode */
224 opcode_token = *pToken++;
225 curOpcode = shader_get_opcode(iface, opcode_token);
226
227 /* Unhandled opcode, and its parameters */
228 if (NULL == curOpcode) {
229 while (*pToken & 0x80000000)
230 ++pToken;
231
232 /* Handle declarations */
233 } else if (WINED3DSIO_DCL == curOpcode->opcode) {
234
235 DWORD usage = *pToken++;
236 DWORD param = *pToken++;
237 DWORD regtype = shader_get_regtype(param);
238 unsigned int regnum = param & WINED3DSP_REGNUM_MASK;
239
240 /* Vshader: mark attributes used
241 Pshader: mark 3.0 input registers used, save token */
242 if (WINED3DSPR_INPUT == regtype) {
243
244 if (!pshader)
245 reg_maps->attributes[regnum] = 1;
246 else
247 reg_maps->packed_input[regnum] = 1;
248
249 semantics_in[regnum].usage = usage;
250 semantics_in[regnum].reg = param;
251
252 /* Vshader: mark 3.0 output registers used, save token */
253 } else if (WINED3DSPR_OUTPUT == regtype) {
254 reg_maps->packed_output[regnum] = 1;
255 semantics_out[regnum].usage = usage;
256 semantics_out[regnum].reg = param;
257 if (usage & (WINED3DDECLUSAGE_FOG << WINED3DSP_DCL_USAGE_SHIFT))
258 reg_maps->fog = 1;
259
260 /* Save sampler usage token */
261 } else if (WINED3DSPR_SAMPLER == regtype)
262 reg_maps->samplers[regnum] = usage;
263
264 } else if (WINED3DSIO_DEF == curOpcode->opcode) {
265
266 local_constant* lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant));
267 if (!lconst) return E_OUTOFMEMORY;
268 lconst->idx = *pToken & WINED3DSP_REGNUM_MASK;
269 memcpy(&lconst->value, pToken + 1, 4 * sizeof(DWORD));
270
271 /* In pixel shader 1.X shaders, the constants are clamped between [-1;1] */
272 if(WINED3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) == 1 && pshader) {
273 float *value = (float *) lconst->value;
274 if(value[0] < -1.0) value[0] = -1.0;
275 else if(value[0] > 1.0) value[0] = 1.0;
276 if(value[1] < -1.0) value[1] = -1.0;
277 else if(value[1] > 1.0) value[1] = 1.0;
278 if(value[2] < -1.0) value[2] = -1.0;
279 else if(value[2] > 1.0) value[2] = 1.0;
280 if(value[3] < -1.0) value[3] = -1.0;
281 else if(value[3] > 1.0) value[3] = 1.0;
282 }
283
284 list_add_head(&This->baseShader.constantsF, &lconst->entry);
285 pToken += curOpcode->num_params;
286
287 } else if (WINED3DSIO_DEFI == curOpcode->opcode) {
288
289 local_constant* lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant));
290 if (!lconst) return E_OUTOFMEMORY;
291 lconst->idx = *pToken & WINED3DSP_REGNUM_MASK;
292 memcpy(&lconst->value, pToken + 1, 4 * sizeof(DWORD));
293 list_add_head(&This->baseShader.constantsI, &lconst->entry);
294 pToken += curOpcode->num_params;
295
296 } else if (WINED3DSIO_DEFB == curOpcode->opcode) {
297
298 local_constant* lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant));
299 if (!lconst) return E_OUTOFMEMORY;
300 lconst->idx = *pToken & WINED3DSP_REGNUM_MASK;
301 memcpy(&lconst->value, pToken + 1, 1 * sizeof(DWORD));
302 list_add_head(&This->baseShader.constantsB, &lconst->entry);
303 pToken += curOpcode->num_params;
304
305 /* If there's a loop in the shader */
306 } else if (WINED3DSIO_LOOP == curOpcode->opcode ||
307 WINED3DSIO_REP == curOpcode->opcode) {
308 reg_maps->loop = 1;
309 pToken += curOpcode->num_params;
310
311 /* For subroutine prototypes */
312 } else if (WINED3DSIO_LABEL == curOpcode->opcode) {
313
314 DWORD snum = *pToken & WINED3DSP_REGNUM_MASK;
315 reg_maps->labels[snum] = 1;
316 pToken += curOpcode->num_params;
317
318 } else if(WINED3DSIO_BEM == curOpcode->opcode) {
319 DWORD regnum = *pToken & WINED3DSP_REGNUM_MASK;
320 if(reg_maps->bumpmat != -1 && reg_maps->bumpmat != regnum) {
321 FIXME("Pixel shader uses bem or texbem instruction on more than 1 sampler\n");
322 } else {
323 reg_maps->bumpmat = regnum;
324 }
325
326 /* Set texture, address, temporary registers */
327 } else {
328 int i, limit;
329
330 /* Declare 1.X samplers implicitly, based on the destination reg. number */
331 if (WINED3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) == 1 &&
332 (WINED3DSIO_TEX == curOpcode->opcode ||
333 WINED3DSIO_TEXBEM == curOpcode->opcode ||
334 WINED3DSIO_TEXBEML == curOpcode->opcode ||
335 WINED3DSIO_TEXDP3TEX == curOpcode->opcode ||
336 WINED3DSIO_TEXM3x2TEX == curOpcode->opcode ||
337 WINED3DSIO_TEXM3x3SPEC == curOpcode->opcode ||
338 WINED3DSIO_TEXM3x3TEX == curOpcode->opcode ||
339 WINED3DSIO_TEXM3x3VSPEC == curOpcode->opcode ||
340 WINED3DSIO_TEXREG2AR == curOpcode->opcode ||
341 WINED3DSIO_TEXREG2GB == curOpcode->opcode ||
342 WINED3DSIO_TEXREG2RGB == curOpcode->opcode)) {
343
344 /* Fake sampler usage, only set reserved bit and ttype */
345 DWORD sampler_code = *pToken & WINED3DSP_REGNUM_MASK;
346
347 if(!stateBlock->textures[sampler_code]) {
348 ERR("No texture bound to sampler %d\n", sampler_code);
349 reg_maps->samplers[sampler_code] = (0x1 << 31) | WINED3DSTT_2D;
350 } else {
351 int texType = IWineD3DBaseTexture_GetTextureDimensions(stateBlock->textures[sampler_code]);
352 switch(texType) {
353 case GL_TEXTURE_2D:
354 reg_maps->samplers[sampler_code] = (0x1 << 31) | WINED3DSTT_2D;
355 break;
356
357 case GL_TEXTURE_3D:
358 reg_maps->samplers[sampler_code] = (0x1 << 31) | WINED3DSTT_VOLUME;
359 break;
360
361 case GL_TEXTURE_CUBE_MAP_ARB:
362 reg_maps->samplers[sampler_code] = (0x1 << 31) | WINED3DSTT_CUBE;
363 break;
364
365 default:
366 ERR("Unexpected gl texture type found: %d\n", texType);
367 reg_maps->samplers[sampler_code] = (0x1 << 31) | WINED3DSTT_2D;
368 }
369 }
370
371 /* texbem is only valid with < 1.4 pixel shaders */
372 if(WINED3DSIO_TEXBEM == curOpcode->opcode ||
373 WINED3DSIO_TEXBEML == curOpcode->opcode) {
374 if(reg_maps->bumpmat != -1 && reg_maps->bumpmat != sampler_code) {
375 FIXME("Pixel shader uses texbem instruction on more than 1 sampler\n");
376 } else {
377 reg_maps->bumpmat = sampler_code;
378 if(WINED3DSIO_TEXBEML == curOpcode->opcode) {
379 reg_maps->luminanceparams = sampler_code;
380 }
381 }
382 }
383 }
384 if(WINED3DSIO_NRM == curOpcode->opcode) {
385 reg_maps->usesnrm = 1;
386 }
387
388 /* This will loop over all the registers and try to
389 * make a bitmask of the ones we're interested in.
390 *
391 * Relative addressing tokens are ignored, but that's
392 * okay, since we'll catch any address registers when
393 * they are initialized (required by spec) */
394
395 limit = (opcode_token & WINED3DSHADER_INSTRUCTION_PREDICATED)?
396 curOpcode->num_params + 1: curOpcode->num_params;
397
398 for (i = 0; i < limit; ++i) {
399
400 DWORD param, addr_token, reg, regtype;
401 pToken += shader_get_param(iface, pToken, &param, &addr_token);
402
403 regtype = shader_get_regtype(param);
404 reg = param & WINED3DSP_REGNUM_MASK;
405
406 if (WINED3DSPR_TEXTURE == regtype) { /* vs: WINED3DSPR_ADDR */
407
408 if (pshader)
409 reg_maps->texcoord[reg] = 1;
410 else
411 reg_maps->address[reg] = 1;
412 }
413
414 else if (WINED3DSPR_TEMP == regtype)
415 reg_maps->temporary[reg] = 1;
416
417 else if (WINED3DSPR_INPUT == regtype && !pshader)
418 reg_maps->attributes[reg] = 1;
419
420 else if (WINED3DSPR_RASTOUT == regtype && reg == 1)
421 reg_maps->fog = 1;
422 }
423 }
424 }
425
426 return WINED3D_OK;
427 }
428
429 static void shader_dump_decl_usage(
430 IWineD3DBaseShaderImpl* This,
431 DWORD decl,
432 DWORD param) {
433
434 DWORD regtype = shader_get_regtype(param);
435
436 TRACE("dcl");
437
438 if (regtype == WINED3DSPR_SAMPLER) {
439 DWORD ttype = decl & WINED3DSP_TEXTURETYPE_MASK;
440
441 switch (ttype) {
442 case WINED3DSTT_2D: TRACE("_2d"); break;
443 case WINED3DSTT_CUBE: TRACE("_cube"); break;
444 case WINED3DSTT_VOLUME: TRACE("_volume"); break;
445 default: TRACE("_unknown_ttype(%08x)", ttype);
446 }
447
448 } else {
449
450 DWORD usage = decl & WINED3DSP_DCL_USAGE_MASK;
451 DWORD idx = (decl & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
452
453 /* Pixel shaders 3.0 don't have usage semantics */
454 char pshader = shader_is_pshader_version(This->baseShader.hex_version);
455 if (pshader && This->baseShader.hex_version < WINED3DPS_VERSION(3,0))
456 return;
457 else
458 TRACE("_");
459
460 switch(usage) {
461 case WINED3DDECLUSAGE_POSITION:
462 TRACE("position%d", idx);
463 break;
464 case WINED3DDECLUSAGE_BLENDINDICES:
465 TRACE("blend");
466 break;
467 case WINED3DDECLUSAGE_BLENDWEIGHT:
468 TRACE("weight");
469 break;
470 case WINED3DDECLUSAGE_NORMAL:
471 TRACE("normal%d", idx);
472 break;
473 case WINED3DDECLUSAGE_PSIZE:
474 TRACE("psize");
475 break;
476 case WINED3DDECLUSAGE_COLOR:
477 if(idx == 0) {
478 TRACE("color");
479 } else {
480 TRACE("specular%d", (idx - 1));
481 }
482 break;
483 case WINED3DDECLUSAGE_TEXCOORD:
484 TRACE("texture%d", idx);
485 break;
486 case WINED3DDECLUSAGE_TANGENT:
487 TRACE("tangent");
488 break;
489 case WINED3DDECLUSAGE_BINORMAL:
490 TRACE("binormal");
491 break;
492 case WINED3DDECLUSAGE_TESSFACTOR:
493 TRACE("tessfactor");
494 break;
495 case WINED3DDECLUSAGE_POSITIONT:
496 TRACE("positionT%d", idx);
497 break;
498 case WINED3DDECLUSAGE_FOG:
499 TRACE("fog");
500 break;
501 case WINED3DDECLUSAGE_DEPTH:
502 TRACE("depth");
503 break;
504 case WINED3DDECLUSAGE_SAMPLE:
505 TRACE("sample");
506 break;
507 default:
508 FIXME("unknown_semantics(%08x)", usage);
509 }
510 }
511 }
512
513 static void shader_dump_arr_entry(
514 IWineD3DBaseShader *iface,
515 const DWORD param,
516 const DWORD addr_token,
517 unsigned int reg,
518 int input) {
519
520 char relative =
521 ((param & WINED3DSHADER_ADDRESSMODE_MASK) == WINED3DSHADER_ADDRMODE_RELATIVE);
522
523 if (relative) {
524 TRACE("[");
525 if (addr_token)
526 shader_dump_param(iface, addr_token, 0, input);
527 else
528 TRACE("a0.x");
529 TRACE(" + ");
530 }
531 TRACE("%u", reg);
532 if (relative)
533 TRACE("]");
534 }
535
536 void shader_dump_param(
537 IWineD3DBaseShader *iface,
538 const DWORD param,
539 const DWORD addr_token,
540 int input) {
541
542 IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
543 static const char * const rastout_reg_names[] = { "oPos", "oFog", "oPts" };
544 static const char * const misctype_reg_names[] = { "vPos", "vFace"};
545 char swizzle_reg_chars[4];
546
547 DWORD reg = param & WINED3DSP_REGNUM_MASK;
548 DWORD regtype = shader_get_regtype(param);
549 DWORD modifier = param & WINED3DSP_SRCMOD_MASK;
550
551 /* There are some minor differences between pixel and vertex shaders */
552 char pshader = shader_is_pshader_version(This->baseShader.hex_version);
553
554 /* For one, we'd prefer color components to be shown for pshaders.
555 * FIXME: use the swizzle function for this */
556
557 swizzle_reg_chars[0] = pshader? 'r': 'x';
558 swizzle_reg_chars[1] = pshader? 'g': 'y';
559 swizzle_reg_chars[2] = pshader? 'b': 'z';
560 swizzle_reg_chars[3] = pshader? 'a': 'w';
561
562 if (input) {
563 if ( (modifier == WINED3DSPSM_NEG) ||
564 (modifier == WINED3DSPSM_BIASNEG) ||
565 (modifier == WINED3DSPSM_SIGNNEG) ||
566 (modifier == WINED3DSPSM_X2NEG) ||
567 (modifier == WINED3DSPSM_ABSNEG) )
568 TRACE("-");
569 else if (modifier == WINED3DSPSM_COMP)
570 TRACE("1-");
571 else if (modifier == WINED3DSPSM_NOT)
572 TRACE("!");
573
574 if (modifier == WINED3DSPSM_ABS || modifier == WINED3DSPSM_ABSNEG)
575 TRACE("abs(");
576 }
577
578 switch (regtype) {
579 case WINED3DSPR_TEMP:
580 TRACE("r%u", reg);
581 break;
582 case WINED3DSPR_INPUT:
583 TRACE("v");
584 shader_dump_arr_entry(iface, param, addr_token, reg, input);
585 break;
586 case WINED3DSPR_CONST:
587 case WINED3DSPR_CONST2:
588 case WINED3DSPR_CONST3:
589 case WINED3DSPR_CONST4:
590 TRACE("c");
591 shader_dump_arr_entry(iface, param, addr_token, shader_get_float_offset(param), input);
592 break;
593 case WINED3DSPR_TEXTURE: /* vs: case D3DSPR_ADDR */
594 TRACE("%c%u", (pshader? 't':'a'), reg);
595 break;
596 case WINED3DSPR_RASTOUT:
597 TRACE("%s", rastout_reg_names[reg]);
598 break;
599 case WINED3DSPR_COLOROUT:
600 TRACE("oC%u", reg);
601 break;
602 case WINED3DSPR_DEPTHOUT:
603 TRACE("oDepth");
604 break;
605 case WINED3DSPR_ATTROUT:
606 TRACE("oD%u", reg);
607 break;
608 case WINED3DSPR_TEXCRDOUT:
609
610 /* Vertex shaders >= 3.0 use general purpose output registers
611 * (WINED3DSPR_OUTPUT), which can include an address token */
612
613 if (WINED3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) >= 3) {
614 TRACE("o");
615 shader_dump_arr_entry(iface, param, addr_token, reg, input);
616 }
617 else
618 TRACE("oT%u", reg);
619 break;
620 case WINED3DSPR_CONSTINT:
621 TRACE("i");
622 shader_dump_arr_entry(iface, param, addr_token, reg, input);
623 break;
624 case WINED3DSPR_CONSTBOOL:
625 TRACE("b");
626 shader_dump_arr_entry(iface, param, addr_token, reg, input);
627 break;
628 case WINED3DSPR_LABEL:
629 TRACE("l%u", reg);
630 break;
631 case WINED3DSPR_LOOP:
632 TRACE("aL");
633 break;
634 case WINED3DSPR_SAMPLER:
635 TRACE("s%u", reg);
636 break;
637 case WINED3DSPR_MISCTYPE:
638 if (reg > 1) {
639 FIXME("Unhandled misctype register %d\n", reg);
640 } else {
641 TRACE("%s", misctype_reg_names[reg]);
642 }
643 break;
644 case WINED3DSPR_PREDICATE:
645 TRACE("p%u", reg);
646 break;
647 default:
648 TRACE("unhandled_rtype(%#x)", regtype);
649 break;
650 }
651
652 if (!input) {
653 /* operand output (for modifiers and shift, see dump_ins_modifiers) */
654
655 if ((param & WINED3DSP_WRITEMASK_ALL) != WINED3DSP_WRITEMASK_ALL) {
656 TRACE(".");
657 if (param & WINED3DSP_WRITEMASK_0) TRACE("%c", swizzle_reg_chars[0]);
658 if (param & WINED3DSP_WRITEMASK_1) TRACE("%c", swizzle_reg_chars[1]);
659 if (param & WINED3DSP_WRITEMASK_2) TRACE("%c", swizzle_reg_chars[2]);
660 if (param & WINED3DSP_WRITEMASK_3) TRACE("%c", swizzle_reg_chars[3]);
661 }
662
663 } else {
664 /** operand input */
665 DWORD swizzle = (param & WINED3DSP_SWIZZLE_MASK) >> WINED3DSP_SWIZZLE_SHIFT;
666 DWORD swizzle_r = swizzle & 0x03;
667 DWORD swizzle_g = (swizzle >> 2) & 0x03;
668 DWORD swizzle_b = (swizzle >> 4) & 0x03;
669 DWORD swizzle_a = (swizzle >> 6) & 0x03;
670
671 if (0 != modifier) {
672 switch (modifier) {
673 case WINED3DSPSM_NONE: break;
674 case WINED3DSPSM_NEG: break;
675 case WINED3DSPSM_NOT: break;
676 case WINED3DSPSM_BIAS: TRACE("_bias"); break;
677 case WINED3DSPSM_BIASNEG: TRACE("_bias"); break;
678 case WINED3DSPSM_SIGN: TRACE("_bx2"); break;
679 case WINED3DSPSM_SIGNNEG: TRACE("_bx2"); break;
680 case WINED3DSPSM_COMP: break;
681 case WINED3DSPSM_X2: TRACE("_x2"); break;
682 case WINED3DSPSM_X2NEG: TRACE("_x2"); break;
683 case WINED3DSPSM_DZ: TRACE("_dz"); break;
684 case WINED3DSPSM_DW: TRACE("_dw"); break;
685 case WINED3DSPSM_ABSNEG: TRACE(")"); break;
686 case WINED3DSPSM_ABS: TRACE(")"); break;
687 default:
688 TRACE("_unknown_modifier(%#x)", modifier >> WINED3DSP_SRCMOD_SHIFT);
689 }
690 }
691
692 /**
693 * swizzle bits fields:
694 * RRGGBBAA
695 */
696 if ((WINED3DVS_NOSWIZZLE >> WINED3DVS_SWIZZLE_SHIFT) != swizzle) {
697 if (swizzle_r == swizzle_g &&
698 swizzle_r == swizzle_b &&
699 swizzle_r == swizzle_a) {
700 TRACE(".%c", swizzle_reg_chars[swizzle_r]);
701 } else {
702 TRACE(".%c%c%c%c",
703 swizzle_reg_chars[swizzle_r],
704 swizzle_reg_chars[swizzle_g],
705 swizzle_reg_chars[swizzle_b],
706 swizzle_reg_chars[swizzle_a]);
707 }
708 }
709 }
710 }
711
712 /** Shared code in order to generate the bulk of the shader string.
713 Use the shader_header_fct & shader_footer_fct to add strings
714 that are specific to pixel or vertex functions
715 NOTE: A description of how to parse tokens can be found at:
716 http://msdn.microsoft.com/library/default.asp?url=/library/en-us/graphics/hh/graphics/usermodedisplaydriver_shader_cc8e4e05-f5c3-4ec0-8853-8ce07c1551b2.xml.asp */
717 void shader_generate_main(
718 IWineD3DBaseShader *iface,
719 SHADER_BUFFER* buffer,
720 shader_reg_maps* reg_maps,
721 CONST DWORD* pFunction) {
722
723 IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
724 IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) This->baseShader.device; /* To access shader backend callbacks */
725 const DWORD *pToken = pFunction;
726 const SHADER_OPCODE *curOpcode = NULL;
727 SHADER_HANDLER hw_fct = NULL;
728 DWORD i;
729 SHADER_OPCODE_ARG hw_arg;
730
731 /* Initialize current parsing state */
732 hw_arg.shader = iface;
733 hw_arg.buffer = buffer;
734 hw_arg.reg_maps = reg_maps;
735 This->baseShader.parse_state.current_row = 0;
736
737 /* Second pass, process opcodes */
738 if (NULL != pToken) {
739 while (WINED3DPS_END() != *pToken) {
740
741 /* Skip version token */
742 if (shader_is_version_token(*pToken)) {
743 ++pToken;
744 continue;
745 }
746
747 /* Skip comment tokens */
748 if (shader_is_comment(*pToken)) {
749 DWORD comment_len = (*pToken & WINED3DSI_COMMENTSIZE_MASK) >> WINED3DSI_COMMENTSIZE_SHIFT;
750 ++pToken;
751 TRACE("#%s\n", (const char*)pToken);
752 pToken += comment_len;
753 continue;
754 }
755
756 /* Read opcode */
757 hw_arg.opcode_token = *pToken++;
758 curOpcode = shader_get_opcode(iface, hw_arg.opcode_token);
759
760 /* Select handler */
761 if (curOpcode == NULL)
762 hw_fct = NULL;
763 else if (This->baseShader.shader_mode == SHADER_GLSL)
764 hw_fct = curOpcode->hw_glsl_fct;
765 else if (This->baseShader.shader_mode == SHADER_ARB)
766 hw_fct = curOpcode->hw_fct;
767
768 /* Unknown opcode and its parameters */
769 if (NULL == curOpcode) {
770 FIXME("Unrecognized opcode: token=%08x\n", hw_arg.opcode_token);
771 pToken += shader_skip_unrecognized(iface, pToken);
772
773 /* Nothing to do */
774 } else if (WINED3DSIO_DCL == curOpcode->opcode ||
775 WINED3DSIO_NOP == curOpcode->opcode ||
776 WINED3DSIO_DEF == curOpcode->opcode ||
777 WINED3DSIO_DEFI == curOpcode->opcode ||
778 WINED3DSIO_DEFB == curOpcode->opcode ||
779 WINED3DSIO_PHASE == curOpcode->opcode ||
780 WINED3DSIO_RET == curOpcode->opcode) {
781
782 pToken += shader_skip_opcode(This, curOpcode, hw_arg.opcode_token);
783
784 /* If a generator function is set for current shader target, use it */
785 } else if (hw_fct != NULL) {
786
787 hw_arg.opcode = curOpcode;
788
789 /* Destination token */
790 if (curOpcode->dst_token) {
791
792 DWORD param, addr_token = 0;
793 pToken += shader_get_param(iface, pToken, &param, &addr_token);
794 hw_arg.dst = param;
795 hw_arg.dst_addr = addr_token;
796 }
797
798 /* Predication token */
799 if (hw_arg.opcode_token & WINED3DSHADER_INSTRUCTION_PREDICATED)
800 hw_arg.predicate = *pToken++;
801
802 /* Other source tokens */
803 for (i = 0; i < (curOpcode->num_params - curOpcode->dst_token); i++) {
804
805 DWORD param, addr_token = 0;
806 pToken += shader_get_param(iface, pToken, &param, &addr_token);
807 hw_arg.src[i] = param;
808 hw_arg.src_addr[i] = addr_token;
809 }
810
811 /* Call appropriate function for output target */
812 hw_fct(&hw_arg);
813
814 /* Add color correction if needed */
815 device->shader_backend->shader_color_correction(&hw_arg);
816
817 /* Process instruction modifiers for GLSL apps ( _sat, etc. ) */
818 if (This->baseShader.shader_mode == SHADER_GLSL)
819 shader_glsl_add_instruction_modifiers(&hw_arg);
820
821 /* Unhandled opcode */
822 } else {
823
824 FIXME("Can't handle opcode %s in hwShader\n", curOpcode->name);
825 pToken += shader_skip_opcode(This, curOpcode, hw_arg.opcode_token);
826 }
827 }
828 /* TODO: What about result.depth? */
829
830 }
831 }
832
833 void shader_dump_ins_modifiers(const DWORD output) {
834
835 DWORD shift = (output & WINED3DSP_DSTSHIFT_MASK) >> WINED3DSP_DSTSHIFT_SHIFT;
836 DWORD mmask = output & WINED3DSP_DSTMOD_MASK;
837
838 switch (shift) {
839 case 0: break;
840 case 13: TRACE("_d8"); break;
841 case 14: TRACE("_d4"); break;
842 case 15: TRACE("_d2"); break;
843 case 1: TRACE("_x2"); break;
844 case 2: TRACE("_x4"); break;
845 case 3: TRACE("_x8"); break;
846 default: TRACE("_unhandled_shift(%d)", shift); break;
847 }
848
849 if (mmask & WINED3DSPDM_SATURATE) TRACE("_sat");
850 if (mmask & WINED3DSPDM_PARTIALPRECISION) TRACE("_pp");
851 if (mmask & WINED3DSPDM_MSAMPCENTROID) TRACE("_centroid");
852
853 mmask &= ~(WINED3DSPDM_SATURATE | WINED3DSPDM_PARTIALPRECISION | WINED3DSPDM_MSAMPCENTROID);
854 if (mmask)
855 FIXME("_unrecognized_modifier(%#x)", mmask >> WINED3DSP_DSTMOD_SHIFT);
856 }
857
858 /* First pass: trace shader, initialize length and version */
859 void shader_trace_init(
860 IWineD3DBaseShader *iface,
861 const DWORD* pFunction) {
862
863 IWineD3DBaseShaderImpl *This =(IWineD3DBaseShaderImpl *)iface;
864
865 const DWORD* pToken = pFunction;
866 const SHADER_OPCODE* curOpcode = NULL;
867 DWORD opcode_token;
868 unsigned int len = 0;
869 DWORD i;
870
871 TRACE("(%p) : Parsing programme\n", This);
872
873 if (NULL != pToken) {
874 while (WINED3DVS_END() != *pToken) {
875 if (shader_is_version_token(*pToken)) { /** version */
876 This->baseShader.hex_version = *pToken;
877 TRACE("%s_%u_%u\n", shader_is_pshader_version(This->baseShader.hex_version)? "ps": "vs",
878 WINED3DSHADER_VERSION_MAJOR(This->baseShader.hex_version),
879 WINED3DSHADER_VERSION_MINOR(This->baseShader.hex_version));
880 ++pToken;
881 ++len;
882 continue;
883 }
884 if (shader_is_comment(*pToken)) { /** comment */
885 DWORD comment_len = (*pToken & WINED3DSI_COMMENTSIZE_MASK) >> WINED3DSI_COMMENTSIZE_SHIFT;
886 ++pToken;
887 TRACE("//%s\n", (const char*)pToken);
888 pToken += comment_len;
889 len += comment_len + 1;
890 continue;
891 }
892 opcode_token = *pToken++;
893 curOpcode = shader_get_opcode(iface, opcode_token);
894 len++;
895
896 if (NULL == curOpcode) {
897 int tokens_read;
898 FIXME("Unrecognized opcode: token=%08x\n", opcode_token);
899 tokens_read = shader_skip_unrecognized(iface, pToken);
900 pToken += tokens_read;
901 len += tokens_read;
902
903 } else {
904 if (curOpcode->opcode == WINED3DSIO_DCL) {
905
906 DWORD usage = *pToken;
907 DWORD param = *(pToken + 1);
908
909 shader_dump_decl_usage(This, usage, param);
910 shader_dump_ins_modifiers(param);
911 TRACE(" ");
912 shader_dump_param(iface, param, 0, 0);
913 pToken += 2;
914 len += 2;
915
916 } else if (curOpcode->opcode == WINED3DSIO_DEF) {
917
918 unsigned int offset = shader_get_float_offset(*pToken);
919
920 TRACE("def c%u = %f, %f, %f, %f", offset,
921 *(const float *)(pToken + 1),
922 *(const float *)(pToken + 2),
923 *(const float *)(pToken + 3),
924 *(const float *)(pToken + 4));
925
926 pToken += 5;
927 len += 5;
928 } else if (curOpcode->opcode == WINED3DSIO_DEFI) {
929
930 TRACE("defi i%u = %d, %d, %d, %d", *pToken & WINED3DSP_REGNUM_MASK,
931 *(pToken + 1),
932 *(pToken + 2),
933 *(pToken + 3),
934 *(pToken + 4));
935
936 pToken += 5;
937 len += 5;
938
939 } else if (curOpcode->opcode == WINED3DSIO_DEFB) {
940
941 TRACE("defb b%u = %s", *pToken & WINED3DSP_REGNUM_MASK,
942 *(pToken + 1)? "true": "false");
943
944 pToken += 2;
945 len += 2;
946
947 } else {
948
949 DWORD param, addr_token;
950 int tokens_read;
951
952 /* Print out predication source token first - it follows
953 * the destination token. */
954 if (opcode_token & WINED3DSHADER_INSTRUCTION_PREDICATED) {
955 TRACE("(");
956 shader_dump_param(iface, *(pToken + 2), 0, 1);
957 TRACE(") ");
958 }
959 if (opcode_token & WINED3DSI_COISSUE) {
960 /* PixWin marks instructions with the coissue flag with a '+' */
961 TRACE("+");
962 }
963
964 TRACE("%s", curOpcode->name);
965
966 if (curOpcode->opcode == WINED3DSIO_IFC ||
967 curOpcode->opcode == WINED3DSIO_BREAKC) {
968
969 DWORD op = (opcode_token & INST_CONTROLS_MASK) >> INST_CONTROLS_SHIFT;
970 switch (op) {
971 case COMPARISON_GT: TRACE("_gt"); break;
972 case COMPARISON_EQ: TRACE("_eq"); break;
973 case COMPARISON_GE: TRACE("_ge"); break;
974 case COMPARISON_LT: TRACE("_lt"); break;
975 case COMPARISON_NE: TRACE("_ne"); break;
976 case COMPARISON_LE: TRACE("_le"); break;
977 default:
978 TRACE("_(%u)", op);
979 }
980 } else if (curOpcode->opcode == WINED3DSIO_TEX &&
981 This->baseShader.hex_version >= WINED3DPS_VERSION(2,0)) {
982 if(opcode_token & WINED3DSI_TEXLD_PROJECT) TRACE("p");
983 }
984
985 /* Destination token */
986 if (curOpcode->dst_token) {
987
988 /* Destination token */
989 tokens_read = shader_get_param(iface, pToken, &param, &addr_token);
990 pToken += tokens_read;
991 len += tokens_read;
992
993 shader_dump_ins_modifiers(param);
994 TRACE(" ");
995 shader_dump_param(iface, param, addr_token, 0);
996 }
997
998 /* Predication token - already printed out, just skip it */
999 if (opcode_token & WINED3DSHADER_INSTRUCTION_PREDICATED) {
1000 pToken++;
1001 len++;
1002 }
1003
1004 /* Other source tokens */
1005 for (i = curOpcode->dst_token; i < curOpcode->num_params; ++i) {
1006
1007 tokens_read = shader_get_param(iface, pToken, &param, &addr_token);
1008 pToken += tokens_read;
1009 len += tokens_read;
1010
1011 TRACE((i == 0)? " " : ", ");
1012 shader_dump_param(iface, param, addr_token, 1);
1013 }
1014 }
1015 TRACE("\n");
1016 }
1017 }
1018 This->baseShader.functionLength = (len + 1) * sizeof(DWORD);
1019 } else {
1020 This->baseShader.functionLength = 1; /* no Function defined use fixed function vertex processing */
1021 }
1022 }
1023
1024 void shader_delete_constant_list(
1025 struct list* clist) {
1026
1027 struct list *ptr;
1028 struct local_constant* constant;
1029
1030 ptr = list_head(clist);
1031 while (ptr) {
1032 constant = LIST_ENTRY(ptr, struct local_constant, entry);
1033 ptr = list_next(clist, ptr);
1034 HeapFree(GetProcessHeap(), 0, constant);
1035 }
1036 }
1037
1038 static void shader_none_select(IWineD3DDevice *iface, BOOL usePS, BOOL useVS) {}
1039 static void shader_none_select_depth_blt(IWineD3DDevice *iface) {}
1040 static void shader_none_load_constants(IWineD3DDevice *iface, char usePS, char useVS) {}
1041 static void shader_none_cleanup(IWineD3DDevice *iface) {}
1042
1043 const shader_backend_t none_shader_backend = {
1044 &shader_none_select,
1045 &shader_none_select_depth_blt,
1046 &shader_none_load_constants,
1047 &shader_none_cleanup
1048 };
useful hacks and other patches not (yet) suitable for mainline