src/gallium/auxiliary/util/u_dump_state.c

   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 static void
 251 util_dump_enum_prim_mode(FILE *stream, unsigned value)
 252 {
 253    util_dump_enum(stream, util_dump_prim_mode(value, TRUE));
 254 }
 255
 256 static void
 257 util_dump_enum_tex_target(FILE *stream, unsigned value)
 258 {
 259    util_dump_enum(stream, util_dump_tex_target(value, TRUE));
 260 }
 261
 262 static void
 263 util_dump_enum_tex_filter(FILE *stream, unsigned value)
 264 {
 265    util_dump_enum(stream, util_dump_tex_filter(value, TRUE));
 266 }
 267
 268 static void
 269 util_dump_enum_tex_mipfilter(FILE *stream, unsigned value)
 270 {
 271    util_dump_enum(stream, util_dump_tex_mipfilter(value, TRUE));
 272 }
 273
 274 static void
 275 util_dump_enum_tex_wrap(FILE *stream, unsigned value)
 276 {
 277    util_dump_enum(stream, util_dump_tex_wrap(value, TRUE));
 278 }
 279
 280 static void
 281 util_dump_enum_stencil_op(FILE *stream, unsigned value)
 282 {
 283    util_dump_enum(stream, util_dump_stencil_op(value, TRUE));
 284 }
 285
 286
 287 /*
 288  * Public functions
 289  */
 290
 291
 292 void
 293 util_dump_resource(FILE *stream, const struct pipe_resource *state)
 294 {
 295    if (!state) {
 296       util_dump_null(stream);
 297       return;
 298    }
 299
 300    util_dump_struct_begin(stream, "pipe_resource");
 301
 302    util_dump_member(stream, enum_tex_target, state, target);
 303    util_dump_member(stream, format, state, format);
 304
 305    util_dump_member(stream, uint, state, width0);
 306    util_dump_member(stream, uint, state, height0);
 307    util_dump_member(stream, uint, state, depth0);
 308    util_dump_member(stream, uint, state, array_size);
 309
 310    util_dump_member(stream, uint, state, last_level);
 311    util_dump_member(stream, uint, state, nr_samples);
 312    util_dump_member(stream, uint, state, usage);
 313    util_dump_member(stream, uint, state, bind);
 314    util_dump_member(stream, uint, state, flags);
 315
 316    util_dump_struct_end(stream);
 317 }
 318
 319
 320 void
 321 util_dump_rasterizer_state(FILE *stream, const struct pipe_rasterizer_state *state)
 322 {
 323    if (!state) {
 324       util_dump_null(stream);
 325       return;
 326    }
 327
 328    util_dump_struct_begin(stream, "pipe_rasterizer_state");
 329
 330    util_dump_member(stream, bool, state, flatshade);
 331    util_dump_member(stream, bool, state, light_twoside);
 332    util_dump_member(stream, bool, state, clamp_vertex_color);
 333    util_dump_member(stream, bool, state, clamp_fragment_color);
 334    util_dump_member(stream, uint, state, front_ccw);
 335    util_dump_member(stream, uint, state, cull_face);
 336    util_dump_member(stream, uint, state, fill_front);
 337    util_dump_member(stream, uint, state, fill_back);
 338    util_dump_member(stream, bool, state, offset_point);
 339    util_dump_member(stream, bool, state, offset_line);
 340    util_dump_member(stream, bool, state, offset_tri);
 341    util_dump_member(stream, bool, state, scissor);
 342    util_dump_member(stream, bool, state, poly_smooth);
 343    util_dump_member(stream, bool, state, poly_stipple_enable);
 344    util_dump_member(stream, bool, state, point_smooth);
 345    util_dump_member(stream, uint, state, sprite_coord_enable);
 346    util_dump_member(stream, bool, state, sprite_coord_mode);
 347    util_dump_member(stream, bool, state, point_quad_rasterization);
 348    util_dump_member(stream, bool, state, point_tri_clip);
 349    util_dump_member(stream, bool, state, point_size_per_vertex);
 350    util_dump_member(stream, bool, state, multisample);
 351    util_dump_member(stream, bool, state, line_smooth);
 352    util_dump_member(stream, bool, state, line_stipple_enable);
 353    util_dump_member(stream, uint, state, line_stipple_factor);
 354    util_dump_member(stream, uint, state, line_stipple_pattern);
 355    util_dump_member(stream, bool, state, line_last_pixel);
 356    util_dump_member(stream, bool, state, flatshade_first);
 357    util_dump_member(stream, bool, state, half_pixel_center);
 358    util_dump_member(stream, bool, state, bottom_edge_rule);
 359    util_dump_member(stream, bool, state, rasterizer_discard);
 360    util_dump_member(stream, bool, state, depth_clip);
 361    util_dump_member(stream, bool, state, clip_halfz);
 362    util_dump_member(stream, uint, state, clip_plane_enable);
 363
 364    util_dump_member(stream, float, state, line_width);
 365    util_dump_member(stream, float, state, point_size);
 366    util_dump_member(stream, float, state, offset_units);
 367    util_dump_member(stream, float, state, offset_scale);
 368    util_dump_member(stream, float, state, offset_clamp);
 369
 370    util_dump_struct_end(stream);
 371 }
 372
 373
 374 void
 375 util_dump_poly_stipple(FILE *stream, const struct pipe_poly_stipple *state)
 376 {
 377    if (!state) {
 378       util_dump_null(stream);
 379       return;
 380    }
 381
 382    util_dump_struct_begin(stream, "pipe_poly_stipple");
 383
 384    util_dump_member_begin(stream, "stipple");
 385    util_dump_member_array(stream, uint, state, stipple);
 386    util_dump_member_end(stream);
 387
 388    util_dump_struct_end(stream);
 389 }
 390
 391
 392 void
 393 util_dump_viewport_state(FILE *stream, const struct pipe_viewport_state *state)
 394 {
 395    if (!state) {
 396       util_dump_null(stream);
 397       return;
 398    }
 399
 400    util_dump_struct_begin(stream, "pipe_viewport_state");
 401
 402    util_dump_member_array(stream, float, state, scale);
 403    util_dump_member_array(stream, float, state, translate);
 404
 405    util_dump_struct_end(stream);
 406 }
 407
 408
 409 void
 410 util_dump_scissor_state(FILE *stream, const struct pipe_scissor_state *state)
 411 {
 412    if (!state) {
 413       util_dump_null(stream);
 414       return;
 415    }
 416
 417    util_dump_struct_begin(stream, "pipe_scissor_state");
 418
 419    util_dump_member(stream, uint, state, minx);
 420    util_dump_member(stream, uint, state, miny);
 421    util_dump_member(stream, uint, state, maxx);
 422    util_dump_member(stream, uint, state, maxy);
 423
 424    util_dump_struct_end(stream);
 425 }
 426
 427
 428 void
 429 util_dump_clip_state(FILE *stream, const struct pipe_clip_state *state)
 430 {
 431    unsigned i;
 432
 433    if (!state) {
 434       util_dump_null(stream);
 435       return;
 436    }
 437
 438    util_dump_struct_begin(stream, "pipe_clip_state");
 439
 440    util_dump_member_begin(stream, "ucp");
 441    util_dump_array_begin(stream);
 442    for(i = 0; i < PIPE_MAX_CLIP_PLANES; ++i) {
 443       util_dump_elem_begin(stream);
 444       util_dump_array(stream, float, state->ucp[i], 4);
 445       util_dump_elem_end(stream);
 446    }
 447    util_dump_array_end(stream);
 448    util_dump_member_end(stream);
 449
 450    util_dump_struct_end(stream);
 451 }
 452
 453
 454 void
 455 util_dump_shader_state(FILE *stream, const struct pipe_shader_state *state)
 456 {
 457    unsigned i;
 458
 459    if (!state) {
 460       util_dump_null(stream);
 461       return;
 462    }
 463
 464    util_dump_struct_begin(stream, "pipe_shader_state");
 465
 466    util_dump_member_begin(stream, "tokens");
 467    fprintf(stream, "\"\n");
 468    tgsi_dump_to_file(state->tokens, 0, stream);
 469    fprintf(stream, "\"");
 470    util_dump_member_end(stream);
 471
 472    if (state->stream_output.num_outputs) {
 473       util_dump_member_begin(stream, "stream_output");
 474       util_dump_struct_begin(stream, "pipe_stream_output_info");
 475       util_dump_member(stream, uint, &state->stream_output, num_outputs);
 476       util_dump_array(stream, uint, state->stream_output.stride,
 477                       Elements(state->stream_output.stride));
 478       util_dump_array_begin(stream);
 479       for(i = 0; i < state->stream_output.num_outputs; ++i) {
 480          util_dump_elem_begin(stream);
 481          util_dump_struct_begin(stream, ""); /* anonymous */
 482          util_dump_member(stream, uint, &state->stream_output.output[i], register_index);
 483          util_dump_member(stream, uint, &state->stream_output.output[i], start_component);
 484          util_dump_member(stream, uint, &state->stream_output.output[i], num_components);
 485          util_dump_member(stream, uint, &state->stream_output.output[i], output_buffer);
 486          util_dump_struct_end(stream);
 487          util_dump_elem_end(stream);
 488       }
 489       util_dump_array_end(stream);
 490       util_dump_struct_end(stream);
 491       util_dump_member_end(stream);
 492    }
 493
 494    util_dump_struct_end(stream);
 495 }
 496
 497
 498 void
 499 util_dump_depth_stencil_alpha_state(FILE *stream, const struct pipe_depth_stencil_alpha_state *state)
 500 {
 501    unsigned i;
 502
 503    if (!state) {
 504       util_dump_null(stream);
 505       return;
 506    }
 507
 508    util_dump_struct_begin(stream, "pipe_depth_stencil_alpha_state");
 509
 510    util_dump_member_begin(stream, "depth");
 511    util_dump_struct_begin(stream, "pipe_depth_state");
 512    util_dump_member(stream, bool, &state->depth, enabled);
 513    if (state->depth.enabled) {
 514       util_dump_member(stream, bool, &state->depth, writemask);
 515       util_dump_member(stream, enum_func, &state->depth, func);
 516    }
 517    util_dump_struct_end(stream);
 518    util_dump_member_end(stream);
 519
 520    util_dump_member_begin(stream, "stencil");
 521    util_dump_array_begin(stream);
 522    for(i = 0; i < Elements(state->stencil); ++i) {
 523       util_dump_elem_begin(stream);
 524       util_dump_struct_begin(stream, "pipe_stencil_state");
 525       util_dump_member(stream, bool, &state->stencil[i], enabled);
 526       if (state->stencil[i].enabled) {
 527          util_dump_member(stream, enum_func, &state->stencil[i], func);
 528          util_dump_member(stream, enum_stencil_op,
 529                           &state->stencil[i], fail_op);
 530          util_dump_member(stream, enum_stencil_op,
 531                           &state->stencil[i], zpass_op);
 532          util_dump_member(stream, enum_stencil_op,
 533                           &state->stencil[i], zfail_op);
 534          util_dump_member(stream, uint, &state->stencil[i], valuemask);
 535          util_dump_member(stream, uint, &state->stencil[i], writemask);
 536       }
 537       util_dump_struct_end(stream);
 538       util_dump_elem_end(stream);
 539    }
 540    util_dump_array_end(stream);
 541    util_dump_member_end(stream);
 542
 543    util_dump_member_begin(stream, "alpha");
 544    util_dump_struct_begin(stream, "pipe_alpha_state");
 545    util_dump_member(stream, bool, &state->alpha, enabled);
 546    if (state->alpha.enabled) {
 547       util_dump_member(stream, enum_func, &state->alpha, func);
 548       util_dump_member(stream, float, &state->alpha, ref_value);
 549    }
 550    util_dump_struct_end(stream);
 551    util_dump_member_end(stream);
 552
 553    util_dump_struct_end(stream);
 554 }
 555
 556 void
 557 util_dump_rt_blend_state(FILE *stream, const struct pipe_rt_blend_state *state)
 558 {
 559    util_dump_struct_begin(stream, "pipe_rt_blend_state");
 560
 561    util_dump_member(stream, uint, state, blend_enable);
 562    if (state->blend_enable) {
 563       util_dump_member(stream, enum_blend_func, state, rgb_func);
 564       util_dump_member(stream, enum_blend_factor, state, rgb_src_factor);
 565       util_dump_member(stream, enum_blend_factor, state, rgb_dst_factor);
 566
 567       util_dump_member(stream, enum_blend_func, state, alpha_func);
 568       util_dump_member(stream, enum_blend_factor, state, alpha_src_factor);
 569       util_dump_member(stream, enum_blend_factor, state, alpha_dst_factor);
 570    }
 571
 572    util_dump_member(stream, uint, state, colormask);
 573
 574    util_dump_struct_end(stream);
 575 }
 576
 577 void
 578 util_dump_blend_state(FILE *stream, const struct pipe_blend_state *state)
 579 {
 580    unsigned valid_entries = 1;
 581
 582    if (!state) {
 583       util_dump_null(stream);
 584       return;
 585    }
 586
 587    util_dump_struct_begin(stream, "pipe_blend_state");
 588
 589    util_dump_member(stream, bool, state, dither);
 590    util_dump_member(stream, bool, state, alpha_to_coverage);
 591    util_dump_member(stream, bool, state, alpha_to_one);
 592
 593    util_dump_member(stream, bool, state, logicop_enable);
 594    if (state->logicop_enable) {
 595       util_dump_member(stream, enum_func, state, logicop_func);
 596    }
 597    else {
 598       util_dump_member(stream, bool, state, independent_blend_enable);
 599
 600       util_dump_member_begin(stream, "rt");
 601       if (state->independent_blend_enable)
 602          valid_entries = PIPE_MAX_COLOR_BUFS;
 603       util_dump_struct_array(stream, rt_blend_state, state->rt, valid_entries);
 604       util_dump_member_end(stream);
 605    }
 606
 607    util_dump_struct_end(stream);
 608 }
 609
 610
 611 void
 612 util_dump_blend_color(FILE *stream, const struct pipe_blend_color *state)
 613 {
 614    if (!state) {
 615       util_dump_null(stream);
 616       return;
 617    }
 618
 619    util_dump_struct_begin(stream, "pipe_blend_color");
 620
 621    util_dump_member_array(stream, float, state, color);
 622
 623    util_dump_struct_end(stream);
 624 }
 625
 626 void
 627 util_dump_stencil_ref(FILE *stream, const struct pipe_stencil_ref *state)
 628 {
 629    if (!state) {
 630       util_dump_null(stream);
 631       return;
 632    }
 633
 634    util_dump_struct_begin(stream, "pipe_stencil_ref");
 635
 636    util_dump_member_array(stream, uint, state, ref_value);
 637
 638    util_dump_struct_end(stream);
 639 }
 640
 641 void
 642 util_dump_framebuffer_state(FILE *stream, const struct pipe_framebuffer_state *state)
 643 {
 644    util_dump_struct_begin(stream, "pipe_framebuffer_state");
 645
 646    util_dump_member(stream, uint, state, width);
 647    util_dump_member(stream, uint, state, height);
 648    util_dump_member(stream, uint, state, nr_cbufs);
 649    util_dump_member_array(stream, ptr, state, cbufs);
 650    util_dump_member(stream, ptr, state, zsbuf);
 651
 652    util_dump_struct_end(stream);
 653 }
 654
 655
 656 void
 657 util_dump_sampler_state(FILE *stream, const struct pipe_sampler_state *state)
 658 {
 659    if (!state) {
 660       util_dump_null(stream);
 661       return;
 662    }
 663
 664    util_dump_struct_begin(stream, "pipe_sampler_state");
 665
 666    util_dump_member(stream, enum_tex_wrap, state, wrap_s);
 667    util_dump_member(stream, enum_tex_wrap, state, wrap_t);
 668    util_dump_member(stream, enum_tex_wrap, state, wrap_r);
 669    util_dump_member(stream, enum_tex_filter, state, min_img_filter);
 670    util_dump_member(stream, enum_tex_mipfilter, state, min_mip_filter);
 671    util_dump_member(stream, enum_tex_filter, state, mag_img_filter);
 672    util_dump_member(stream, uint, state, compare_mode);
 673    util_dump_member(stream, enum_func, state, compare_func);
 674    util_dump_member(stream, bool, state, normalized_coords);
 675    util_dump_member(stream, uint, state, max_anisotropy);
 676    util_dump_member(stream, bool, state, seamless_cube_map);
 677    util_dump_member(stream, float, state, lod_bias);
 678    util_dump_member(stream, float, state, min_lod);
 679    util_dump_member(stream, float, state, max_lod);
 680    util_dump_member_array(stream, float, state, border_color.f);
 681
 682    util_dump_struct_end(stream);
 683 }
 684
 685
 686 void
 687 util_dump_surface(FILE *stream, const struct pipe_surface *state)
 688 {
 689    if (!state) {
 690       util_dump_null(stream);
 691       return;
 692    }
 693
 694    util_dump_struct_begin(stream, "pipe_surface");
 695
 696    util_dump_member(stream, format, state, format);
 697    util_dump_member(stream, uint, state, width);
 698    util_dump_member(stream, uint, state, height);
 699
 700    util_dump_member(stream, ptr, state, texture);
 701    util_dump_member(stream, uint, state, u.tex.level);
 702    util_dump_member(stream, uint, state, u.tex.first_layer);
 703    util_dump_member(stream, uint, state, u.tex.last_layer);
 704
 705    util_dump_struct_end(stream);
 706 }
 707
 708
 709 void
 710 util_dump_image_view(FILE *stream, const struct pipe_image_view *state)
 711 {
 712    if (!state) {
 713       util_dump_null(stream);
 714       return;
 715    }
 716
 717    util_dump_struct_begin(stream, "pipe_image_view");
 718
 719    util_dump_member(stream, ptr, state, resource);
 720    util_dump_member(stream, format, state, format);
 721
 722    if (state->resource->target == PIPE_BUFFER) {
 723       util_dump_member(stream, uint, state, u.buf.first_element);
 724       util_dump_member(stream, uint, state, u.buf.last_element);
 725    }
 726    else {
 727       util_dump_member(stream, uint, state, u.tex.first_layer);
 728       util_dump_member(stream, uint, state, u.tex.last_layer);
 729       util_dump_member(stream, uint, state, u.tex.level);
 730    }
 731
 732    util_dump_struct_end(stream);
 733 }
 734
 735
 736 void
 737 util_dump_sampler_view(FILE *stream, const struct pipe_sampler_view *state)
 738 {
 739    if (!state) {
 740       util_dump_null(stream);
 741       return;
 742    }
 743
 744    util_dump_struct_begin(stream, "pipe_sampler_view");
 745
 746    util_dump_member(stream, enum_tex_target, state, target);
 747    util_dump_member(stream, format, state, format);
 748    util_dump_member(stream, ptr, state, texture);
 749
 750    if (state->target == PIPE_BUFFER) {
 751       util_dump_member(stream, uint, state, u.buf.first_element);
 752       util_dump_member(stream, uint, state, u.buf.last_element);
 753    }
 754    else {
 755       util_dump_member(stream, uint, state, u.tex.first_layer);
 756       util_dump_member(stream, uint, state, u.tex.last_layer);
 757       util_dump_member(stream, uint, state, u.tex.last_level);
 758       util_dump_member(stream, uint, state, u.tex.last_level);
 759    }
 760
 761    util_dump_member(stream, uint, state, swizzle_r);
 762    util_dump_member(stream, uint, state, swizzle_g);
 763    util_dump_member(stream, uint, state, swizzle_b);
 764    util_dump_member(stream, uint, state, swizzle_a);
 765
 766    util_dump_struct_end(stream);
 767 }
 768
 769
 770 void
 771 util_dump_transfer(FILE *stream, const struct pipe_transfer *state)
 772 {
 773    if (!state) {
 774       util_dump_null(stream);
 775       return;
 776    }
 777
 778    util_dump_struct_begin(stream, "pipe_transfer");
 779
 780    util_dump_member(stream, ptr, state, resource);
 781    util_dump_member(stream, uint, state, level);
 782    util_dump_member(stream, uint, state, usage);
 783    util_dump_member_begin(stream, "box");
 784    util_dump_box(stream, &state->box);
 785    util_dump_member_end(stream);
 786    util_dump_member(stream, uint, state, stride);
 787    util_dump_member(stream, uint, state, layer_stride);
 788
 789    util_dump_struct_end(stream);
 790 }
 791
 792
 793 void
 794 util_dump_constant_buffer(FILE *stream,
 795                           const struct pipe_constant_buffer *state)
 796 {
 797    if (!state) {
 798       util_dump_null(stream);
 799       return;
 800    }
 801
 802    util_dump_struct_begin(stream, "pipe_constant_buffer");
 803
 804    util_dump_member(stream, ptr, state, buffer);
 805    util_dump_member(stream, uint, state, buffer_offset);
 806    util_dump_member(stream, uint, state, buffer_size);
 807    util_dump_member(stream, ptr, state, user_buffer);
 808
 809    util_dump_struct_end(stream);
 810 }
 811
 812
 813 void
 814 util_dump_index_buffer(FILE *stream, const struct pipe_index_buffer *state)
 815 {
 816    if (!state) {
 817       util_dump_null(stream);
 818       return;
 819    }
 820
 821    util_dump_struct_begin(stream, "pipe_index_buffer");
 822
 823    util_dump_member(stream, uint, state, index_size);
 824    util_dump_member(stream, uint, state, offset);
 825    util_dump_member(stream, ptr, state, buffer);
 826    util_dump_member(stream, ptr, state, user_buffer);
 827
 828    util_dump_struct_end(stream);
 829 }
 830
 831
 832 void
 833 util_dump_vertex_buffer(FILE *stream, const struct pipe_vertex_buffer *state)
 834 {
 835    if (!state) {
 836       util_dump_null(stream);
 837       return;
 838    }
 839
 840    util_dump_struct_begin(stream, "pipe_vertex_buffer");
 841
 842    util_dump_member(stream, uint, state, stride);
 843    util_dump_member(stream, uint, state, buffer_offset);
 844    util_dump_member(stream, ptr, state, buffer);
 845    util_dump_member(stream, ptr, state, user_buffer);
 846
 847    util_dump_struct_end(stream);
 848 }
 849
 850
 851 void
 852 util_dump_vertex_element(FILE *stream, const struct pipe_vertex_element *state)
 853 {
 854    if (!state) {
 855       util_dump_null(stream);
 856       return;
 857    }
 858
 859    util_dump_struct_begin(stream, "pipe_vertex_element");
 860
 861    util_dump_member(stream, uint, state, src_offset);
 862    util_dump_member(stream, uint, state, instance_divisor);
 863    util_dump_member(stream, uint, state, vertex_buffer_index);
 864    util_dump_member(stream, format, state, src_format);
 865
 866    util_dump_struct_end(stream);
 867 }
 868
 869
 870 void
 871 util_dump_stream_output_target(FILE *stream,
 872                                const struct pipe_stream_output_target *state)
 873 {
 874    if (!state) {
 875       util_dump_null(stream);
 876       return;
 877    }
 878
 879    util_dump_struct_begin(stream, "pipe_stream_output_target");
 880
 881    util_dump_member(stream, ptr, state, buffer);
 882    util_dump_member(stream, uint, state, buffer_offset);
 883    util_dump_member(stream, uint, state, buffer_size);
 884
 885    util_dump_struct_end(stream);
 886 }
 887
 888
 889 void
 890 util_dump_draw_info(FILE *stream, const struct pipe_draw_info *state)
 891 {
 892    if (!state) {
 893       util_dump_null(stream);
 894       return;
 895    }
 896
 897    util_dump_struct_begin(stream, "pipe_draw_info");
 898
 899    util_dump_member(stream, bool, state, indexed);
 900
 901    util_dump_member(stream, enum_prim_mode, state, mode);
 902    util_dump_member(stream, uint, state, start);
 903    util_dump_member(stream, uint, state, count);
 904
 905    util_dump_member(stream, uint, state, start_instance);
 906    util_dump_member(stream, uint, state, instance_count);
 907
 908    util_dump_member(stream, uint, state, vertices_per_patch);
 909
 910    util_dump_member(stream, int,  state, index_bias);
 911    util_dump_member(stream, uint, state, min_index);
 912    util_dump_member(stream, uint, state, max_index);
 913
 914    util_dump_member(stream, bool, state, primitive_restart);
 915    util_dump_member(stream, uint, state, restart_index);
 916
 917    util_dump_member(stream, ptr, state, count_from_stream_output);
 918
 919    util_dump_member(stream, ptr, state, indirect);
 920    util_dump_member(stream, uint, state, indirect_offset);
 921
 922    util_dump_struct_end(stream);
 923 }
 924
 925 void util_dump_box(FILE *stream, const struct pipe_box *box)
 926 {
 927    if (!box) {
 928       util_dump_null(stream);
 929       return;
 930    }
 931
 932    util_dump_struct_begin(stream, "pipe_box");
 933
 934    util_dump_member(stream, int, box, x);
 935    util_dump_member(stream, int, box, y);
 936    util_dump_member(stream, int, box, z);
 937    util_dump_member(stream, int, box, width);
 938    util_dump_member(stream, int, box, height);
 939    util_dump_member(stream, int, box, depth);
 940
 941    util_dump_struct_end(stream);
 942 }
 943
 944 void util_dump_blit_info(FILE *stream, const struct pipe_blit_info *info)
 945 {
 946    char mask[7];
 947
 948    if (!info) {
 949       util_dump_null(stream);
 950       return;
 951    }
 952
 953    util_dump_struct_begin(stream, "pipe_blit_info");
 954
 955    util_dump_member_begin(stream, "dst");
 956    util_dump_struct_begin(stream, "dst");
 957    util_dump_member(stream, ptr, &info->dst, resource);
 958    util_dump_member(stream, uint, &info->dst, level);
 959    util_dump_member(stream, format, &info->dst, format);
 960    util_dump_member_begin(stream, "box");
 961    util_dump_box(stream, &info->dst.box);
 962    util_dump_member_end(stream);
 963    util_dump_struct_end(stream);
 964    util_dump_member_end(stream);
 965
 966    util_dump_member_begin(stream, "src");
 967    util_dump_struct_begin(stream, "src");
 968    util_dump_member(stream, ptr, &info->src, resource);
 969    util_dump_member(stream, uint, &info->src, level);
 970    util_dump_member(stream, format, &info->src, format);
 971    util_dump_member_begin(stream, "box");
 972    util_dump_box(stream, &info->src.box);
 973    util_dump_member_end(stream);
 974    util_dump_struct_end(stream);
 975    util_dump_member_end(stream);
 976
 977    mask[0] = (info->mask & PIPE_MASK_R) ? 'R' : '-';
 978    mask[1] = (info->mask & PIPE_MASK_G) ? 'G' : '-';
 979    mask[2] = (info->mask & PIPE_MASK_B) ? 'B' : '-';
 980    mask[3] = (info->mask & PIPE_MASK_A) ? 'A' : '-';
 981    mask[4] = (info->mask & PIPE_MASK_Z) ? 'Z' : '-';
 982    mask[5] = (info->mask & PIPE_MASK_S) ? 'S' : '-';
 983    mask[6] = 0;
 984
 985    util_dump_member_begin(stream, "mask");
 986    util_dump_string(stream, mask);
 987    util_dump_member_end(stream);
 988    util_dump_member(stream, enum_tex_filter, info, filter);
 989
 990    util_dump_member(stream, bool, info, scissor_enable);
 991    util_dump_member_begin(stream, "scissor");
 992    util_dump_scissor_state(stream, &info->scissor);
 993    util_dump_member_end(stream);
 994
 995    util_dump_member(stream, bool, info, render_condition_enable);
 996
 997    util_dump_struct_end(stream);
 998 }