Home | History | Annotate | Download | only in util
      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, gl_rasterization_rules);
    331    util_dump_member(stream, bool, state, rasterizer_discard);
    332    util_dump_member(stream, bool, state, depth_clip);
    333    util_dump_member(stream, uint, state, clip_plane_enable);
    334 
    335    util_dump_member(stream, float, state, line_width);
    336    util_dump_member(stream, float, state, point_size);
    337    util_dump_member(stream, float, state, offset_units);
    338    util_dump_member(stream, float, state, offset_scale);
    339    util_dump_member(stream, float, state, offset_clamp);
    340 
    341    util_dump_struct_end(stream);
    342 }
    343 
    344 
    345 void
    346 util_dump_poly_stipple(FILE *stream, const struct pipe_poly_stipple *state)
    347 {
    348    if(!state) {
    349       util_dump_null(stream);
    350       return;
    351    }
    352 
    353    util_dump_struct_begin(stream, "pipe_poly_stipple");
    354 
    355    util_dump_member_begin(stream, "stipple");
    356    util_dump_member_array(stream, uint, state, stipple);
    357    util_dump_member_end(stream);
    358 
    359    util_dump_struct_end(stream);
    360 }
    361 
    362 
    363 void
    364 util_dump_viewport_state(FILE *stream, const struct pipe_viewport_state *state)
    365 {
    366    if(!state) {
    367       util_dump_null(stream);
    368       return;
    369    }
    370 
    371    util_dump_struct_begin(stream, "pipe_viewport_state");
    372 
    373    util_dump_member_array(stream, float, state, scale);
    374    util_dump_member_array(stream, float, state, translate);
    375 
    376    util_dump_struct_end(stream);
    377 }
    378 
    379 
    380 void
    381 util_dump_scissor_state(FILE *stream, const struct pipe_scissor_state *state)
    382 {
    383    if(!state) {
    384       util_dump_null(stream);
    385       return;
    386    }
    387 
    388    util_dump_struct_begin(stream, "pipe_scissor_state");
    389 
    390    util_dump_member(stream, uint, state, minx);
    391    util_dump_member(stream, uint, state, miny);
    392    util_dump_member(stream, uint, state, maxx);
    393    util_dump_member(stream, uint, state, maxy);
    394 
    395    util_dump_struct_end(stream);
    396 }
    397 
    398 
    399 void
    400 util_dump_clip_state(FILE *stream, const struct pipe_clip_state *state)
    401 {
    402    unsigned i;
    403 
    404    if(!state) {
    405       util_dump_null(stream);
    406       return;
    407    }
    408 
    409    util_dump_struct_begin(stream, "pipe_clip_state");
    410 
    411    util_dump_member_begin(stream, "ucp");
    412    util_dump_array_begin(stream);
    413    for(i = 0; i < PIPE_MAX_CLIP_PLANES; ++i) {
    414       util_dump_elem_begin(stream);
    415       util_dump_array(stream, float, state->ucp[i], 4);
    416       util_dump_elem_end(stream);
    417    }
    418    util_dump_array_end(stream);
    419    util_dump_member_end(stream);
    420 
    421    util_dump_struct_end(stream);
    422 }
    423 
    424 
    425 void
    426 util_dump_shader_state(FILE *stream, const struct pipe_shader_state *state)
    427 {
    428    char str[8192];
    429    unsigned i;
    430 
    431    if(!state) {
    432       util_dump_null(stream);
    433       return;
    434    }
    435 
    436    tgsi_dump_str(state->tokens, 0, str, sizeof(str));
    437 
    438    util_dump_struct_begin(stream, "pipe_shader_state");
    439 
    440    util_dump_member_begin(stream, "tokens");
    441    util_dump_string(stream, str);
    442    util_dump_member_end(stream);
    443 
    444    util_dump_member_begin(stream, "stream_output");
    445    util_dump_struct_begin(stream, "pipe_stream_output_info");
    446    util_dump_member(stream, uint, &state->stream_output, num_outputs);
    447    util_dump_array(stream, uint, state->stream_output.stride,
    448                    Elements(state->stream_output.stride));
    449    util_dump_array_begin(stream);
    450    for(i = 0; i < state->stream_output.num_outputs; ++i) {
    451       util_dump_elem_begin(stream);
    452       util_dump_struct_begin(stream, ""); /* anonymous */
    453       util_dump_member(stream, uint, &state->stream_output.output[i], register_index);
    454       util_dump_member(stream, uint, &state->stream_output.output[i], start_component);
    455       util_dump_member(stream, uint, &state->stream_output.output[i], num_components);
    456       util_dump_member(stream, uint, &state->stream_output.output[i], output_buffer);
    457       util_dump_struct_end(stream);
    458       util_dump_elem_end(stream);
    459    }
    460    util_dump_array_end(stream);
    461    util_dump_struct_end(stream);
    462    util_dump_member_end(stream);
    463 
    464    util_dump_struct_end(stream);
    465 }
    466 
    467 
    468 void
    469 util_dump_depth_stencil_alpha_state(FILE *stream, const struct pipe_depth_stencil_alpha_state *state)
    470 {
    471    unsigned i;
    472 
    473    if(!state) {
    474       util_dump_null(stream);
    475       return;
    476    }
    477 
    478    util_dump_struct_begin(stream, "pipe_depth_stencil_alpha_state");
    479 
    480    util_dump_member_begin(stream, "depth");
    481    util_dump_struct_begin(stream, "pipe_depth_state");
    482    util_dump_member(stream, bool, &state->depth, enabled);
    483    if (state->depth.enabled) {
    484       util_dump_member(stream, bool, &state->depth, writemask);
    485       util_dump_member(stream, enum_func, &state->depth, func);
    486    }
    487    util_dump_struct_end(stream);
    488    util_dump_member_end(stream);
    489 
    490    util_dump_member_begin(stream, "stencil");
    491    util_dump_array_begin(stream);
    492    for(i = 0; i < Elements(state->stencil); ++i) {
    493       util_dump_elem_begin(stream);
    494       util_dump_struct_begin(stream, "pipe_stencil_state");
    495       util_dump_member(stream, bool, &state->stencil[i], enabled);
    496       if (state->stencil[i].enabled) {
    497          util_dump_member(stream, enum_func, &state->stencil[i], func);
    498          util_dump_member(stream, uint, &state->stencil[i], fail_op);
    499          util_dump_member(stream, uint, &state->stencil[i], zpass_op);
    500          util_dump_member(stream, uint, &state->stencil[i], zfail_op);
    501          util_dump_member(stream, uint, &state->stencil[i], valuemask);
    502          util_dump_member(stream, uint, &state->stencil[i], writemask);
    503       }
    504       util_dump_struct_end(stream);
    505       util_dump_elem_end(stream);
    506    }
    507    util_dump_array_end(stream);
    508    util_dump_member_end(stream);
    509 
    510    util_dump_member_begin(stream, "alpha");
    511    util_dump_struct_begin(stream, "pipe_alpha_state");
    512    util_dump_member(stream, bool, &state->alpha, enabled);
    513    if (state->alpha.enabled) {
    514       util_dump_member(stream, enum_func, &state->alpha, func);
    515       util_dump_member(stream, float, &state->alpha, ref_value);
    516    }
    517    util_dump_struct_end(stream);
    518    util_dump_member_end(stream);
    519 
    520    util_dump_struct_end(stream);
    521 }
    522 
    523 void
    524 util_dump_rt_blend_state(FILE *stream, const struct pipe_rt_blend_state *state)
    525 {
    526    util_dump_struct_begin(stream, "pipe_rt_blend_state");
    527 
    528    util_dump_member(stream, uint, state, blend_enable);
    529    if (state->blend_enable) {
    530       util_dump_member(stream, enum_blend_func, state, rgb_func);
    531       util_dump_member(stream, enum_blend_factor, state, rgb_src_factor);
    532       util_dump_member(stream, enum_blend_factor, state, rgb_dst_factor);
    533 
    534       util_dump_member(stream, enum_blend_func, state, alpha_func);
    535       util_dump_member(stream, enum_blend_factor, state, alpha_src_factor);
    536       util_dump_member(stream, enum_blend_factor, state, alpha_dst_factor);
    537    }
    538 
    539    util_dump_member(stream, uint, state, colormask);
    540 
    541    util_dump_struct_end(stream);
    542 }
    543 
    544 void
    545 util_dump_blend_state(FILE *stream, const struct pipe_blend_state *state)
    546 {
    547    unsigned valid_entries = 1;
    548 
    549    if(!state) {
    550       util_dump_null(stream);
    551       return;
    552    }
    553 
    554    util_dump_struct_begin(stream, "pipe_blend_state");
    555 
    556    util_dump_member(stream, bool, state, dither);
    557 
    558    util_dump_member(stream, bool, state, logicop_enable);
    559    if (state->logicop_enable) {
    560       util_dump_member(stream, enum_func, state, logicop_func);
    561    }
    562    else {
    563       util_dump_member(stream, bool, state, independent_blend_enable);
    564 
    565       util_dump_member_begin(stream, "rt");
    566       if (state->independent_blend_enable)
    567          valid_entries = PIPE_MAX_COLOR_BUFS;
    568       util_dump_struct_array(stream, rt_blend_state, state->rt, valid_entries);
    569       util_dump_member_end(stream);
    570    }
    571 
    572    util_dump_struct_end(stream);
    573 }
    574 
    575 
    576 void
    577 util_dump_blend_color(FILE *stream, const struct pipe_blend_color *state)
    578 {
    579    if(!state) {
    580       util_dump_null(stream);
    581       return;
    582    }
    583 
    584    util_dump_struct_begin(stream, "pipe_blend_color");
    585 
    586    util_dump_member_array(stream, float, state, color);
    587 
    588    util_dump_struct_end(stream);
    589 }
    590 
    591 void
    592 util_dump_stencil_ref(FILE *stream, const struct pipe_stencil_ref *state)
    593 {
    594    if(!state) {
    595       util_dump_null(stream);
    596       return;
    597    }
    598 
    599    util_dump_struct_begin(stream, "pipe_stencil_ref");
    600 
    601    util_dump_member_array(stream, uint, state, ref_value);
    602 
    603    util_dump_struct_end(stream);
    604 }
    605 
    606 void
    607 util_dump_framebuffer_state(FILE *stream, const struct pipe_framebuffer_state *state)
    608 {
    609    util_dump_struct_begin(stream, "pipe_framebuffer_state");
    610 
    611    util_dump_member(stream, uint, state, width);
    612    util_dump_member(stream, uint, state, height);
    613    util_dump_member(stream, uint, state, nr_cbufs);
    614    util_dump_member_array(stream, ptr, state, cbufs);
    615    util_dump_member(stream, ptr, state, zsbuf);
    616 
    617    util_dump_struct_end(stream);
    618 }
    619 
    620 
    621 void
    622 util_dump_sampler_state(FILE *stream, const struct pipe_sampler_state *state)
    623 {
    624    if(!state) {
    625       util_dump_null(stream);
    626       return;
    627    }
    628 
    629    util_dump_struct_begin(stream, "pipe_sampler_state");
    630 
    631    util_dump_member(stream, uint, state, wrap_s);
    632    util_dump_member(stream, uint, state, wrap_t);
    633    util_dump_member(stream, uint, state, wrap_r);
    634    util_dump_member(stream, uint, state, min_img_filter);
    635    util_dump_member(stream, uint, state, min_mip_filter);
    636    util_dump_member(stream, uint, state, mag_img_filter);
    637    util_dump_member(stream, uint, state, compare_mode);
    638    util_dump_member(stream, enum_func, state, compare_func);
    639    util_dump_member(stream, bool, state, normalized_coords);
    640    util_dump_member(stream, uint, state, max_anisotropy);
    641    util_dump_member(stream, float, state, lod_bias);
    642    util_dump_member(stream, float, state, min_lod);
    643    util_dump_member(stream, float, state, max_lod);
    644    util_dump_member_array(stream, float, state, border_color.f);
    645 
    646    util_dump_struct_end(stream);
    647 }
    648 
    649 
    650 void
    651 util_dump_surface(FILE *stream, const struct pipe_surface *state)
    652 {
    653    if(!state) {
    654       util_dump_null(stream);
    655       return;
    656    }
    657 
    658    util_dump_struct_begin(stream, "pipe_surface");
    659 
    660    util_dump_member(stream, format, state, format);
    661    util_dump_member(stream, uint, state, width);
    662    util_dump_member(stream, uint, state, height);
    663 
    664    util_dump_member(stream, uint, state, usage);
    665 
    666    util_dump_member(stream, ptr, state, texture);
    667    util_dump_member(stream, uint, state, u.tex.level);
    668    util_dump_member(stream, uint, state, u.tex.first_layer);
    669    util_dump_member(stream, uint, state, u.tex.last_layer);
    670 
    671    util_dump_struct_end(stream);
    672 }
    673 
    674 
    675 void
    676 util_dump_transfer(FILE *stream, const struct pipe_transfer *state)
    677 {
    678    if(!state) {
    679       util_dump_null(stream);
    680       return;
    681    }
    682 
    683    util_dump_struct_begin(stream, "pipe_transfer");
    684 
    685    util_dump_member(stream, ptr, state, resource);
    686    /*util_dump_member(stream, uint, state, box);*/
    687 
    688    util_dump_member(stream, uint, state, stride);
    689    util_dump_member(stream, uint, state, layer_stride);
    690 
    691    /*util_dump_member(stream, ptr, state, data);*/
    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 
    727    util_dump_member(stream, uint, state, vertex_buffer_index);
    728 
    729    util_dump_member(stream, format, state, src_format);
    730 
    731    util_dump_struct_end(stream);
    732 }
    733 
    734 
    735 void
    736 util_dump_draw_info(FILE *stream, const struct pipe_draw_info *state)
    737 {
    738    if(!state) {
    739       util_dump_null(stream);
    740       return;
    741    }
    742 
    743    util_dump_struct_begin(stream, "pipe_draw_info");
    744 
    745    util_dump_member(stream, bool, state, indexed);
    746 
    747    util_dump_member(stream, uint, state, mode);
    748    util_dump_member(stream, uint, state, start);
    749    util_dump_member(stream, uint, state, count);
    750 
    751    util_dump_member(stream, uint, state, start_instance);
    752    util_dump_member(stream, uint, state, instance_count);
    753 
    754    util_dump_member(stream, int,  state, index_bias);
    755    util_dump_member(stream, uint, state, min_index);
    756    util_dump_member(stream, uint, state, max_index);
    757 
    758    util_dump_member(stream, bool, state, primitive_restart);
    759    util_dump_member(stream, uint, state, restart_index);
    760 
    761    util_dump_member(stream, ptr, state, count_from_stream_output);
    762 
    763    util_dump_struct_end(stream);
    764 }
    765