?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dxgi: Don't crash and just skip the tests if glX in not available.
[wine/testsucceed.git] / dlls / wined3d / baseshader.c
blob1c7c565c32507d24ae0716f090af495022b68f2b
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 * Copyright 2007-2008 Stefan Dösinger for CodeWeavers
10 *
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
14 * version 2.1 of the License, or (at your option) any later version.
15 *
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
20 *
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with this library; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 */
25
26 #include "config.h"
27 #include <string.h>
28 #include <stdio.h>
29 #include "wined3d_private.h"
30
31 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
32 WINE_DECLARE_DEBUG_CHANNEL(d3d);
33
34 #define GLNAME_REQUIRE_GLSL ((const char *)1)
35
36 static void shader_dump_param(IWineD3DBaseShader *iface, const DWORD param, const DWORD addr_token, int input);
37
38 static inline BOOL shader_is_version_token(DWORD token) {
39 return shader_is_pshader_version(token) ||
40 shader_is_vshader_version(token);
41 }
42
43 int shader_addline(
44 SHADER_BUFFER* buffer,
45 const char *format, ...) {
46
47 char* base = buffer->buffer + buffer->bsize;
48 int rc;
49
50 va_list args;
51 va_start(args, format);
52 rc = vsnprintf(base, SHADER_PGMSIZE - 1 - buffer->bsize, format, args);
53 va_end(args);
54
55 if (rc < 0 || /* C89 */
56 rc > SHADER_PGMSIZE - 1 - buffer->bsize) { /* C99 */
57
58 ERR("The buffer allocated for the shader program string "
59 "is too small at %d bytes.\n", SHADER_PGMSIZE);
60 buffer->bsize = SHADER_PGMSIZE - 1;
61 return -1;
62 }
63
64 if (buffer->newline) {
65 TRACE("GL HW (%u, %u) : %s", buffer->lineNo + 1, buffer->bsize, base);
66 buffer->newline = FALSE;
67 } else {
68 TRACE("%s", base);
69 }
70
71 buffer->bsize += rc;
72 if (buffer->buffer[buffer->bsize-1] == '\n') {
73 buffer->lineNo++;
74 buffer->newline = TRUE;
75 }
76 return 0;
77 }
78
79 const SHADER_OPCODE* shader_get_opcode(
80 IWineD3DBaseShader *iface, const DWORD code) {
81
82 IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl*) iface;
83
84 DWORD i = 0;
85 DWORD hex_version = This->baseShader.hex_version;
86 const SHADER_OPCODE *shader_ins = This->baseShader.shader_ins;
87
88 /** TODO: use dichotomic search */
89 while (NULL != shader_ins[i].name) {
90 if (((code & WINED3DSI_OPCODE_MASK) == shader_ins[i].opcode) &&
91 (((hex_version >= shader_ins[i].min_version) && (hex_version <= shader_ins[i].max_version)) ||
92 ((shader_ins[i].min_version == 0) && (shader_ins[i].max_version == 0)))) {
93 return &shader_ins[i];
94 }
95 ++i;
96 }
97 FIXME("Unsupported opcode %#x(%d) masked %#x, shader version %#x\n",
98 code, code, code & WINED3DSI_OPCODE_MASK, hex_version);
99 return NULL;
100 }
101
102 /* Read a parameter opcode from the input stream,
103 * and possibly a relative addressing token.
104 * Return the number of tokens read */
105 static int shader_get_param(IWineD3DBaseShader *iface, const DWORD *pToken, DWORD *param, 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 length 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 static int shader_skip_unrecognized(IWineD3DBaseShader *iface, const DWORD *pToken)
142 {
143 int tokens_read = 0;
144 int i = 0;
145
146 /* TODO: Think of a good name for 0x80000000 and replace it with a constant */
147 while (*pToken & 0x80000000) {
148
149 DWORD param, addr_token;
150 tokens_read += shader_get_param(iface, pToken, &param, &addr_token);
151 pToken += tokens_read;
152
153 FIXME("Unrecognized opcode param: token=0x%08x "
154 "addr_token=0x%08x name=", param, addr_token);
155 shader_dump_param(iface, param, addr_token, i);
156 FIXME("\n");
157 ++i;
158 }
159 return tokens_read;
160 }
161
162 /* Convert floating point offset relative
163 * to a register file to an absolute offset for float constants */
164 static unsigned int shader_get_float_offset(const DWORD reg)
165 {
166 unsigned int regnum = reg & WINED3DSP_REGNUM_MASK;
167 int regtype = shader_get_regtype(reg);
168
169 switch (regtype) {
170 case WINED3DSPR_CONST: return regnum;
171 case WINED3DSPR_CONST2: return 2048 + regnum;
172 case WINED3DSPR_CONST3: return 4096 + regnum;
173 case WINED3DSPR_CONST4: return 6144 + regnum;
174 default:
175 FIXME("Unsupported register type: %d\n", regtype);
176 return regnum;
177 }
178 }
179
180 static void shader_delete_constant_list(struct list* clist) {
181
182 struct list *ptr;
183 struct local_constant* constant;
184
185 ptr = list_head(clist);
186 while (ptr) {
187 constant = LIST_ENTRY(ptr, struct local_constant, entry);
188 ptr = list_next(clist, ptr);
189 HeapFree(GetProcessHeap(), 0, constant);
190 }
191 list_init(clist);
192 }
193
194 /* Note that this does not count the loop register
195 * as an address register. */
196
197 HRESULT shader_get_registers_used(
198 IWineD3DBaseShader *iface,
199 shader_reg_maps* reg_maps,
200 semantic* semantics_in,
201 semantic* semantics_out,
202 CONST DWORD* pToken,
203 IWineD3DStateBlockImpl *stateBlock) {
204
205 IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
206 unsigned int cur_loop_depth = 0, max_loop_depth = 0;
207
208 /* There are some minor differences between pixel and vertex shaders */
209 char pshader = shader_is_pshader_version(This->baseShader.hex_version);
210
211 memset(reg_maps->bumpmat, 0, sizeof(reg_maps->bumpmat));
212 memset(reg_maps->luminanceparams, 0, sizeof(reg_maps->luminanceparams));
213
214 if (pToken == NULL)
215 return WINED3D_OK;
216
217 /* get_registers_used is called on every compile on some 1.x shaders, which can result
218 * in stacking up a collection of local constants. Delete the old constants if existing
219 */
220 shader_delete_constant_list(&This->baseShader.constantsF);
221 shader_delete_constant_list(&This->baseShader.constantsB);
222 shader_delete_constant_list(&This->baseShader.constantsI);
223
224 while (WINED3DVS_END() != *pToken) {
225 CONST SHADER_OPCODE* curOpcode;
226 DWORD opcode_token;
227
228 /* Skip version */
229 if (shader_is_version_token(*pToken)) {
230 ++pToken;
231 continue;
232
233 /* Skip comments */
234 } else if (shader_is_comment(*pToken)) {
235 DWORD comment_len = (*pToken & WINED3DSI_COMMENTSIZE_MASK) >> WINED3DSI_COMMENTSIZE_SHIFT;
236 ++pToken;
237 pToken += comment_len;
238 continue;
239 }
240
241 /* Fetch opcode */
242 opcode_token = *pToken++;
243 curOpcode = shader_get_opcode(iface, opcode_token);
244
245 /* Unhandled opcode, and its parameters */
246 if (NULL == curOpcode) {
247 while (*pToken & 0x80000000)
248 ++pToken;
249
250 /* Handle declarations */
251 } else if (WINED3DSIO_DCL == curOpcode->opcode) {
252
253 DWORD usage = *pToken++;
254 DWORD param = *pToken++;
255 DWORD regtype = shader_get_regtype(param);
256 unsigned int regnum = param & WINED3DSP_REGNUM_MASK;
257
258 /* Vshader: mark attributes used
259 Pshader: mark 3.0 input registers used, save token */
260 if (WINED3DSPR_INPUT == regtype) {
261
262 if (!pshader)
263 reg_maps->attributes[regnum] = 1;
264 else
265 reg_maps->packed_input[regnum] = 1;
266
267 semantics_in[regnum].usage = usage;
268 semantics_in[regnum].reg = param;
269
270 /* Vshader: mark 3.0 output registers used, save token */
271 } else if (WINED3DSPR_OUTPUT == regtype) {
272 reg_maps->packed_output[regnum] = 1;
273 semantics_out[regnum].usage = usage;
274 semantics_out[regnum].reg = param;
275 if (usage & (WINED3DDECLUSAGE_FOG << WINED3DSP_DCL_USAGE_SHIFT))
276 reg_maps->fog = 1;
277
278 /* Save sampler usage token */
279 } else if (WINED3DSPR_SAMPLER == regtype)
280 reg_maps->samplers[regnum] = usage;
281
282 } else if (WINED3DSIO_DEF == curOpcode->opcode) {
283
284 local_constant* lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant));
285 if (!lconst) return E_OUTOFMEMORY;
286 lconst->idx = *pToken & WINED3DSP_REGNUM_MASK;
287 memcpy(lconst->value, pToken + 1, 4 * sizeof(DWORD));
288
289 /* In pixel shader 1.X shaders, the constants are clamped between [-1;1] */
290 if(WINED3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) == 1 && pshader) {
291 float *value = (float *) lconst->value;
292 if(value[0] < -1.0) value[0] = -1.0;
293 else if(value[0] > 1.0) value[0] = 1.0;
294 if(value[1] < -1.0) value[1] = -1.0;
295 else if(value[1] > 1.0) value[1] = 1.0;
296 if(value[2] < -1.0) value[2] = -1.0;
297 else if(value[2] > 1.0) value[2] = 1.0;
298 if(value[3] < -1.0) value[3] = -1.0;
299 else if(value[3] > 1.0) value[3] = 1.0;
300 }
301
302 list_add_head(&This->baseShader.constantsF, &lconst->entry);
303 pToken += curOpcode->num_params;
304
305 } else if (WINED3DSIO_DEFI == curOpcode->opcode) {
306
307 local_constant* lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant));
308 if (!lconst) return E_OUTOFMEMORY;
309 lconst->idx = *pToken & WINED3DSP_REGNUM_MASK;
310 memcpy(lconst->value, pToken + 1, 4 * sizeof(DWORD));
311 list_add_head(&This->baseShader.constantsI, &lconst->entry);
312 pToken += curOpcode->num_params;
313
314 } else if (WINED3DSIO_DEFB == curOpcode->opcode) {
315
316 local_constant* lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant));
317 if (!lconst) return E_OUTOFMEMORY;
318 lconst->idx = *pToken & WINED3DSP_REGNUM_MASK;
319 memcpy(lconst->value, pToken + 1, 1 * sizeof(DWORD));
320 list_add_head(&This->baseShader.constantsB, &lconst->entry);
321 pToken += curOpcode->num_params;
322
323 /* If there's a loop in the shader */
324 } else if (WINED3DSIO_LOOP == curOpcode->opcode ||
325 WINED3DSIO_REP == curOpcode->opcode) {
326 cur_loop_depth++;
327 if(cur_loop_depth > max_loop_depth)
328 max_loop_depth = cur_loop_depth;
329 pToken += curOpcode->num_params;
330
331 } else if (WINED3DSIO_ENDLOOP == curOpcode->opcode ||
332 WINED3DSIO_ENDREP == curOpcode->opcode) {
333 cur_loop_depth--;
334
335 /* For subroutine prototypes */
336 } else if (WINED3DSIO_LABEL == curOpcode->opcode) {
337
338 DWORD snum = *pToken & WINED3DSP_REGNUM_MASK;
339 reg_maps->labels[snum] = 1;
340 pToken += curOpcode->num_params;
341
342 /* Set texture, address, temporary registers */
343 } else {
344 int i, limit;
345
346 /* Declare 1.X samplers implicitly, based on the destination reg. number */
347 if (WINED3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) == 1 &&
348 pshader /* Filter different instructions with the same enum values in VS */ &&
349 (WINED3DSIO_TEX == curOpcode->opcode ||
350 WINED3DSIO_TEXBEM == curOpcode->opcode ||
351 WINED3DSIO_TEXBEML == curOpcode->opcode ||
352 WINED3DSIO_TEXDP3TEX == curOpcode->opcode ||
353 WINED3DSIO_TEXM3x2TEX == curOpcode->opcode ||
354 WINED3DSIO_TEXM3x3SPEC == curOpcode->opcode ||
355 WINED3DSIO_TEXM3x3TEX == curOpcode->opcode ||
356 WINED3DSIO_TEXM3x3VSPEC == curOpcode->opcode ||
357 WINED3DSIO_TEXREG2AR == curOpcode->opcode ||
358 WINED3DSIO_TEXREG2GB == curOpcode->opcode ||
359 WINED3DSIO_TEXREG2RGB == curOpcode->opcode)) {
360
361 /* Fake sampler usage, only set reserved bit and ttype */
362 DWORD sampler_code = *pToken & WINED3DSP_REGNUM_MASK;
363
364 if(!stateBlock->textures[sampler_code]) {
365 ERR("No texture bound to sampler %d\n", sampler_code);
366 reg_maps->samplers[sampler_code] = (0x1 << 31) | WINED3DSTT_2D;
367 } else {
368 int texType = IWineD3DBaseTexture_GetTextureDimensions(stateBlock->textures[sampler_code]);
369 switch(texType) {
370 /* We have to select between texture rectangles and 2D textures later because 2.0 and
371 * 3.0 shaders only have WINED3DSTT_2D as well
372 */
373 case GL_TEXTURE_RECTANGLE_ARB:
374 case GL_TEXTURE_2D:
375 reg_maps->samplers[sampler_code] = (0x1 << 31) | WINED3DSTT_2D;
376 break;
377
378 case GL_TEXTURE_3D:
379 reg_maps->samplers[sampler_code] = (0x1 << 31) | WINED3DSTT_VOLUME;
380 break;
381
382 case GL_TEXTURE_CUBE_MAP_ARB:
383 reg_maps->samplers[sampler_code] = (0x1 << 31) | WINED3DSTT_CUBE;
384 break;
385
386 default:
387 ERR("Unexpected gl texture type found: %d\n", texType);
388 reg_maps->samplers[sampler_code] = (0x1 << 31) | WINED3DSTT_2D;
389 }
390 }
391
392 /* texbem is only valid with < 1.4 pixel shaders */
393 if(WINED3DSIO_TEXBEM == curOpcode->opcode ||
394 WINED3DSIO_TEXBEML == curOpcode->opcode) {
395 reg_maps->bumpmat[sampler_code] = TRUE;
396 if(WINED3DSIO_TEXBEML == curOpcode->opcode) {
397 reg_maps->luminanceparams[sampler_code] = TRUE;
398 }
399 }
400 }
401 if(WINED3DSIO_NRM == curOpcode->opcode) {
402 reg_maps->usesnrm = 1;
403 } else if(WINED3DSIO_BEM == curOpcode->opcode && pshader) {
404 DWORD regnum = *pToken & WINED3DSP_REGNUM_MASK;
405 reg_maps->bumpmat[regnum] = TRUE;
406 } else if(WINED3DSIO_DSY == curOpcode->opcode) {
407 reg_maps->usesdsy = 1;
408 }
409
410 /* This will loop over all the registers and try to
411 * make a bitmask of the ones we're interested in.
412 *
413 * Relative addressing tokens are ignored, but that's
414 * okay, since we'll catch any address registers when
415 * they are initialized (required by spec) */
416
417 limit = (opcode_token & WINED3DSHADER_INSTRUCTION_PREDICATED)?
418 curOpcode->num_params + 1: curOpcode->num_params;
419
420 for (i = 0; i < limit; ++i) {
421
422 DWORD param, addr_token, reg, regtype;
423 pToken += shader_get_param(iface, pToken, &param, &addr_token);
424
425 regtype = shader_get_regtype(param);
426 reg = param & WINED3DSP_REGNUM_MASK;
427
428 if (WINED3DSPR_TEXTURE == regtype) { /* vs: WINED3DSPR_ADDR */
429
430 if (pshader)
431 reg_maps->texcoord[reg] = 1;
432 else
433 reg_maps->address[reg] = 1;
434 }
435
436 else if (WINED3DSPR_TEMP == regtype)
437 reg_maps->temporary[reg] = 1;
438
439 else if (WINED3DSPR_INPUT == regtype) {
440 if( !pshader)
441 reg_maps->attributes[reg] = 1;
442 else {
443 if(param & WINED3DSHADER_ADDRMODE_RELATIVE) {
444 /* If relative addressing is used, we must assume that all registers
445 * are used. Even if it is a construct like v3[aL], we can't assume
446 * that v0, v1 and v2 aren't read because aL can be negative
447 */
448 unsigned int i;
449 for(i = 0; i < MAX_REG_INPUT; i++) {
450 ((IWineD3DPixelShaderImpl *) This)->input_reg_used[i] = TRUE;
451 }
452 } else {
453 ((IWineD3DPixelShaderImpl *) This)->input_reg_used[reg] = TRUE;
454 }
455 }
456 }
457
458 else if (WINED3DSPR_RASTOUT == regtype && reg == 1)
459 reg_maps->fog = 1;
460
461 else if (WINED3DSPR_MISCTYPE == regtype && reg == 0 && pshader)
462 reg_maps->vpos = 1;
463
464 else if(WINED3DSPR_CONST == regtype) {
465 if(param & WINED3DSHADER_ADDRMODE_RELATIVE) {
466 if(!pshader) {
467 if(reg <= ((IWineD3DVertexShaderImpl *) This)->min_rel_offset) {
468 ((IWineD3DVertexShaderImpl *) This)->min_rel_offset = reg;
469 } else if(reg >= ((IWineD3DVertexShaderImpl *) This)->max_rel_offset) {
470 ((IWineD3DVertexShaderImpl *) This)->max_rel_offset = reg;
471 }
472 }
473 reg_maps->usesrelconstF = TRUE;
474 }
475 }
476
477 /* WINED3DSPR_TEXCRDOUT is the same as WINED3DSPR_OUTPUT. _OUTPUT can be > MAX_REG_TEXCRD and is used
478 * in >= 3.0 shaders. Filter 3.0 shaders to prevent overflows, and also filter pixel shaders because TECRDOUT
479 * isn't used in them, but future register types might cause issues
480 */
481 else if(WINED3DSPR_TEXCRDOUT == regtype && i == 0 /* Only look at writes */ &&
482 !pshader && WINED3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) < 3) {
483 reg_maps->texcoord_mask[reg] |= shader_get_writemask(param);
484 }
485 }
486 }
487 }
488 reg_maps->loop_depth = max_loop_depth;
489
490 return WINED3D_OK;
491 }
492
493 static void shader_dump_decl_usage(
494 IWineD3DBaseShaderImpl* This,
495 DWORD decl,
496 DWORD param) {
497
498 DWORD regtype = shader_get_regtype(param);
499
500 TRACE("dcl");
501
502 if (regtype == WINED3DSPR_SAMPLER) {
503 DWORD ttype = decl & WINED3DSP_TEXTURETYPE_MASK;
504
505 switch (ttype) {
506 case WINED3DSTT_2D: TRACE("_2d"); break;
507 case WINED3DSTT_CUBE: TRACE("_cube"); break;
508 case WINED3DSTT_VOLUME: TRACE("_volume"); break;
509 default: TRACE("_unknown_ttype(0x%08x)", ttype);
510 }
511
512 } else {
513
514 DWORD usage = decl & WINED3DSP_DCL_USAGE_MASK;
515 DWORD idx = (decl & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
516
517 /* Pixel shaders 3.0 don't have usage semantics */
518 char pshader = shader_is_pshader_version(This->baseShader.hex_version);
519 if (pshader && This->baseShader.hex_version < WINED3DPS_VERSION(3,0))
520 return;
521 else
522 TRACE("_");
523
524 switch(usage) {
525 case WINED3DDECLUSAGE_POSITION:
526 TRACE("position%d", idx);
527 break;
528 case WINED3DDECLUSAGE_BLENDINDICES:
529 TRACE("blend");
530 break;
531 case WINED3DDECLUSAGE_BLENDWEIGHT:
532 TRACE("weight");
533 break;
534 case WINED3DDECLUSAGE_NORMAL:
535 TRACE("normal%d", idx);
536 break;
537 case WINED3DDECLUSAGE_PSIZE:
538 TRACE("psize");
539 break;
540 case WINED3DDECLUSAGE_COLOR:
541 if(idx == 0) {
542 TRACE("color");
543 } else {
544 TRACE("specular%d", (idx - 1));
545 }
546 break;
547 case WINED3DDECLUSAGE_TEXCOORD:
548 TRACE("texture%d", idx);
549 break;
550 case WINED3DDECLUSAGE_TANGENT:
551 TRACE("tangent");
552 break;
553 case WINED3DDECLUSAGE_BINORMAL:
554 TRACE("binormal");
555 break;
556 case WINED3DDECLUSAGE_TESSFACTOR:
557 TRACE("tessfactor");
558 break;
559 case WINED3DDECLUSAGE_POSITIONT:
560 TRACE("positionT%d", idx);
561 break;
562 case WINED3DDECLUSAGE_FOG:
563 TRACE("fog");
564 break;
565 case WINED3DDECLUSAGE_DEPTH:
566 TRACE("depth");
567 break;
568 case WINED3DDECLUSAGE_SAMPLE:
569 TRACE("sample");
570 break;
571 default:
572 FIXME("unknown_semantics(0x%08x)", usage);
573 }
574 }
575 }
576
577 static void shader_dump_arr_entry(
578 IWineD3DBaseShader *iface,
579 const DWORD param,
580 const DWORD addr_token,
581 unsigned int reg,
582 int input) {
583
584 char relative =
585 ((param & WINED3DSHADER_ADDRESSMODE_MASK) == WINED3DSHADER_ADDRMODE_RELATIVE);
586
587 if (relative) {
588 TRACE("[");
589 if (addr_token)
590 shader_dump_param(iface, addr_token, 0, input);
591 else
592 TRACE("a0.x");
593 TRACE(" + ");
594 }
595 TRACE("%u", reg);
596 if (relative)
597 TRACE("]");
598 }
599
600 static void shader_dump_param(IWineD3DBaseShader *iface, const DWORD param, const DWORD addr_token, int input)
601 {
602 IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
603 static const char * const rastout_reg_names[] = { "oPos", "oFog", "oPts" };
604 static const char * const misctype_reg_names[] = { "vPos", "vFace"};
605 char swizzle_reg_chars[4];
606
607 DWORD reg = param & WINED3DSP_REGNUM_MASK;
608 DWORD regtype = shader_get_regtype(param);
609 DWORD modifier = param & WINED3DSP_SRCMOD_MASK;
610
611 /* There are some minor differences between pixel and vertex shaders */
612 char pshader = shader_is_pshader_version(This->baseShader.hex_version);
613
614 /* For one, we'd prefer color components to be shown for pshaders.
615 * FIXME: use the swizzle function for this */
616
617 swizzle_reg_chars[0] = pshader? 'r': 'x';
618 swizzle_reg_chars[1] = pshader? 'g': 'y';
619 swizzle_reg_chars[2] = pshader? 'b': 'z';
620 swizzle_reg_chars[3] = pshader? 'a': 'w';
621
622 if (input) {
623 if ( (modifier == WINED3DSPSM_NEG) ||
624 (modifier == WINED3DSPSM_BIASNEG) ||
625 (modifier == WINED3DSPSM_SIGNNEG) ||
626 (modifier == WINED3DSPSM_X2NEG) ||
627 (modifier == WINED3DSPSM_ABSNEG) )
628 TRACE("-");
629 else if (modifier == WINED3DSPSM_COMP)
630 TRACE("1-");
631 else if (modifier == WINED3DSPSM_NOT)
632 TRACE("!");
633
634 if (modifier == WINED3DSPSM_ABS || modifier == WINED3DSPSM_ABSNEG)
635 TRACE("abs(");
636 }
637
638 switch (regtype) {
639 case WINED3DSPR_TEMP:
640 TRACE("r%u", reg);
641 break;
642 case WINED3DSPR_INPUT:
643 TRACE("v");
644 shader_dump_arr_entry(iface, param, addr_token, reg, input);
645 break;
646 case WINED3DSPR_CONST:
647 case WINED3DSPR_CONST2:
648 case WINED3DSPR_CONST3:
649 case WINED3DSPR_CONST4:
650 TRACE("c");
651 shader_dump_arr_entry(iface, param, addr_token, shader_get_float_offset(param), input);
652 break;
653 case WINED3DSPR_TEXTURE: /* vs: case D3DSPR_ADDR */
654 TRACE("%c%u", (pshader? 't':'a'), reg);
655 break;
656 case WINED3DSPR_RASTOUT:
657 TRACE("%s", rastout_reg_names[reg]);
658 break;
659 case WINED3DSPR_COLOROUT:
660 TRACE("oC%u", reg);
661 break;
662 case WINED3DSPR_DEPTHOUT:
663 TRACE("oDepth");
664 break;
665 case WINED3DSPR_ATTROUT:
666 TRACE("oD%u", reg);
667 break;
668 case WINED3DSPR_TEXCRDOUT:
669
670 /* Vertex shaders >= 3.0 use general purpose output registers
671 * (WINED3DSPR_OUTPUT), which can include an address token */
672
673 if (WINED3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) >= 3) {
674 TRACE("o");
675 shader_dump_arr_entry(iface, param, addr_token, reg, input);
676 }
677 else
678 TRACE("oT%u", reg);
679 break;
680 case WINED3DSPR_CONSTINT:
681 TRACE("i");
682 shader_dump_arr_entry(iface, param, addr_token, reg, input);
683 break;
684 case WINED3DSPR_CONSTBOOL:
685 TRACE("b");
686 shader_dump_arr_entry(iface, param, addr_token, reg, input);
687 break;
688 case WINED3DSPR_LABEL:
689 TRACE("l%u", reg);
690 break;
691 case WINED3DSPR_LOOP:
692 TRACE("aL");
693 break;
694 case WINED3DSPR_SAMPLER:
695 TRACE("s%u", reg);
696 break;
697 case WINED3DSPR_MISCTYPE:
698 if (reg > 1) {
699 FIXME("Unhandled misctype register %d\n", reg);
700 } else {
701 TRACE("%s", misctype_reg_names[reg]);
702 }
703 break;
704 case WINED3DSPR_PREDICATE:
705 TRACE("p%u", reg);
706 break;
707 default:
708 TRACE("unhandled_rtype(%#x)", regtype);
709 break;
710 }
711
712 if (!input) {
713 /* operand output (for modifiers and shift, see dump_ins_modifiers) */
714
715 if ((param & WINED3DSP_WRITEMASK_ALL) != WINED3DSP_WRITEMASK_ALL) {
716 TRACE(".");
717 if (param & WINED3DSP_WRITEMASK_0) TRACE("%c", swizzle_reg_chars[0]);
718 if (param & WINED3DSP_WRITEMASK_1) TRACE("%c", swizzle_reg_chars[1]);
719 if (param & WINED3DSP_WRITEMASK_2) TRACE("%c", swizzle_reg_chars[2]);
720 if (param & WINED3DSP_WRITEMASK_3) TRACE("%c", swizzle_reg_chars[3]);
721 }
722
723 } else {
724 /** operand input */
725 DWORD swizzle = (param & WINED3DSP_SWIZZLE_MASK) >> WINED3DSP_SWIZZLE_SHIFT;
726 DWORD swizzle_r = swizzle & 0x03;
727 DWORD swizzle_g = (swizzle >> 2) & 0x03;
728 DWORD swizzle_b = (swizzle >> 4) & 0x03;
729 DWORD swizzle_a = (swizzle >> 6) & 0x03;
730
731 if (0 != modifier) {
732 switch (modifier) {
733 case WINED3DSPSM_NONE: break;
734 case WINED3DSPSM_NEG: break;
735 case WINED3DSPSM_NOT: break;
736 case WINED3DSPSM_BIAS: TRACE("_bias"); break;
737 case WINED3DSPSM_BIASNEG: TRACE("_bias"); break;
738 case WINED3DSPSM_SIGN: TRACE("_bx2"); break;
739 case WINED3DSPSM_SIGNNEG: TRACE("_bx2"); break;
740 case WINED3DSPSM_COMP: break;
741 case WINED3DSPSM_X2: TRACE("_x2"); break;
742 case WINED3DSPSM_X2NEG: TRACE("_x2"); break;
743 case WINED3DSPSM_DZ: TRACE("_dz"); break;
744 case WINED3DSPSM_DW: TRACE("_dw"); break;
745 case WINED3DSPSM_ABSNEG: TRACE(")"); break;
746 case WINED3DSPSM_ABS: TRACE(")"); break;
747 default:
748 TRACE("_unknown_modifier(%#x)", modifier >> WINED3DSP_SRCMOD_SHIFT);
749 }
750 }
751
752 /**
753 * swizzle bits fields:
754 * RRGGBBAA
755 */
756 if ((WINED3DVS_NOSWIZZLE >> WINED3DVS_SWIZZLE_SHIFT) != swizzle) {
757 if (swizzle_r == swizzle_g &&
758 swizzle_r == swizzle_b &&
759 swizzle_r == swizzle_a) {
760 TRACE(".%c", swizzle_reg_chars[swizzle_r]);
761 } else {
762 TRACE(".%c%c%c%c",
763 swizzle_reg_chars[swizzle_r],
764 swizzle_reg_chars[swizzle_g],
765 swizzle_reg_chars[swizzle_b],
766 swizzle_reg_chars[swizzle_a]);
767 }
768 }
769 }
770 }
771
772 static void shader_color_correction(IWineD3DBaseShaderImpl *shader,
773 IWineD3DDeviceImpl *device, const struct SHADER_OPCODE_ARG *arg)
774 {
775 DWORD hex_version = shader->baseShader.hex_version;
776 IWineD3DBaseTextureImpl *texture;
777 struct color_fixup_desc fixup;
778 BOOL recorded = FALSE;
779 DWORD sampler_idx;
780 UINT i;
781
782 switch(arg->opcode->opcode)
783 {
784 case WINED3DSIO_TEX:
785 if (hex_version < WINED3DPS_VERSION(2,0)) sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
786 else sampler_idx = arg->src[1] & WINED3DSP_REGNUM_MASK;
787 break;
788
789 case WINED3DSIO_TEXLDL:
790 FIXME("Add color fixup for vertex texture WINED3DSIO_TEXLDL\n");
791 return;
792
793 case WINED3DSIO_TEXDP3TEX:
794 case WINED3DSIO_TEXM3x3TEX:
795 case WINED3DSIO_TEXM3x3SPEC:
796 case WINED3DSIO_TEXM3x3VSPEC:
797 case WINED3DSIO_TEXBEM:
798 case WINED3DSIO_TEXREG2AR:
799 case WINED3DSIO_TEXREG2GB:
800 case WINED3DSIO_TEXREG2RGB:
801 sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
802 break;
803
804 default:
805 /* Not a texture sampling instruction, nothing to do */
806 return;
807 };
808
809 texture = (IWineD3DBaseTextureImpl *)device->stateBlock->textures[sampler_idx];
810 if (texture) fixup = texture->baseTexture.shader_color_fixup;
811 else fixup = COLOR_FIXUP_IDENTITY;
812
813 /* before doing anything, record the sampler with the format in the format conversion list,
814 * but check if it's not there already */
815 for (i = 0; i < shader->baseShader.num_sampled_samplers; ++i)
816 {
817 if (shader->baseShader.sampled_samplers[i] == sampler_idx)
818 {
819 recorded = TRUE;
820 break;
821 }
822 }
823
824 if (!recorded)
825 {
826 shader->baseShader.sampled_samplers[shader->baseShader.num_sampled_samplers] = sampler_idx;
827 ++shader->baseShader.num_sampled_samplers;
828 }
829
830 device->shader_backend->shader_color_correction(arg, fixup);
831 }
832
833 /** Shared code in order to generate the bulk of the shader string.
834 Use the shader_header_fct & shader_footer_fct to add strings
835 that are specific to pixel or vertex functions
836 NOTE: A description of how to parse tokens can be found on msdn */
837 void shader_generate_main(IWineD3DBaseShader *iface, SHADER_BUFFER* buffer,
838 const shader_reg_maps* reg_maps, CONST DWORD* pFunction)
839 {
840 IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
841 IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) This->baseShader.device; /* To access shader backend callbacks */
842 const SHADER_HANDLER *handler_table = device->shader_backend->shader_instruction_handler_table;
843 const DWORD *pToken = pFunction;
844 const SHADER_OPCODE *curOpcode = NULL;
845 SHADER_HANDLER hw_fct = NULL;
846 DWORD i;
847 SHADER_OPCODE_ARG hw_arg;
848
849 /* Initialize current parsing state */
850 hw_arg.shader = iface;
851 hw_arg.buffer = buffer;
852 hw_arg.reg_maps = reg_maps;
853 This->baseShader.parse_state.current_row = 0;
854
855 /* Second pass, process opcodes */
856 if (NULL != pToken) {
857 while (WINED3DPS_END() != *pToken) {
858
859 /* Skip version token */
860 if (shader_is_version_token(*pToken)) {
861 ++pToken;
862 continue;
863 }
864
865 /* Skip comment tokens */
866 if (shader_is_comment(*pToken)) {
867 DWORD comment_len = (*pToken & WINED3DSI_COMMENTSIZE_MASK) >> WINED3DSI_COMMENTSIZE_SHIFT;
868 ++pToken;
869 TRACE("#%s\n", (const char*)pToken);
870 pToken += comment_len;
871 continue;
872 }
873
874 /* Read opcode */
875 hw_arg.opcode_token = *pToken++;
876 curOpcode = shader_get_opcode(iface, hw_arg.opcode_token);
877
878 /* Select handler */
879 if (curOpcode == NULL)
880 hw_fct = NULL;
881 else
882 hw_fct = handler_table[curOpcode->handler_idx];
883
884 /* Unknown opcode and its parameters */
885 if (NULL == curOpcode) {
886 FIXME("Unrecognized opcode: token=0x%08x\n", hw_arg.opcode_token);
887 pToken += shader_skip_unrecognized(iface, pToken);
888
889 /* Nothing to do */
890 } else if (WINED3DSIO_DCL == curOpcode->opcode ||
891 WINED3DSIO_NOP == curOpcode->opcode ||
892 WINED3DSIO_DEF == curOpcode->opcode ||
893 WINED3DSIO_DEFI == curOpcode->opcode ||
894 WINED3DSIO_DEFB == curOpcode->opcode ||
895 WINED3DSIO_PHASE == curOpcode->opcode ||
896 WINED3DSIO_RET == curOpcode->opcode) {
897
898 pToken += shader_skip_opcode(This, curOpcode, hw_arg.opcode_token);
899
900 /* If a generator function is set for current shader target, use it */
901 } else if (hw_fct != NULL) {
902
903 hw_arg.opcode = curOpcode;
904
905 /* Destination token */
906 if (curOpcode->dst_token) {
907
908 DWORD param, addr_token = 0;
909 pToken += shader_get_param(iface, pToken, &param, &addr_token);
910 hw_arg.dst = param;
911 hw_arg.dst_addr = addr_token;
912 }
913
914 /* Predication token */
915 if (hw_arg.opcode_token & WINED3DSHADER_INSTRUCTION_PREDICATED)
916 hw_arg.predicate = *pToken++;
917
918 /* Other source tokens */
919 for (i = 0; i < (curOpcode->num_params - curOpcode->dst_token); i++) {
920
921 DWORD param, addr_token = 0;
922 pToken += shader_get_param(iface, pToken, &param, &addr_token);
923 hw_arg.src[i] = param;
924 hw_arg.src_addr[i] = addr_token;
925 }
926
927 /* Call appropriate function for output target */
928 hw_fct(&hw_arg);
929
930 /* Add color correction if needed */
931 shader_color_correction(This, device, &hw_arg);
932
933 /* Process instruction modifiers for GLSL apps ( _sat, etc. ) */
934 /* FIXME: This should be internal to the shader backend.
935 * Also, right now this is the only reason "shader_mode" exists. */
936 if (This->baseShader.shader_mode == SHADER_GLSL)
937 shader_glsl_add_instruction_modifiers(&hw_arg);
938
939 /* Unhandled opcode */
940 } else {
941
942 FIXME("Can't handle opcode %s in hwShader\n", curOpcode->name);
943 pToken += shader_skip_opcode(This, curOpcode, hw_arg.opcode_token);
944 }
945 }
946 /* TODO: What about result.depth? */
947
948 }
949 }
950
951 static void shader_dump_ins_modifiers(const DWORD output)
952 {
953 DWORD shift = (output & WINED3DSP_DSTSHIFT_MASK) >> WINED3DSP_DSTSHIFT_SHIFT;
954 DWORD mmask = output & WINED3DSP_DSTMOD_MASK;
955
956 switch (shift) {
957 case 0: break;
958 case 13: TRACE("_d8"); break;
959 case 14: TRACE("_d4"); break;
960 case 15: TRACE("_d2"); break;
961 case 1: TRACE("_x2"); break;
962 case 2: TRACE("_x4"); break;
963 case 3: TRACE("_x8"); break;
964 default: TRACE("_unhandled_shift(%d)", shift); break;
965 }
966
967 if (mmask & WINED3DSPDM_SATURATE) TRACE("_sat");
968 if (mmask & WINED3DSPDM_PARTIALPRECISION) TRACE("_pp");
969 if (mmask & WINED3DSPDM_MSAMPCENTROID) TRACE("_centroid");
970
971 mmask &= ~(WINED3DSPDM_SATURATE | WINED3DSPDM_PARTIALPRECISION | WINED3DSPDM_MSAMPCENTROID);
972 if (mmask)
973 FIXME("_unrecognized_modifier(%#x)", mmask >> WINED3DSP_DSTMOD_SHIFT);
974 }
975
976 /* First pass: trace shader, initialize length and version */
977 void shader_trace_init(
978 IWineD3DBaseShader *iface,
979 const DWORD* pFunction) {
980
981 IWineD3DBaseShaderImpl *This =(IWineD3DBaseShaderImpl *)iface;
982
983 const DWORD* pToken = pFunction;
984 const SHADER_OPCODE* curOpcode = NULL;
985 DWORD opcode_token;
986 unsigned int len = 0;
987 DWORD i;
988
989 TRACE("(%p) : Parsing program\n", This);
990
991 if (NULL != pToken) {
992 while (WINED3DVS_END() != *pToken) {
993 if (shader_is_version_token(*pToken)) { /** version */
994 This->baseShader.hex_version = *pToken;
995 TRACE("%s_%u_%u\n", shader_is_pshader_version(This->baseShader.hex_version)? "ps": "vs",
996 WINED3DSHADER_VERSION_MAJOR(This->baseShader.hex_version),
997 WINED3DSHADER_VERSION_MINOR(This->baseShader.hex_version));
998 ++pToken;
999 ++len;
1000 continue;
1001 }
1002 if (shader_is_comment(*pToken)) { /** comment */
1003 DWORD comment_len = (*pToken & WINED3DSI_COMMENTSIZE_MASK) >> WINED3DSI_COMMENTSIZE_SHIFT;
1004 ++pToken;
1005 TRACE("//%s\n", (const char*)pToken);
1006 pToken += comment_len;
1007 len += comment_len + 1;
1008 continue;
1009 }
1010 opcode_token = *pToken++;
1011 curOpcode = shader_get_opcode(iface, opcode_token);
1012 len++;
1013
1014 if (NULL == curOpcode) {
1015 int tokens_read;
1016 FIXME("Unrecognized opcode: token=0x%08x\n", opcode_token);
1017 tokens_read = shader_skip_unrecognized(iface, pToken);
1018 pToken += tokens_read;
1019 len += tokens_read;
1020
1021 } else {
1022 if (curOpcode->opcode == WINED3DSIO_DCL) {
1023
1024 DWORD usage = *pToken;
1025 DWORD param = *(pToken + 1);
1026
1027 shader_dump_decl_usage(This, usage, param);
1028 shader_dump_ins_modifiers(param);
1029 TRACE(" ");
1030 shader_dump_param(iface, param, 0, 0);
1031 pToken += 2;
1032 len += 2;
1033
1034 } else if (curOpcode->opcode == WINED3DSIO_DEF) {
1035
1036 unsigned int offset = shader_get_float_offset(*pToken);
1037
1038 TRACE("def c%u = %f, %f, %f, %f", offset,
1039 *(const float *)(pToken + 1),
1040 *(const float *)(pToken + 2),
1041 *(const float *)(pToken + 3),
1042 *(const float *)(pToken + 4));
1043
1044 pToken += 5;
1045 len += 5;
1046 } else if (curOpcode->opcode == WINED3DSIO_DEFI) {
1047
1048 TRACE("defi i%u = %d, %d, %d, %d", *pToken & WINED3DSP_REGNUM_MASK,
1049 *(pToken + 1),
1050 *(pToken + 2),
1051 *(pToken + 3),
1052 *(pToken + 4));
1053
1054 pToken += 5;
1055 len += 5;
1056
1057 } else if (curOpcode->opcode == WINED3DSIO_DEFB) {
1058
1059 TRACE("defb b%u = %s", *pToken & WINED3DSP_REGNUM_MASK,
1060 *(pToken + 1)? "true": "false");
1061
1062 pToken += 2;
1063 len += 2;
1064
1065 } else {
1066
1067 DWORD param, addr_token;
1068 int tokens_read;
1069
1070 /* Print out predication source token first - it follows
1071 * the destination token. */
1072 if (opcode_token & WINED3DSHADER_INSTRUCTION_PREDICATED) {
1073 TRACE("(");
1074 shader_dump_param(iface, *(pToken + 2), 0, 1);
1075 TRACE(") ");
1076 }
1077 if (opcode_token & WINED3DSI_COISSUE) {
1078 /* PixWin marks instructions with the coissue flag with a '+' */
1079 TRACE("+");
1080 }
1081
1082 TRACE("%s", curOpcode->name);
1083
1084 if (curOpcode->opcode == WINED3DSIO_IFC ||
1085 curOpcode->opcode == WINED3DSIO_BREAKC) {
1086
1087 DWORD op = (opcode_token & INST_CONTROLS_MASK) >> INST_CONTROLS_SHIFT;
1088 switch (op) {
1089 case COMPARISON_GT: TRACE("_gt"); break;
1090 case COMPARISON_EQ: TRACE("_eq"); break;
1091 case COMPARISON_GE: TRACE("_ge"); break;
1092 case COMPARISON_LT: TRACE("_lt"); break;
1093 case COMPARISON_NE: TRACE("_ne"); break;
1094 case COMPARISON_LE: TRACE("_le"); break;
1095 default:
1096 TRACE("_(%u)", op);
1097 }
1098 } else if (curOpcode->opcode == WINED3DSIO_TEX &&
1099 This->baseShader.hex_version >= WINED3DPS_VERSION(2,0)) {
1100 if(opcode_token & WINED3DSI_TEXLD_PROJECT) TRACE("p");
1101 }
1102
1103 /* Destination token */
1104 if (curOpcode->dst_token) {
1105
1106 /* Destination token */
1107 tokens_read = shader_get_param(iface, pToken, &param, &addr_token);
1108 pToken += tokens_read;
1109 len += tokens_read;
1110
1111 shader_dump_ins_modifiers(param);
1112 TRACE(" ");
1113 shader_dump_param(iface, param, addr_token, 0);
1114 }
1115
1116 /* Predication token - already printed out, just skip it */
1117 if (opcode_token & WINED3DSHADER_INSTRUCTION_PREDICATED) {
1118 pToken++;
1119 len++;
1120 }
1121
1122 /* Other source tokens */
1123 for (i = curOpcode->dst_token; i < curOpcode->num_params; ++i) {
1124
1125 tokens_read = shader_get_param(iface, pToken, &param, &addr_token);
1126 pToken += tokens_read;
1127 len += tokens_read;
1128
1129 TRACE((i == 0)? " " : ", ");
1130 shader_dump_param(iface, param, addr_token, 1);
1131 }
1132 }
1133 TRACE("\n");
1134 }
1135 }
1136 This->baseShader.functionLength = (len + 1) * sizeof(DWORD);
1137 } else {
1138 This->baseShader.functionLength = 1; /* no Function defined use fixed function vertex processing */
1139 }
1140 }
1141
1142 static const SHADER_HANDLER shader_none_instruction_handler_table[WINED3DSIH_TABLE_SIZE] = {0};
1143 static void shader_none_select(IWineD3DDevice *iface, BOOL usePS, BOOL useVS) {}
1144 static void shader_none_select_depth_blt(IWineD3DDevice *iface, enum tex_types tex_type) {}
1145 static void shader_none_deselect_depth_blt(IWineD3DDevice *iface) {}
1146 static void shader_none_load_constants(IWineD3DDevice *iface, char usePS, char useVS) {}
1147 static void shader_none_cleanup(IWineD3DDevice *iface) {}
1148 static void shader_none_color_correction(const struct SHADER_OPCODE_ARG *arg, struct color_fixup_desc fixup) {}
1149 static void shader_none_destroy(IWineD3DBaseShader *iface) {}
1150 static HRESULT shader_none_alloc(IWineD3DDevice *iface) {return WINED3D_OK;}
1151 static void shader_none_free(IWineD3DDevice *iface) {}
1152 static BOOL shader_none_dirty_const(IWineD3DDevice *iface) {return FALSE;}
1153 static GLuint shader_none_generate_pshader(IWineD3DPixelShader *iface, SHADER_BUFFER *buffer) {
1154 FIXME("NONE shader backend asked to generate a pixel shader\n");
1155 return 0;
1156 }
1157 static void shader_none_generate_vshader(IWineD3DVertexShader *iface, SHADER_BUFFER *buffer) {
1158 FIXME("NONE shader backend asked to generate a vertex shader\n");
1159 }
1160
1161 #define GLINFO_LOCATION (*gl_info)
1162 static void shader_none_get_caps(WINED3DDEVTYPE devtype, const WineD3D_GL_Info *gl_info, struct shader_caps *pCaps)
1163 {
1164 /* Set the shader caps to 0 for the none shader backend */
1165 pCaps->VertexShaderVersion = 0;
1166 pCaps->PixelShaderVersion = 0;
1167 pCaps->PixelShader1xMaxValue = 0.0;
1168 }
1169 #undef GLINFO_LOCATION
1170 static BOOL shader_none_color_fixup_supported(struct color_fixup_desc fixup)
1171 {
1172 if (TRACE_ON(d3d_shader) && TRACE_ON(d3d))
1173 {
1174 TRACE("Checking support for fixup:\n");
1175 dump_color_fixup_desc(fixup);
1176 }
1177
1178 /* Faked to make some apps happy. */
1179 if (!is_yuv_fixup(fixup))
1180 {
1181 TRACE("[OK]\n");
1182 return TRUE;
1183 }
1184
1185 TRACE("[FAILED]\n");
1186 return FALSE;
1187 }
1188
1189 const shader_backend_t none_shader_backend = {
1190 shader_none_instruction_handler_table,
1191 shader_none_select,
1192 shader_none_select_depth_blt,
1193 shader_none_deselect_depth_blt,
1194 shader_none_load_constants,
1195 shader_none_cleanup,
1196 shader_none_color_correction,
1197 shader_none_destroy,
1198 shader_none_alloc,
1199 shader_none_free,
1200 shader_none_dirty_const,
1201 shader_none_generate_pshader,
1202 shader_none_generate_vshader,
1203 shader_none_get_caps,
1204 shader_none_color_fixup_supported,
1205 };
1206
1207 /* *******************************************
1208 IWineD3DPixelShader IUnknown parts follow
1209 ******************************************* */
1210 HRESULT WINAPI IWineD3DBaseShaderImpl_QueryInterface(IWineD3DBaseShader *iface, REFIID riid, LPVOID *ppobj)
1211 {
1212 IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl *)iface;
1213 TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppobj);
1214 if (IsEqualGUID(riid, &IID_IUnknown)
1215 || IsEqualGUID(riid, &IID_IWineD3DBase)
1216 || IsEqualGUID(riid, &IID_IWineD3DBaseShader)
1217 || IsEqualGUID(riid, &IID_IWineD3DPixelShader)) {
1218 IUnknown_AddRef(iface);
1219 *ppobj = This;
1220 return S_OK;
1221 }
1222 *ppobj = NULL;
1223 return E_NOINTERFACE;
1224 }
1225
1226 ULONG WINAPI IWineD3DBaseShaderImpl_AddRef(IWineD3DBaseShader *iface) {
1227 IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)iface;
1228 TRACE("(%p) : AddRef increasing from %d\n", This, This->baseShader.ref);
1229 return InterlockedIncrement(&This->baseShader.ref);
1230 }
1231
1232 ULONG WINAPI IWineD3DBaseShaderImpl_Release(IWineD3DBaseShader *iface) {
1233 IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl *)iface;
1234 IWineD3DDeviceImpl *deviceImpl = (IWineD3DDeviceImpl *) This->baseShader.device;
1235 ULONG ref;
1236 TRACE("(%p) : Releasing from %d\n", This, This->baseShader.ref);
1237 ref = InterlockedDecrement(&This->baseShader.ref);
1238 if (ref == 0) {
1239 deviceImpl->shader_backend->shader_destroy(iface);
1240 HeapFree(GetProcessHeap(), 0, This->baseShader.function);
1241 shader_delete_constant_list(&This->baseShader.constantsF);
1242 shader_delete_constant_list(&This->baseShader.constantsB);
1243 shader_delete_constant_list(&This->baseShader.constantsI);
1244 list_remove(&This->baseShader.shader_list_entry);
1245 HeapFree(GetProcessHeap(), 0, This);
1246 }
1247 return ref;
1248 }
Quick hack tree for wine patches julliard doesn't want to commit