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