Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
5564 | serge | 1 | /************************************************************************** |
2 | * |
||
3 | * Copyright 2008-2010 VMware, Inc. |
||
4 | * All Rights Reserved. |
||
5 | * |
||
6 | * Permission is hereby granted, free of charge, to any person obtaining a |
||
7 | * copy of this software and associated documentation files (the |
||
8 | * "Software"), to deal in the Software without restriction, including |
||
9 | * without limitation the rights to use, copy, modify, merge, publish, |
||
10 | * distribute, sub license, and/or sell copies of the Software, and to |
||
11 | * permit persons to whom the Software is furnished to do so, subject to |
||
12 | * the following conditions: |
||
13 | * |
||
14 | * The above copyright notice and this permission notice (including the |
||
15 | * next paragraph) shall be included in all copies or substantial portions |
||
16 | * of the Software. |
||
17 | * |
||
18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
||
19 | * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
||
20 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. |
||
21 | * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR |
||
22 | * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, |
||
23 | * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE |
||
24 | * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
||
25 | * |
||
26 | **************************************************************************/ |
||
27 | |||
28 | |||
29 | #include "pipe/p_compiler.h" |
||
30 | #include "util/u_memory.h" |
||
31 | #include "util/u_string.h" |
||
32 | #include "util/u_format.h" |
||
33 | #include "tgsi/tgsi_dump.h" |
||
34 | |||
35 | #include "u_dump.h" |
||
36 | |||
37 | |||
38 | /* |
||
39 | * Dump primitives |
||
40 | */ |
||
41 | |||
42 | static INLINE void |
||
43 | util_stream_writef(FILE *stream, const char *format, ...) |
||
44 | { |
||
45 | static char buf[1024]; |
||
46 | unsigned len; |
||
47 | va_list ap; |
||
48 | va_start(ap, format); |
||
49 | len = util_vsnprintf(buf, sizeof(buf), format, ap); |
||
50 | va_end(ap); |
||
51 | fwrite(buf, len, 1, stream); |
||
52 | } |
||
53 | |||
54 | static void |
||
55 | util_dump_bool(FILE *stream, int value) |
||
56 | { |
||
57 | util_stream_writef(stream, "%c", value ? '1' : '0'); |
||
58 | } |
||
59 | |||
60 | static void |
||
61 | util_dump_int(FILE *stream, long long int value) |
||
62 | { |
||
63 | util_stream_writef(stream, "%lli", value); |
||
64 | } |
||
65 | |||
66 | static void |
||
67 | util_dump_uint(FILE *stream, long long unsigned value) |
||
68 | { |
||
69 | util_stream_writef(stream, "%llu", value); |
||
70 | } |
||
71 | |||
72 | static void |
||
73 | util_dump_float(FILE *stream, double value) |
||
74 | { |
||
75 | util_stream_writef(stream, "%g", value); |
||
76 | } |
||
77 | |||
78 | static void |
||
79 | util_dump_string(FILE *stream, const char *str) |
||
80 | { |
||
81 | fputs("\"", stream); |
||
82 | fputs(str, stream); |
||
83 | fputs("\"", stream); |
||
84 | } |
||
85 | |||
86 | static void |
||
87 | util_dump_enum(FILE *stream, const char *value) |
||
88 | { |
||
89 | fputs(value, stream); |
||
90 | } |
||
91 | |||
92 | static void |
||
93 | util_dump_array_begin(FILE *stream) |
||
94 | { |
||
95 | fputs("{", stream); |
||
96 | } |
||
97 | |||
98 | static void |
||
99 | util_dump_array_end(FILE *stream) |
||
100 | { |
||
101 | fputs("}", stream); |
||
102 | } |
||
103 | |||
104 | static void |
||
105 | util_dump_elem_begin(FILE *stream) |
||
106 | { |
||
107 | } |
||
108 | |||
109 | static void |
||
110 | util_dump_elem_end(FILE *stream) |
||
111 | { |
||
112 | fputs(", ", stream); |
||
113 | } |
||
114 | |||
115 | static void |
||
116 | util_dump_struct_begin(FILE *stream, const char *name) |
||
117 | { |
||
118 | fputs("{", stream); |
||
119 | } |
||
120 | |||
121 | static void |
||
122 | util_dump_struct_end(FILE *stream) |
||
123 | { |
||
124 | fputs("}", stream); |
||
125 | } |
||
126 | |||
127 | static void |
||
128 | util_dump_member_begin(FILE *stream, const char *name) |
||
129 | { |
||
130 | util_stream_writef(stream, "%s = ", name); |
||
131 | } |
||
132 | |||
133 | static void |
||
134 | util_dump_member_end(FILE *stream) |
||
135 | { |
||
136 | fputs(", ", stream); |
||
137 | } |
||
138 | |||
139 | static void |
||
140 | util_dump_null(FILE *stream) |
||
141 | { |
||
142 | fputs("NULL", stream); |
||
143 | } |
||
144 | |||
145 | static void |
||
146 | util_dump_ptr(FILE *stream, const void *value) |
||
147 | { |
||
148 | if(value) |
||
149 | util_stream_writef(stream, "0x%08lx", (unsigned long)(uintptr_t)value); |
||
150 | else |
||
151 | util_dump_null(stream); |
||
152 | } |
||
153 | |||
154 | |||
155 | /* |
||
156 | * Code saving macros. |
||
157 | */ |
||
158 | |||
159 | #define util_dump_arg(_stream, _type, _arg) \ |
||
160 | do { \ |
||
161 | util_dump_arg_begin(_stream, #_arg); \ |
||
162 | util_dump_##_type(_stream, _arg); \ |
||
163 | util_dump_arg_end(_stream); \ |
||
164 | } while(0) |
||
165 | |||
166 | #define util_dump_ret(_stream, _type, _arg) \ |
||
167 | do { \ |
||
168 | util_dump_ret_begin(_stream); \ |
||
169 | util_dump_##_type(_stream, _arg); \ |
||
170 | util_dump_ret_end(_stream); \ |
||
171 | } while(0) |
||
172 | |||
173 | #define util_dump_array(_stream, _type, _obj, _size) \ |
||
174 | do { \ |
||
175 | size_t idx; \ |
||
176 | util_dump_array_begin(_stream); \ |
||
177 | for(idx = 0; idx < (_size); ++idx) { \ |
||
178 | util_dump_elem_begin(_stream); \ |
||
179 | util_dump_##_type(_stream, (_obj)[idx]); \ |
||
180 | util_dump_elem_end(_stream); \ |
||
181 | } \ |
||
182 | util_dump_array_end(_stream); \ |
||
183 | } while(0) |
||
184 | |||
185 | #define util_dump_struct_array(_stream, _type, _obj, _size) \ |
||
186 | do { \ |
||
187 | size_t idx; \ |
||
188 | util_dump_array_begin(_stream); \ |
||
189 | for(idx = 0; idx < (_size); ++idx) { \ |
||
190 | util_dump_elem_begin(_stream); \ |
||
191 | util_dump_##_type(_stream, &(_obj)[idx]); \ |
||
192 | util_dump_elem_end(_stream); \ |
||
193 | } \ |
||
194 | util_dump_array_end(_stream); \ |
||
195 | } while(0) |
||
196 | |||
197 | #define util_dump_member(_stream, _type, _obj, _member) \ |
||
198 | do { \ |
||
199 | util_dump_member_begin(_stream, #_member); \ |
||
200 | util_dump_##_type(_stream, (_obj)->_member); \ |
||
201 | util_dump_member_end(_stream); \ |
||
202 | } while(0) |
||
203 | |||
204 | #define util_dump_arg_array(_stream, _type, _arg, _size) \ |
||
205 | do { \ |
||
206 | util_dump_arg_begin(_stream, #_arg); \ |
||
207 | util_dump_array(_stream, _type, _arg, _size); \ |
||
208 | util_dump_arg_end(_stream); \ |
||
209 | } while(0) |
||
210 | |||
211 | #define util_dump_member_array(_stream, _type, _obj, _member) \ |
||
212 | do { \ |
||
213 | util_dump_member_begin(_stream, #_member); \ |
||
214 | util_dump_array(_stream, _type, (_obj)->_member, sizeof((_obj)->_member)/sizeof((_obj)->_member[0])); \ |
||
215 | util_dump_member_end(_stream); \ |
||
216 | } while(0) |
||
217 | |||
218 | |||
219 | |||
220 | /* |
||
221 | * Wrappers for enum -> string dumpers. |
||
222 | */ |
||
223 | |||
224 | |||
225 | static void |
||
226 | util_dump_format(FILE *stream, enum pipe_format format) |
||
227 | { |
||
228 | util_dump_enum(stream, util_format_name(format)); |
||
229 | } |
||
230 | |||
231 | |||
232 | static void |
||
233 | util_dump_enum_blend_factor(FILE *stream, unsigned value) |
||
234 | { |
||
235 | util_dump_enum(stream, util_dump_blend_factor(value, TRUE)); |
||
236 | } |
||
237 | |||
238 | static void |
||
239 | util_dump_enum_blend_func(FILE *stream, unsigned value) |
||
240 | { |
||
241 | util_dump_enum(stream, util_dump_blend_func(value, TRUE)); |
||
242 | } |
||
243 | |||
244 | static void |
||
245 | util_dump_enum_func(FILE *stream, unsigned value) |
||
246 | { |
||
247 | util_dump_enum(stream, util_dump_func(value, TRUE)); |
||
248 | } |
||
249 | |||
250 | |||
251 | /* |
||
252 | * Public functions |
||
253 | */ |
||
254 | |||
255 | |||
256 | void |
||
257 | util_dump_template(FILE *stream, const struct pipe_resource *templat) |
||
258 | { |
||
259 | if(!templat) { |
||
260 | util_dump_null(stream); |
||
261 | return; |
||
262 | } |
||
263 | |||
264 | util_dump_struct_begin(stream, "pipe_resource"); |
||
265 | |||
266 | util_dump_member(stream, int, templat, target); |
||
267 | util_dump_member(stream, format, templat, format); |
||
268 | |||
269 | util_dump_member_begin(stream, "width"); |
||
270 | util_dump_uint(stream, templat->width0); |
||
271 | util_dump_member_end(stream); |
||
272 | |||
273 | util_dump_member_begin(stream, "height"); |
||
274 | util_dump_uint(stream, templat->height0); |
||
275 | util_dump_member_end(stream); |
||
276 | |||
277 | util_dump_member_begin(stream, "depth"); |
||
278 | util_dump_uint(stream, templat->depth0); |
||
279 | util_dump_member_end(stream); |
||
280 | |||
281 | util_dump_member_begin(stream, "array_size"); |
||
282 | util_dump_uint(stream, templat->array_size); |
||
283 | util_dump_member_end(stream); |
||
284 | |||
285 | util_dump_member(stream, uint, templat, last_level); |
||
286 | util_dump_member(stream, uint, templat, usage); |
||
287 | util_dump_member(stream, uint, templat, bind); |
||
288 | util_dump_member(stream, uint, templat, flags); |
||
289 | |||
290 | util_dump_struct_end(stream); |
||
291 | } |
||
292 | |||
293 | |||
294 | void |
||
295 | util_dump_rasterizer_state(FILE *stream, const struct pipe_rasterizer_state *state) |
||
296 | { |
||
297 | if(!state) { |
||
298 | util_dump_null(stream); |
||
299 | return; |
||
300 | } |
||
301 | |||
302 | util_dump_struct_begin(stream, "pipe_rasterizer_state"); |
||
303 | |||
304 | util_dump_member(stream, bool, state, flatshade); |
||
305 | util_dump_member(stream, bool, state, light_twoside); |
||
306 | util_dump_member(stream, bool, state, clamp_vertex_color); |
||
307 | util_dump_member(stream, bool, state, clamp_fragment_color); |
||
308 | util_dump_member(stream, uint, state, front_ccw); |
||
309 | util_dump_member(stream, uint, state, cull_face); |
||
310 | util_dump_member(stream, uint, state, fill_front); |
||
311 | util_dump_member(stream, uint, state, fill_back); |
||
312 | util_dump_member(stream, bool, state, offset_point); |
||
313 | util_dump_member(stream, bool, state, offset_line); |
||
314 | util_dump_member(stream, bool, state, offset_tri); |
||
315 | util_dump_member(stream, bool, state, scissor); |
||
316 | util_dump_member(stream, bool, state, poly_smooth); |
||
317 | util_dump_member(stream, bool, state, poly_stipple_enable); |
||
318 | util_dump_member(stream, bool, state, point_smooth); |
||
319 | util_dump_member(stream, uint, state, sprite_coord_enable); |
||
320 | util_dump_member(stream, bool, state, sprite_coord_mode); |
||
321 | util_dump_member(stream, bool, state, point_quad_rasterization); |
||
322 | util_dump_member(stream, bool, state, point_size_per_vertex); |
||
323 | util_dump_member(stream, bool, state, multisample); |
||
324 | util_dump_member(stream, bool, state, line_smooth); |
||
325 | util_dump_member(stream, bool, state, line_stipple_enable); |
||
326 | util_dump_member(stream, uint, state, line_stipple_factor); |
||
327 | util_dump_member(stream, uint, state, line_stipple_pattern); |
||
328 | util_dump_member(stream, bool, state, line_last_pixel); |
||
329 | util_dump_member(stream, bool, state, flatshade_first); |
||
330 | util_dump_member(stream, bool, state, half_pixel_center); |
||
331 | util_dump_member(stream, bool, state, bottom_edge_rule); |
||
332 | util_dump_member(stream, bool, state, rasterizer_discard); |
||
333 | util_dump_member(stream, bool, state, depth_clip); |
||
334 | util_dump_member(stream, uint, state, clip_plane_enable); |
||
335 | |||
336 | util_dump_member(stream, float, state, line_width); |
||
337 | util_dump_member(stream, float, state, point_size); |
||
338 | util_dump_member(stream, float, state, offset_units); |
||
339 | util_dump_member(stream, float, state, offset_scale); |
||
340 | util_dump_member(stream, float, state, offset_clamp); |
||
341 | |||
342 | util_dump_struct_end(stream); |
||
343 | } |
||
344 | |||
345 | |||
346 | void |
||
347 | util_dump_poly_stipple(FILE *stream, const struct pipe_poly_stipple *state) |
||
348 | { |
||
349 | if(!state) { |
||
350 | util_dump_null(stream); |
||
351 | return; |
||
352 | } |
||
353 | |||
354 | util_dump_struct_begin(stream, "pipe_poly_stipple"); |
||
355 | |||
356 | util_dump_member_begin(stream, "stipple"); |
||
357 | util_dump_member_array(stream, uint, state, stipple); |
||
358 | util_dump_member_end(stream); |
||
359 | |||
360 | util_dump_struct_end(stream); |
||
361 | } |
||
362 | |||
363 | |||
364 | void |
||
365 | util_dump_viewport_state(FILE *stream, const struct pipe_viewport_state *state) |
||
366 | { |
||
367 | if(!state) { |
||
368 | util_dump_null(stream); |
||
369 | return; |
||
370 | } |
||
371 | |||
372 | util_dump_struct_begin(stream, "pipe_viewport_state"); |
||
373 | |||
374 | util_dump_member_array(stream, float, state, scale); |
||
375 | util_dump_member_array(stream, float, state, translate); |
||
376 | |||
377 | util_dump_struct_end(stream); |
||
378 | } |
||
379 | |||
380 | |||
381 | void |
||
382 | util_dump_scissor_state(FILE *stream, const struct pipe_scissor_state *state) |
||
383 | { |
||
384 | if(!state) { |
||
385 | util_dump_null(stream); |
||
386 | return; |
||
387 | } |
||
388 | |||
389 | util_dump_struct_begin(stream, "pipe_scissor_state"); |
||
390 | |||
391 | util_dump_member(stream, uint, state, minx); |
||
392 | util_dump_member(stream, uint, state, miny); |
||
393 | util_dump_member(stream, uint, state, maxx); |
||
394 | util_dump_member(stream, uint, state, maxy); |
||
395 | |||
396 | util_dump_struct_end(stream); |
||
397 | } |
||
398 | |||
399 | |||
400 | void |
||
401 | util_dump_clip_state(FILE *stream, const struct pipe_clip_state *state) |
||
402 | { |
||
403 | unsigned i; |
||
404 | |||
405 | if(!state) { |
||
406 | util_dump_null(stream); |
||
407 | return; |
||
408 | } |
||
409 | |||
410 | util_dump_struct_begin(stream, "pipe_clip_state"); |
||
411 | |||
412 | util_dump_member_begin(stream, "ucp"); |
||
413 | util_dump_array_begin(stream); |
||
414 | for(i = 0; i < PIPE_MAX_CLIP_PLANES; ++i) { |
||
415 | util_dump_elem_begin(stream); |
||
416 | util_dump_array(stream, float, state->ucp[i], 4); |
||
417 | util_dump_elem_end(stream); |
||
418 | } |
||
419 | util_dump_array_end(stream); |
||
420 | util_dump_member_end(stream); |
||
421 | |||
422 | util_dump_struct_end(stream); |
||
423 | } |
||
424 | |||
425 | |||
426 | void |
||
427 | util_dump_shader_state(FILE *stream, const struct pipe_shader_state *state) |
||
428 | { |
||
429 | char str[8192]; |
||
430 | unsigned i; |
||
431 | |||
432 | if(!state) { |
||
433 | util_dump_null(stream); |
||
434 | return; |
||
435 | } |
||
436 | |||
437 | tgsi_dump_str(state->tokens, 0, str, sizeof(str)); |
||
438 | |||
439 | util_dump_struct_begin(stream, "pipe_shader_state"); |
||
440 | |||
441 | util_dump_member_begin(stream, "tokens"); |
||
442 | util_dump_string(stream, str); |
||
443 | util_dump_member_end(stream); |
||
444 | |||
445 | util_dump_member_begin(stream, "stream_output"); |
||
446 | util_dump_struct_begin(stream, "pipe_stream_output_info"); |
||
447 | util_dump_member(stream, uint, &state->stream_output, num_outputs); |
||
448 | util_dump_array(stream, uint, state->stream_output.stride, |
||
449 | Elements(state->stream_output.stride)); |
||
450 | util_dump_array_begin(stream); |
||
451 | for(i = 0; i < state->stream_output.num_outputs; ++i) { |
||
452 | util_dump_elem_begin(stream); |
||
453 | util_dump_struct_begin(stream, ""); /* anonymous */ |
||
454 | util_dump_member(stream, uint, &state->stream_output.output[i], register_index); |
||
455 | util_dump_member(stream, uint, &state->stream_output.output[i], start_component); |
||
456 | util_dump_member(stream, uint, &state->stream_output.output[i], num_components); |
||
457 | util_dump_member(stream, uint, &state->stream_output.output[i], output_buffer); |
||
458 | util_dump_struct_end(stream); |
||
459 | util_dump_elem_end(stream); |
||
460 | } |
||
461 | util_dump_array_end(stream); |
||
462 | util_dump_struct_end(stream); |
||
463 | util_dump_member_end(stream); |
||
464 | |||
465 | util_dump_struct_end(stream); |
||
466 | } |
||
467 | |||
468 | |||
469 | void |
||
470 | util_dump_depth_stencil_alpha_state(FILE *stream, const struct pipe_depth_stencil_alpha_state *state) |
||
471 | { |
||
472 | unsigned i; |
||
473 | |||
474 | if(!state) { |
||
475 | util_dump_null(stream); |
||
476 | return; |
||
477 | } |
||
478 | |||
479 | util_dump_struct_begin(stream, "pipe_depth_stencil_alpha_state"); |
||
480 | |||
481 | util_dump_member_begin(stream, "depth"); |
||
482 | util_dump_struct_begin(stream, "pipe_depth_state"); |
||
483 | util_dump_member(stream, bool, &state->depth, enabled); |
||
484 | if (state->depth.enabled) { |
||
485 | util_dump_member(stream, bool, &state->depth, writemask); |
||
486 | util_dump_member(stream, enum_func, &state->depth, func); |
||
487 | } |
||
488 | util_dump_struct_end(stream); |
||
489 | util_dump_member_end(stream); |
||
490 | |||
491 | util_dump_member_begin(stream, "stencil"); |
||
492 | util_dump_array_begin(stream); |
||
493 | for(i = 0; i < Elements(state->stencil); ++i) { |
||
494 | util_dump_elem_begin(stream); |
||
495 | util_dump_struct_begin(stream, "pipe_stencil_state"); |
||
496 | util_dump_member(stream, bool, &state->stencil[i], enabled); |
||
497 | if (state->stencil[i].enabled) { |
||
498 | util_dump_member(stream, enum_func, &state->stencil[i], func); |
||
499 | util_dump_member(stream, uint, &state->stencil[i], fail_op); |
||
500 | util_dump_member(stream, uint, &state->stencil[i], zpass_op); |
||
501 | util_dump_member(stream, uint, &state->stencil[i], zfail_op); |
||
502 | util_dump_member(stream, uint, &state->stencil[i], valuemask); |
||
503 | util_dump_member(stream, uint, &state->stencil[i], writemask); |
||
504 | } |
||
505 | util_dump_struct_end(stream); |
||
506 | util_dump_elem_end(stream); |
||
507 | } |
||
508 | util_dump_array_end(stream); |
||
509 | util_dump_member_end(stream); |
||
510 | |||
511 | util_dump_member_begin(stream, "alpha"); |
||
512 | util_dump_struct_begin(stream, "pipe_alpha_state"); |
||
513 | util_dump_member(stream, bool, &state->alpha, enabled); |
||
514 | if (state->alpha.enabled) { |
||
515 | util_dump_member(stream, enum_func, &state->alpha, func); |
||
516 | util_dump_member(stream, float, &state->alpha, ref_value); |
||
517 | } |
||
518 | util_dump_struct_end(stream); |
||
519 | util_dump_member_end(stream); |
||
520 | |||
521 | util_dump_struct_end(stream); |
||
522 | } |
||
523 | |||
524 | void |
||
525 | util_dump_rt_blend_state(FILE *stream, const struct pipe_rt_blend_state *state) |
||
526 | { |
||
527 | util_dump_struct_begin(stream, "pipe_rt_blend_state"); |
||
528 | |||
529 | util_dump_member(stream, uint, state, blend_enable); |
||
530 | if (state->blend_enable) { |
||
531 | util_dump_member(stream, enum_blend_func, state, rgb_func); |
||
532 | util_dump_member(stream, enum_blend_factor, state, rgb_src_factor); |
||
533 | util_dump_member(stream, enum_blend_factor, state, rgb_dst_factor); |
||
534 | |||
535 | util_dump_member(stream, enum_blend_func, state, alpha_func); |
||
536 | util_dump_member(stream, enum_blend_factor, state, alpha_src_factor); |
||
537 | util_dump_member(stream, enum_blend_factor, state, alpha_dst_factor); |
||
538 | } |
||
539 | |||
540 | util_dump_member(stream, uint, state, colormask); |
||
541 | |||
542 | util_dump_struct_end(stream); |
||
543 | } |
||
544 | |||
545 | void |
||
546 | util_dump_blend_state(FILE *stream, const struct pipe_blend_state *state) |
||
547 | { |
||
548 | unsigned valid_entries = 1; |
||
549 | |||
550 | if(!state) { |
||
551 | util_dump_null(stream); |
||
552 | return; |
||
553 | } |
||
554 | |||
555 | util_dump_struct_begin(stream, "pipe_blend_state"); |
||
556 | |||
557 | util_dump_member(stream, bool, state, dither); |
||
558 | |||
559 | util_dump_member(stream, bool, state, logicop_enable); |
||
560 | if (state->logicop_enable) { |
||
561 | util_dump_member(stream, enum_func, state, logicop_func); |
||
562 | } |
||
563 | else { |
||
564 | util_dump_member(stream, bool, state, independent_blend_enable); |
||
565 | |||
566 | util_dump_member_begin(stream, "rt"); |
||
567 | if (state->independent_blend_enable) |
||
568 | valid_entries = PIPE_MAX_COLOR_BUFS; |
||
569 | util_dump_struct_array(stream, rt_blend_state, state->rt, valid_entries); |
||
570 | util_dump_member_end(stream); |
||
571 | } |
||
572 | |||
573 | util_dump_struct_end(stream); |
||
574 | } |
||
575 | |||
576 | |||
577 | void |
||
578 | util_dump_blend_color(FILE *stream, const struct pipe_blend_color *state) |
||
579 | { |
||
580 | if(!state) { |
||
581 | util_dump_null(stream); |
||
582 | return; |
||
583 | } |
||
584 | |||
585 | util_dump_struct_begin(stream, "pipe_blend_color"); |
||
586 | |||
587 | util_dump_member_array(stream, float, state, color); |
||
588 | |||
589 | util_dump_struct_end(stream); |
||
590 | } |
||
591 | |||
592 | void |
||
593 | util_dump_stencil_ref(FILE *stream, const struct pipe_stencil_ref *state) |
||
594 | { |
||
595 | if(!state) { |
||
596 | util_dump_null(stream); |
||
597 | return; |
||
598 | } |
||
599 | |||
600 | util_dump_struct_begin(stream, "pipe_stencil_ref"); |
||
601 | |||
602 | util_dump_member_array(stream, uint, state, ref_value); |
||
603 | |||
604 | util_dump_struct_end(stream); |
||
605 | } |
||
606 | |||
607 | void |
||
608 | util_dump_framebuffer_state(FILE *stream, const struct pipe_framebuffer_state *state) |
||
609 | { |
||
610 | util_dump_struct_begin(stream, "pipe_framebuffer_state"); |
||
611 | |||
612 | util_dump_member(stream, uint, state, width); |
||
613 | util_dump_member(stream, uint, state, height); |
||
614 | util_dump_member(stream, uint, state, nr_cbufs); |
||
615 | util_dump_member_array(stream, ptr, state, cbufs); |
||
616 | util_dump_member(stream, ptr, state, zsbuf); |
||
617 | |||
618 | util_dump_struct_end(stream); |
||
619 | } |
||
620 | |||
621 | |||
622 | void |
||
623 | util_dump_sampler_state(FILE *stream, const struct pipe_sampler_state *state) |
||
624 | { |
||
625 | if(!state) { |
||
626 | util_dump_null(stream); |
||
627 | return; |
||
628 | } |
||
629 | |||
630 | util_dump_struct_begin(stream, "pipe_sampler_state"); |
||
631 | |||
632 | util_dump_member(stream, uint, state, wrap_s); |
||
633 | util_dump_member(stream, uint, state, wrap_t); |
||
634 | util_dump_member(stream, uint, state, wrap_r); |
||
635 | util_dump_member(stream, uint, state, min_img_filter); |
||
636 | util_dump_member(stream, uint, state, min_mip_filter); |
||
637 | util_dump_member(stream, uint, state, mag_img_filter); |
||
638 | util_dump_member(stream, uint, state, compare_mode); |
||
639 | util_dump_member(stream, enum_func, state, compare_func); |
||
640 | util_dump_member(stream, bool, state, normalized_coords); |
||
641 | util_dump_member(stream, uint, state, max_anisotropy); |
||
642 | util_dump_member(stream, float, state, lod_bias); |
||
643 | util_dump_member(stream, float, state, min_lod); |
||
644 | util_dump_member(stream, float, state, max_lod); |
||
645 | util_dump_member_array(stream, float, state, border_color.f); |
||
646 | |||
647 | util_dump_struct_end(stream); |
||
648 | } |
||
649 | |||
650 | |||
651 | void |
||
652 | util_dump_surface(FILE *stream, const struct pipe_surface *state) |
||
653 | { |
||
654 | if(!state) { |
||
655 | util_dump_null(stream); |
||
656 | return; |
||
657 | } |
||
658 | |||
659 | util_dump_struct_begin(stream, "pipe_surface"); |
||
660 | |||
661 | util_dump_member(stream, format, state, format); |
||
662 | util_dump_member(stream, uint, state, width); |
||
663 | util_dump_member(stream, uint, state, height); |
||
664 | |||
665 | util_dump_member(stream, ptr, state, texture); |
||
666 | util_dump_member(stream, uint, state, u.tex.level); |
||
667 | util_dump_member(stream, uint, state, u.tex.first_layer); |
||
668 | util_dump_member(stream, uint, state, u.tex.last_layer); |
||
669 | |||
670 | util_dump_struct_end(stream); |
||
671 | } |
||
672 | |||
673 | |||
674 | void |
||
675 | util_dump_transfer(FILE *stream, const struct pipe_transfer *state) |
||
676 | { |
||
677 | if(!state) { |
||
678 | util_dump_null(stream); |
||
679 | return; |
||
680 | } |
||
681 | |||
682 | util_dump_struct_begin(stream, "pipe_transfer"); |
||
683 | |||
684 | util_dump_member(stream, ptr, state, resource); |
||
685 | util_dump_member(stream, uint, state, level); |
||
686 | util_dump_member(stream, uint, state, usage); |
||
687 | util_dump_member_begin(stream, "box"); |
||
688 | util_dump_box(stream, &state->box); |
||
689 | util_dump_member_end(stream); |
||
690 | util_dump_member(stream, uint, state, stride); |
||
691 | util_dump_member(stream, uint, state, layer_stride); |
||
692 | |||
693 | util_dump_struct_end(stream); |
||
694 | } |
||
695 | |||
696 | |||
697 | void |
||
698 | util_dump_vertex_buffer(FILE *stream, const struct pipe_vertex_buffer *state) |
||
699 | { |
||
700 | if(!state) { |
||
701 | util_dump_null(stream); |
||
702 | return; |
||
703 | } |
||
704 | |||
705 | util_dump_struct_begin(stream, "pipe_vertex_buffer"); |
||
706 | |||
707 | util_dump_member(stream, uint, state, stride); |
||
708 | util_dump_member(stream, uint, state, buffer_offset); |
||
709 | util_dump_member(stream, ptr, state, buffer); |
||
710 | |||
711 | util_dump_struct_end(stream); |
||
712 | } |
||
713 | |||
714 | |||
715 | void |
||
716 | util_dump_vertex_element(FILE *stream, const struct pipe_vertex_element *state) |
||
717 | { |
||
718 | if(!state) { |
||
719 | util_dump_null(stream); |
||
720 | return; |
||
721 | } |
||
722 | |||
723 | util_dump_struct_begin(stream, "pipe_vertex_element"); |
||
724 | |||
725 | util_dump_member(stream, uint, state, src_offset); |
||
726 | util_dump_member(stream, uint, state, instance_divisor); |
||
727 | util_dump_member(stream, uint, state, vertex_buffer_index); |
||
728 | util_dump_member(stream, format, state, src_format); |
||
729 | |||
730 | util_dump_struct_end(stream); |
||
731 | } |
||
732 | |||
733 | |||
734 | void |
||
735 | util_dump_draw_info(FILE *stream, const struct pipe_draw_info *state) |
||
736 | { |
||
737 | if(!state) { |
||
738 | util_dump_null(stream); |
||
739 | return; |
||
740 | } |
||
741 | |||
742 | util_dump_struct_begin(stream, "pipe_draw_info"); |
||
743 | |||
744 | util_dump_member(stream, bool, state, indexed); |
||
745 | |||
746 | util_dump_member(stream, uint, state, mode); |
||
747 | util_dump_member(stream, uint, state, start); |
||
748 | util_dump_member(stream, uint, state, count); |
||
749 | |||
750 | util_dump_member(stream, uint, state, start_instance); |
||
751 | util_dump_member(stream, uint, state, instance_count); |
||
752 | |||
753 | util_dump_member(stream, uint, state, vertices_per_patch); |
||
754 | |||
755 | util_dump_member(stream, int, state, index_bias); |
||
756 | util_dump_member(stream, uint, state, min_index); |
||
757 | util_dump_member(stream, uint, state, max_index); |
||
758 | |||
759 | util_dump_member(stream, bool, state, primitive_restart); |
||
760 | util_dump_member(stream, uint, state, restart_index); |
||
761 | |||
762 | util_dump_member(stream, ptr, state, count_from_stream_output); |
||
763 | |||
764 | util_dump_member(stream, ptr, state, indirect); |
||
765 | util_dump_member(stream, uint, state, indirect_offset); |
||
766 | |||
767 | util_dump_struct_end(stream); |
||
768 | } |
||
769 | |||
770 | void util_dump_box(FILE *stream, const struct pipe_box *box) |
||
771 | { |
||
772 | if(!box) { |
||
773 | util_dump_null(stream); |
||
774 | return; |
||
775 | } |
||
776 | |||
777 | util_dump_struct_begin(stream, "pipe_box"); |
||
778 | |||
779 | util_dump_member(stream, int, box, x); |
||
780 | util_dump_member(stream, int, box, y); |
||
781 | util_dump_member(stream, int, box, z); |
||
782 | util_dump_member(stream, int, box, width); |
||
783 | util_dump_member(stream, int, box, height); |
||
784 | util_dump_member(stream, int, box, depth); |
||
785 | |||
786 | util_dump_struct_end(stream); |
||
787 | } |
||
788 | |||
789 | void util_dump_blit_info(FILE *stream, const struct pipe_blit_info *info) |
||
790 | { |
||
791 | char mask[7]; |
||
792 | |||
793 | if (!info) { |
||
794 | util_dump_null(stream); |
||
795 | return; |
||
796 | } |
||
797 | |||
798 | util_dump_struct_begin(stream, "pipe_blit_info"); |
||
799 | |||
800 | util_dump_member_begin(stream, "dst"); |
||
801 | util_dump_struct_begin(stream, "dst"); |
||
802 | util_dump_member(stream, ptr, &info->dst, resource); |
||
803 | util_dump_member(stream, uint, &info->dst, level); |
||
804 | util_dump_member(stream, format, &info->dst, format); |
||
805 | util_dump_member_begin(stream, "box"); |
||
806 | util_dump_box(stream, &info->dst.box); |
||
807 | util_dump_member_end(stream); |
||
808 | util_dump_struct_end(stream); |
||
809 | util_dump_member_end(stream); |
||
810 | |||
811 | util_dump_member_begin(stream, "src"); |
||
812 | util_dump_struct_begin(stream, "src"); |
||
813 | util_dump_member(stream, ptr, &info->src, resource); |
||
814 | util_dump_member(stream, uint, &info->src, level); |
||
815 | util_dump_member(stream, format, &info->src, format); |
||
816 | util_dump_member_begin(stream, "box"); |
||
817 | util_dump_box(stream, &info->src.box); |
||
818 | util_dump_member_end(stream); |
||
819 | util_dump_struct_end(stream); |
||
820 | util_dump_member_end(stream); |
||
821 | |||
822 | mask[0] = (info->mask & PIPE_MASK_R) ? 'R' : '-'; |
||
823 | mask[1] = (info->mask & PIPE_MASK_G) ? 'G' : '-'; |
||
824 | mask[2] = (info->mask & PIPE_MASK_B) ? 'B' : '-'; |
||
825 | mask[3] = (info->mask & PIPE_MASK_A) ? 'A' : '-'; |
||
826 | mask[4] = (info->mask & PIPE_MASK_Z) ? 'Z' : '-'; |
||
827 | mask[5] = (info->mask & PIPE_MASK_S) ? 'S' : '-'; |
||
828 | mask[6] = 0; |
||
829 | |||
830 | util_dump_member_begin(stream, "mask"); |
||
831 | util_dump_string(stream, mask); |
||
832 | util_dump_member_end(stream); |
||
833 | util_dump_member(stream, uint, info, filter); |
||
834 | |||
835 | util_dump_member(stream, bool, info, scissor_enable); |
||
836 | util_dump_member_begin(stream, "scissor"); |
||
837 | util_dump_scissor_state(stream, &info->scissor); |
||
838 | util_dump_member_end(stream); |
||
839 | |||
840 | util_dump_struct_end(stream); |
||
841 | }>>>>> |