?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winex11: Remove now unnecessary surface wrapper struct.
[wine.git] / dlls / d3dcompiler_43 / utils.c
blob96990c3e0976bca2d02f9ca1e17d19abe073a9e1
1 /*
2 * Copyright 2008 Stefan Dösinger
3 * Copyright 2009 Matteo Bruni
4 * Copyright 2008-2009 Henri Verbeet for CodeWeavers
5 * Copyright 2010 Rico Schüller
6 * Copyright 2012 Matteo Bruni for CodeWeavers
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 *
22 */
23
24 #include <stdio.h>
25
26 #include "d3dcompiler_private.h"
27
28 WINE_DEFAULT_DEBUG_CHANNEL(d3dcompiler);
29
30 #define WINE_D3DCOMPILER_TO_STR(x) case x: return #x
31
32 const char *debug_d3dcompiler_shader_variable_class(D3D_SHADER_VARIABLE_CLASS c)
33 {
34 switch (c)
35 {
36 WINE_D3DCOMPILER_TO_STR(D3D_SVC_SCALAR);
37 WINE_D3DCOMPILER_TO_STR(D3D_SVC_VECTOR);
38 WINE_D3DCOMPILER_TO_STR(D3D_SVC_MATRIX_ROWS);
39 WINE_D3DCOMPILER_TO_STR(D3D_SVC_MATRIX_COLUMNS);
40 WINE_D3DCOMPILER_TO_STR(D3D_SVC_OBJECT);
41 WINE_D3DCOMPILER_TO_STR(D3D_SVC_STRUCT);
42 WINE_D3DCOMPILER_TO_STR(D3D_SVC_INTERFACE_CLASS);
43 WINE_D3DCOMPILER_TO_STR(D3D_SVC_INTERFACE_POINTER);
44 default:
45 FIXME("Unrecognized D3D_SHADER_VARIABLE_CLASS %#x.\n", c);
46 return "unrecognized";
47 }
48 }
49
50 const char *debug_d3dcompiler_shader_variable_type(D3D_SHADER_VARIABLE_TYPE t)
51 {
52 switch (t)
53 {
54 WINE_D3DCOMPILER_TO_STR(D3D_SVT_VOID);
55 WINE_D3DCOMPILER_TO_STR(D3D_SVT_BOOL);
56 WINE_D3DCOMPILER_TO_STR(D3D_SVT_INT);
57 WINE_D3DCOMPILER_TO_STR(D3D_SVT_FLOAT);
58 WINE_D3DCOMPILER_TO_STR(D3D_SVT_STRING);
59 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE);
60 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE1D);
61 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2D);
62 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE3D);
63 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURECUBE);
64 WINE_D3DCOMPILER_TO_STR(D3D_SVT_SAMPLER);
65 WINE_D3DCOMPILER_TO_STR(D3D_SVT_PIXELSHADER);
66 WINE_D3DCOMPILER_TO_STR(D3D_SVT_VERTEXSHADER);
67 WINE_D3DCOMPILER_TO_STR(D3D_SVT_UINT);
68 WINE_D3DCOMPILER_TO_STR(D3D_SVT_UINT8);
69 WINE_D3DCOMPILER_TO_STR(D3D_SVT_GEOMETRYSHADER);
70 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RASTERIZER);
71 WINE_D3DCOMPILER_TO_STR(D3D_SVT_DEPTHSTENCIL);
72 WINE_D3DCOMPILER_TO_STR(D3D_SVT_BLEND);
73 WINE_D3DCOMPILER_TO_STR(D3D_SVT_BUFFER);
74 WINE_D3DCOMPILER_TO_STR(D3D_SVT_CBUFFER);
75 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TBUFFER);
76 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE1DARRAY);
77 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2DARRAY);
78 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RENDERTARGETVIEW);
79 WINE_D3DCOMPILER_TO_STR(D3D_SVT_DEPTHSTENCILVIEW);
80 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2DMS);
81 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2DMSARRAY);
82 WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURECUBEARRAY);
83 WINE_D3DCOMPILER_TO_STR(D3D_SVT_HULLSHADER);
84 WINE_D3DCOMPILER_TO_STR(D3D_SVT_DOMAINSHADER);
85 WINE_D3DCOMPILER_TO_STR(D3D_SVT_INTERFACE_POINTER);
86 WINE_D3DCOMPILER_TO_STR(D3D_SVT_COMPUTESHADER);
87 WINE_D3DCOMPILER_TO_STR(D3D_SVT_DOUBLE);
88 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE1D);
89 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE1DARRAY);
90 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE2D);
91 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE2DARRAY);
92 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE3D);
93 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWBUFFER);
94 WINE_D3DCOMPILER_TO_STR(D3D_SVT_BYTEADDRESS_BUFFER);
95 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWBYTEADDRESS_BUFFER);
96 WINE_D3DCOMPILER_TO_STR(D3D_SVT_STRUCTURED_BUFFER);
97 WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWSTRUCTURED_BUFFER);
98 WINE_D3DCOMPILER_TO_STR(D3D_SVT_APPEND_STRUCTURED_BUFFER);
99 WINE_D3DCOMPILER_TO_STR(D3D_SVT_CONSUME_STRUCTURED_BUFFER);
100 default:
101 FIXME("Unrecognized D3D_SHADER_VARIABLE_TYPE %#x.\n", t);
102 return "unrecognized";
103 }
104 }
105
106 const char *debug_d3dcompiler_d3d_blob_part(D3D_BLOB_PART part)
107 {
108 switch(part)
109 {
110 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_INPUT_SIGNATURE_BLOB);
111 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_OUTPUT_SIGNATURE_BLOB);
112 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_INPUT_AND_OUTPUT_SIGNATURE_BLOB);
113 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_PATCH_CONSTANT_SIGNATURE_BLOB);
114 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_ALL_SIGNATURE_BLOB);
115 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_DEBUG_INFO);
116 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_LEGACY_SHADER);
117 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_XNA_PREPASS_SHADER);
118 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_XNA_SHADER);
119 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_PDB);
120 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_PRIVATE_DATA);
121 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_ROOT_SIGNATURE);
122 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_DEBUG_NAME);
123
124 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_TEST_ALTERNATE_SHADER);
125 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_TEST_COMPILE_DETAILS);
126 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_TEST_COMPILE_PERF);
127 WINE_D3DCOMPILER_TO_STR(D3D_BLOB_TEST_COMPILE_REPORT);
128 default:
129 FIXME("Unrecognized D3D_BLOB_PART %#x\n", part);
130 return "unrecognized";
131 }
132 }
133
134 const char *debug_print_srcmod(uint32_t mod)
135 {
136 switch (mod)
137 {
138 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_NEG);
139 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_BIAS);
140 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_BIASNEG);
141 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_SIGN);
142 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_SIGNNEG);
143 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_COMP);
144 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_X2);
145 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_X2NEG);
146 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_DZ);
147 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_DW);
148 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_ABS);
149 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_ABSNEG);
150 WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_NOT);
151 default:
152 FIXME("Unrecognized source modifier %#x.\n", mod);
153 return "unrecognized_src_mod";
154 }
155 }
156
157 #undef WINE_D3DCOMPILER_TO_STR
158
159 const char *debug_print_dstmod(uint32_t mod)
160 {
161 switch (mod)
162 {
163 case 0:
164 return "";
165 case BWRITERSPDM_SATURATE:
166 return "_sat";
167 case BWRITERSPDM_PARTIALPRECISION:
168 return "_pp";
169 case BWRITERSPDM_MSAMPCENTROID:
170 return "_centroid";
171 case BWRITERSPDM_SATURATE | BWRITERSPDM_PARTIALPRECISION:
172 return "_sat_pp";
173 case BWRITERSPDM_SATURATE | BWRITERSPDM_MSAMPCENTROID:
174 return "_sat_centroid";
175 case BWRITERSPDM_PARTIALPRECISION | BWRITERSPDM_MSAMPCENTROID:
176 return "_pp_centroid";
177 case BWRITERSPDM_SATURATE | BWRITERSPDM_PARTIALPRECISION | BWRITERSPDM_MSAMPCENTROID:
178 return "_sat_pp_centroid";
179 default:
180 return "Unexpected modifier\n";
181 }
182 }
183
184 const char *debug_print_shift(uint32_t shift)
185 {
186 static const char * const shiftstrings[] =
187 {
188 "",
189 "_x2",
190 "_x4",
191 "_x8",
192 "_x16",
193 "_x32",
194 "",
195 "",
196 "",
197 "",
198 "",
199 "",
200 "_d16",
201 "_d8",
202 "_d4",
203 "_d2",
204 };
205 return shiftstrings[shift];
206 }
207
208 static const char *get_regname(const struct shader_reg *reg)
209 {
210 switch (reg->type)
211 {
212 case BWRITERSPR_TEMP:
213 return wine_dbg_sprintf("r%u", reg->regnum);
214 case BWRITERSPR_INPUT:
215 return wine_dbg_sprintf("v%u", reg->regnum);
216 case BWRITERSPR_CONST:
217 return wine_dbg_sprintf("c%u", reg->regnum);
218 case BWRITERSPR_ADDR:
219 return wine_dbg_sprintf("a%u", reg->regnum);
220 case BWRITERSPR_TEXTURE:
221 return wine_dbg_sprintf("t%u", reg->regnum);
222 case BWRITERSPR_RASTOUT:
223 switch (reg->regnum)
224 {
225 case BWRITERSRO_POSITION: return "oPos";
226 case BWRITERSRO_FOG: return "oFog";
227 case BWRITERSRO_POINT_SIZE: return "oPts";
228 default: return "Unexpected RASTOUT";
229 }
230 case BWRITERSPR_ATTROUT:
231 return wine_dbg_sprintf("oD%u", reg->regnum);
232 case BWRITERSPR_TEXCRDOUT:
233 return wine_dbg_sprintf("oT%u", reg->regnum);
234 case BWRITERSPR_OUTPUT:
235 return wine_dbg_sprintf("o%u", reg->regnum);
236 case BWRITERSPR_CONSTINT:
237 return wine_dbg_sprintf("i%u", reg->regnum);
238 case BWRITERSPR_COLOROUT:
239 return wine_dbg_sprintf("oC%u", reg->regnum);
240 case BWRITERSPR_DEPTHOUT:
241 return "oDepth";
242 case BWRITERSPR_SAMPLER:
243 return wine_dbg_sprintf("s%u", reg->regnum);
244 case BWRITERSPR_CONSTBOOL:
245 return wine_dbg_sprintf("b%u", reg->regnum);
246 case BWRITERSPR_LOOP:
247 return "aL";
248 case BWRITERSPR_MISCTYPE:
249 switch (reg->regnum)
250 {
251 case 0: return "vPos";
252 case 1: return "vFace";
253 default: return "unexpected misctype";
254 }
255 case BWRITERSPR_LABEL:
256 return wine_dbg_sprintf("l%u", reg->regnum);
257 case BWRITERSPR_PREDICATE:
258 return wine_dbg_sprintf("p%u", reg->regnum);
259 default:
260 return wine_dbg_sprintf("unknown regname %#x", reg->type);
261 }
262 }
263
264 static const char *debug_print_writemask(uint32_t mask)
265 {
266 char ret[6];
267 unsigned char pos = 1;
268
269 if(mask == BWRITERSP_WRITEMASK_ALL) return "";
270 ret[0] = '.';
271 if(mask & BWRITERSP_WRITEMASK_0) ret[pos++] = 'x';
272 if(mask & BWRITERSP_WRITEMASK_1) ret[pos++] = 'y';
273 if(mask & BWRITERSP_WRITEMASK_2) ret[pos++] = 'z';
274 if(mask & BWRITERSP_WRITEMASK_3) ret[pos++] = 'w';
275 ret[pos] = 0;
276
277 return wine_dbg_sprintf("%s", ret);
278 }
279
280 static const char *debug_print_swizzle(uint32_t arg)
281 {
282 char ret[6];
283 unsigned int i;
284 uint32_t swizzle[4];
285
286 switch (arg)
287 {
288 case BWRITERVS_NOSWIZZLE:
289 return "";
290 case BWRITERVS_SWIZZLE_X:
291 return ".x";
292 case BWRITERVS_SWIZZLE_Y:
293 return ".y";
294 case BWRITERVS_SWIZZLE_Z:
295 return ".z";
296 case BWRITERVS_SWIZZLE_W:
297 return ".w";
298 }
299
300 swizzle[0] = arg & 3;
301 swizzle[1] = (arg >> 2) & 3;
302 swizzle[2] = (arg >> 4) & 3;
303 swizzle[3] = (arg >> 6) & 3;
304
305 ret[0] = '.';
306 for (i = 0; i < 4; ++i)
307 {
308 switch (swizzle[i])
309 {
310 case 0: ret[1 + i] = 'x'; break;
311 case 1: ret[1 + i] = 'y'; break;
312 case 2: ret[1 + i] = 'z'; break;
313 case 3: ret[1 + i] = 'w'; break;
314 }
315 }
316 ret[5] = '\0';
317
318 return wine_dbg_sprintf("%s", ret);
319 }
320
321 static const char *debug_print_relarg(const struct shader_reg *reg)
322 {
323 const char *short_swizzle;
324 if (!reg->rel_reg) return "";
325
326 short_swizzle = debug_print_swizzle(reg->rel_reg->swizzle);
327
328 if (reg->rel_reg->type == BWRITERSPR_ADDR)
329 return wine_dbg_sprintf("[a%u%s]", reg->rel_reg->regnum, short_swizzle);
330 else if(reg->rel_reg->type == BWRITERSPR_LOOP && reg->rel_reg->regnum == 0)
331 return wine_dbg_sprintf("[aL%s]", short_swizzle);
332 else
333 return "Unexpected relative addressing argument";
334 }
335
336 const char *debug_print_dstreg(const struct shader_reg *reg)
337 {
338 return wine_dbg_sprintf("%s%s%s", get_regname(reg),
339 debug_print_relarg(reg),
340 debug_print_writemask(reg->writemask));
341 }
342
343 const char *debug_print_srcreg(const struct shader_reg *reg)
344 {
345 switch (reg->srcmod)
346 {
347 case BWRITERSPSM_NONE:
348 return wine_dbg_sprintf("%s%s%s", get_regname(reg),
349 debug_print_relarg(reg),
350 debug_print_swizzle(reg->swizzle));
351 case BWRITERSPSM_NEG:
352 return wine_dbg_sprintf("-%s%s%s", get_regname(reg),
353 debug_print_relarg(reg),
354 debug_print_swizzle(reg->swizzle));
355 case BWRITERSPSM_BIAS:
356 return wine_dbg_sprintf("%s%s_bias%s", get_regname(reg),
357 debug_print_relarg(reg),
358 debug_print_swizzle(reg->swizzle));
359 case BWRITERSPSM_BIASNEG:
360 return wine_dbg_sprintf("-%s%s_bias%s", get_regname(reg),
361 debug_print_relarg(reg),
362 debug_print_swizzle(reg->swizzle));
363 case BWRITERSPSM_SIGN:
364 return wine_dbg_sprintf("%s%s_bx2%s", get_regname(reg),
365 debug_print_relarg(reg),
366 debug_print_swizzle(reg->swizzle));
367 case BWRITERSPSM_SIGNNEG:
368 return wine_dbg_sprintf("-%s%s_bx2%s", get_regname(reg),
369 debug_print_relarg(reg),
370 debug_print_swizzle(reg->swizzle));
371 case BWRITERSPSM_COMP:
372 return wine_dbg_sprintf("1 - %s%s%s", get_regname(reg),
373 debug_print_relarg(reg),
374 debug_print_swizzle(reg->swizzle));
375 case BWRITERSPSM_X2:
376 return wine_dbg_sprintf("%s%s_x2%s", get_regname(reg),
377 debug_print_relarg(reg),
378 debug_print_swizzle(reg->swizzle));
379 case BWRITERSPSM_X2NEG:
380 return wine_dbg_sprintf("-%s%s_x2%s", get_regname(reg),
381 debug_print_relarg(reg),
382 debug_print_swizzle(reg->swizzle));
383 case BWRITERSPSM_DZ:
384 return wine_dbg_sprintf("%s%s_dz%s", get_regname(reg),
385 debug_print_relarg(reg),
386 debug_print_swizzle(reg->swizzle));
387 case BWRITERSPSM_DW:
388 return wine_dbg_sprintf("%s%s_dw%s", get_regname(reg),
389 debug_print_relarg(reg),
390 debug_print_swizzle(reg->swizzle));
391 case BWRITERSPSM_ABS:
392 return wine_dbg_sprintf("%s%s_abs%s", get_regname(reg),
393 debug_print_relarg(reg),
394 debug_print_swizzle(reg->swizzle));
395 case BWRITERSPSM_ABSNEG:
396 return wine_dbg_sprintf("-%s%s_abs%s", get_regname(reg),
397 debug_print_relarg(reg),
398 debug_print_swizzle(reg->swizzle));
399 case BWRITERSPSM_NOT:
400 return wine_dbg_sprintf("!%s%s%s", get_regname(reg),
401 debug_print_relarg(reg),
402 debug_print_swizzle(reg->swizzle));
403 }
404 return "Unknown modifier";
405 }
406
407 const char *debug_print_comp(uint32_t comp)
408 {
409 switch (comp)
410 {
411 case BWRITER_COMPARISON_NONE: return "";
412 case BWRITER_COMPARISON_GT: return "_gt";
413 case BWRITER_COMPARISON_EQ: return "_eq";
414 case BWRITER_COMPARISON_GE: return "_ge";
415 case BWRITER_COMPARISON_LT: return "_lt";
416 case BWRITER_COMPARISON_NE: return "_ne";
417 case BWRITER_COMPARISON_LE: return "_le";
418 default: return "_unknown";
419 }
420 }
421
422 const char *debug_print_opcode(uint32_t opcode)
423 {
424 switch (opcode)
425 {
426 case BWRITERSIO_NOP: return "nop";
427 case BWRITERSIO_MOV: return "mov";
428 case BWRITERSIO_ADD: return "add";
429 case BWRITERSIO_SUB: return "sub";
430 case BWRITERSIO_MAD: return "mad";
431 case BWRITERSIO_MUL: return "mul";
432 case BWRITERSIO_RCP: return "rcp";
433 case BWRITERSIO_RSQ: return "rsq";
434 case BWRITERSIO_DP3: return "dp3";
435 case BWRITERSIO_DP4: return "dp4";
436 case BWRITERSIO_MIN: return "min";
437 case BWRITERSIO_MAX: return "max";
438 case BWRITERSIO_SLT: return "slt";
439 case BWRITERSIO_SGE: return "sge";
440 case BWRITERSIO_EXP: return "exp";
441 case BWRITERSIO_LOG: return "log";
442 case BWRITERSIO_LIT: return "lit";
443 case BWRITERSIO_DST: return "dst";
444 case BWRITERSIO_LRP: return "lrp";
445 case BWRITERSIO_FRC: return "frc";
446 case BWRITERSIO_M4x4: return "m4x4";
447 case BWRITERSIO_M4x3: return "m4x3";
448 case BWRITERSIO_M3x4: return "m3x4";
449 case BWRITERSIO_M3x3: return "m3x3";
450 case BWRITERSIO_M3x2: return "m3x2";
451 case BWRITERSIO_CALL: return "call";
452 case BWRITERSIO_CALLNZ: return "callnz";
453 case BWRITERSIO_LOOP: return "loop";
454 case BWRITERSIO_RET: return "ret";
455 case BWRITERSIO_ENDLOOP: return "endloop";
456 case BWRITERSIO_LABEL: return "label";
457 case BWRITERSIO_DCL: return "dcl";
458 case BWRITERSIO_POW: return "pow";
459 case BWRITERSIO_CRS: return "crs";
460 case BWRITERSIO_SGN: return "sgn";
461 case BWRITERSIO_ABS: return "abs";
462 case BWRITERSIO_NRM: return "nrm";
463 case BWRITERSIO_SINCOS: return "sincos";
464 case BWRITERSIO_REP: return "rep";
465 case BWRITERSIO_ENDREP: return "endrep";
466 case BWRITERSIO_IF: return "if";
467 case BWRITERSIO_IFC: return "ifc";
468 case BWRITERSIO_ELSE: return "else";
469 case BWRITERSIO_ENDIF: return "endif";
470 case BWRITERSIO_BREAK: return "break";
471 case BWRITERSIO_BREAKC: return "breakc";
472 case BWRITERSIO_MOVA: return "mova";
473 case BWRITERSIO_DEFB: return "defb";
474 case BWRITERSIO_DEFI: return "defi";
475 case BWRITERSIO_TEXCOORD: return "texcoord";
476 case BWRITERSIO_TEXKILL: return "texkill";
477 case BWRITERSIO_TEX: return "tex";
478 case BWRITERSIO_TEXBEM: return "texbem";
479 case BWRITERSIO_TEXBEML: return "texbeml";
480 case BWRITERSIO_TEXREG2AR: return "texreg2ar";
481 case BWRITERSIO_TEXREG2GB: return "texreg2gb";
482 case BWRITERSIO_TEXM3x2PAD: return "texm3x2pad";
483 case BWRITERSIO_TEXM3x2TEX: return "texm3x2tex";
484 case BWRITERSIO_TEXM3x3PAD: return "texm3x3pad";
485 case BWRITERSIO_TEXM3x3TEX: return "texm3x3tex";
486 case BWRITERSIO_TEXM3x3SPEC: return "texm3x3vspec";
487 case BWRITERSIO_TEXM3x3VSPEC: return "texm3x3vspec";
488 case BWRITERSIO_EXPP: return "expp";
489 case BWRITERSIO_LOGP: return "logp";
490 case BWRITERSIO_CND: return "cnd";
491 case BWRITERSIO_DEF: return "def";
492 case BWRITERSIO_TEXREG2RGB: return "texreg2rgb";
493 case BWRITERSIO_TEXDP3TEX: return "texdp3tex";
494 case BWRITERSIO_TEXM3x2DEPTH: return "texm3x2depth";
495 case BWRITERSIO_TEXDP3: return "texdp3";
496 case BWRITERSIO_TEXM3x3: return "texm3x3";
497 case BWRITERSIO_TEXDEPTH: return "texdepth";
498 case BWRITERSIO_CMP: return "cmp";
499 case BWRITERSIO_BEM: return "bem";
500 case BWRITERSIO_DP2ADD: return "dp2add";
501 case BWRITERSIO_DSX: return "dsx";
502 case BWRITERSIO_DSY: return "dsy";
503 case BWRITERSIO_TEXLDD: return "texldd";
504 case BWRITERSIO_SETP: return "setp";
505 case BWRITERSIO_TEXLDL: return "texldl";
506 case BWRITERSIO_BREAKP: return "breakp";
507 case BWRITERSIO_PHASE: return "phase";
508
509 case BWRITERSIO_TEXLDP: return "texldp";
510 case BWRITERSIO_TEXLDB: return "texldb";
511
512 default: return "unknown";
513 }
514 }
515
516 void skip_u32_unknown(const char **ptr, unsigned int count)
517 {
518 unsigned int i;
519 uint32_t u32;
520
521 FIXME("Skipping %u unknown u32s:\n", count);
522 for (i = 0; i < count; ++i)
523 {
524 u32 = read_u32(ptr);
525 FIXME("\t0x%08x\n", u32);
526 }
527 }
528
529 void compilation_message(struct compilation_messages *msg, const char *fmt, va_list args)
530 {
531 char* buffer;
532 int rc, size;
533
534 if (msg->capacity == 0)
535 {
536 msg->string = calloc(1, MESSAGEBUFFER_INITIAL_SIZE);
537 if (msg->string == NULL)
538 {
539 ERR("Error allocating memory for parser messages\n");
540 return;
541 }
542 msg->capacity = MESSAGEBUFFER_INITIAL_SIZE;
543 }
544
545 while (1)
546 {
547 rc = vsnprintf(msg->string + msg->size,
548 msg->capacity - msg->size, fmt, args);
549
550 if (rc < 0 || rc >= msg->capacity - msg->size)
551 {
552 size = msg->capacity * 2;
553 buffer = realloc(msg->string, size);
554 if (buffer == NULL)
555 {
556 ERR("Error reallocating memory for parser messages\n");
557 return;
558 }
559 msg->string = buffer;
560 msg->capacity = size;
561 }
562 else
563 {
564 TRACE("%s", msg->string + msg->size);
565 msg->size += rc;
566 return;
567 }
568 }
569 }
Windows API implementation