Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  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, int,  state, index_bias);
  754.    util_dump_member(stream, uint, state, min_index);
  755.    util_dump_member(stream, uint, state, max_index);
  756.  
  757.    util_dump_member(stream, bool, state, primitive_restart);
  758.    util_dump_member(stream, uint, state, restart_index);
  759.  
  760.    util_dump_member(stream, ptr, state, count_from_stream_output);
  761.  
  762.    util_dump_struct_end(stream);
  763. }
  764.  
  765. void util_dump_box(FILE *stream, const struct pipe_box *box)
  766. {
  767.    if(!box) {
  768.       util_dump_null(stream);
  769.       return;
  770.    }
  771.  
  772.    util_dump_struct_begin(stream, "pipe_box");
  773.  
  774.    util_dump_member(stream, int, box, x);
  775.    util_dump_member(stream, int, box, y);
  776.    util_dump_member(stream, int, box, z);
  777.    util_dump_member(stream, int, box, width);
  778.    util_dump_member(stream, int, box, height);
  779.    util_dump_member(stream, int, box, depth);
  780.  
  781.    util_dump_struct_end(stream);
  782. }
  783.  
  784. void util_dump_blit_info(FILE *stream, const struct pipe_blit_info *info)
  785. {
  786.    char mask[7];
  787.  
  788.    if (!info) {
  789.       util_dump_null(stream);
  790.       return;
  791.    }
  792.  
  793.    util_dump_struct_begin(stream, "pipe_blit_info");
  794.  
  795.    util_dump_member_begin(stream, "dst");
  796.    util_dump_struct_begin(stream, "dst");
  797.    util_dump_member(stream, ptr, &info->dst, resource);
  798.    util_dump_member(stream, uint, &info->dst, level);
  799.    util_dump_member(stream, format, &info->dst, format);
  800.    util_dump_member_begin(stream, "box");
  801.    util_dump_box(stream, &info->dst.box);
  802.    util_dump_member_end(stream);
  803.    util_dump_struct_end(stream);
  804.    util_dump_member_end(stream);
  805.  
  806.    util_dump_member_begin(stream, "src");
  807.    util_dump_struct_begin(stream, "src");
  808.    util_dump_member(stream, ptr, &info->src, resource);
  809.    util_dump_member(stream, uint, &info->src, level);
  810.    util_dump_member(stream, format, &info->src, format);
  811.    util_dump_member_begin(stream, "box");
  812.    util_dump_box(stream, &info->src.box);
  813.    util_dump_member_end(stream);
  814.    util_dump_struct_end(stream);
  815.    util_dump_member_end(stream);
  816.  
  817.    mask[0] = (info->mask & PIPE_MASK_R) ? 'R' : '-';
  818.    mask[1] = (info->mask & PIPE_MASK_G) ? 'G' : '-';
  819.    mask[2] = (info->mask & PIPE_MASK_B) ? 'B' : '-';
  820.    mask[3] = (info->mask & PIPE_MASK_A) ? 'A' : '-';
  821.    mask[4] = (info->mask & PIPE_MASK_Z) ? 'Z' : '-';
  822.    mask[5] = (info->mask & PIPE_MASK_S) ? 'S' : '-';
  823.    mask[6] = 0;
  824.  
  825.    util_dump_member_begin(stream, "mask");
  826.    util_dump_string(stream, mask);
  827.    util_dump_member_end(stream);
  828.    util_dump_member(stream, uint, info, filter);
  829.  
  830.    util_dump_member(stream, bool, info, scissor_enable);
  831.    util_dump_member_begin(stream, "scissor");
  832.    util_dump_scissor_state(stream, &info->scissor);
  833.    util_dump_member_end(stream);
  834.  
  835.    util_dump_struct_end(stream);
  836. }
  837.