Subversion Repositories Kolibri OS

Rev

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

  1. /**************************************************************************
  2.  *
  3.  * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
  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 TUNGSTEN GRAPHICS 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_format.h"
  32. #include "tgsi/tgsi_dump.h"
  33.  
  34. #include "tr_dump.h"
  35. #include "tr_dump_state.h"
  36.  
  37.  
  38. void trace_dump_format(enum pipe_format format)
  39. {
  40.    if (!trace_dumping_enabled_locked())
  41.       return;
  42.  
  43.    trace_dump_enum(util_format_name(format) );
  44. }
  45.  
  46.  
  47. void trace_dump_resource_template(const struct pipe_resource *templat)
  48. {
  49.    if (!trace_dumping_enabled_locked())
  50.       return;
  51.  
  52.    if(!templat) {
  53.       trace_dump_null();
  54.       return;
  55.    }
  56.  
  57.    trace_dump_struct_begin("pipe_resource");
  58.  
  59.    trace_dump_member(int, templat, target);
  60.    trace_dump_member(format, templat, format);
  61.  
  62.    trace_dump_member_begin("width");
  63.    trace_dump_uint(templat->width0);
  64.    trace_dump_member_end();
  65.  
  66.    trace_dump_member_begin("height");
  67.    trace_dump_uint(templat->height0);
  68.    trace_dump_member_end();
  69.  
  70.    trace_dump_member_begin("depth");
  71.    trace_dump_uint(templat->depth0);
  72.    trace_dump_member_end();
  73.  
  74.    trace_dump_member_begin("array_size");
  75.    trace_dump_uint(templat->array_size);
  76.    trace_dump_member_end();
  77.  
  78.    trace_dump_member(uint, templat, last_level);
  79.    trace_dump_member(uint, templat, nr_samples);
  80.    trace_dump_member(uint, templat, usage);
  81.    trace_dump_member(uint, templat, bind);
  82.    trace_dump_member(uint, templat, flags);
  83.  
  84.    trace_dump_struct_end();
  85. }
  86.  
  87.  
  88. void trace_dump_box(const struct pipe_box *box)
  89. {
  90.    if (!trace_dumping_enabled_locked())
  91.       return;
  92.  
  93.    if(!box) {
  94.       trace_dump_null();
  95.       return;
  96.    }
  97.  
  98.    trace_dump_struct_begin("pipe_box");
  99.  
  100.    trace_dump_member(int, box, x);
  101.    trace_dump_member(int, box, y);
  102.    trace_dump_member(int, box, z);
  103.    trace_dump_member(int, box, width);
  104.    trace_dump_member(int, box, height);
  105.    trace_dump_member(int, box, depth);
  106.  
  107.    trace_dump_struct_end();
  108. }
  109.  
  110.  
  111. void trace_dump_rasterizer_state(const struct pipe_rasterizer_state *state)
  112. {
  113.    if (!trace_dumping_enabled_locked())
  114.       return;
  115.  
  116.    if(!state) {
  117.       trace_dump_null();
  118.       return;
  119.    }
  120.  
  121.    trace_dump_struct_begin("pipe_rasterizer_state");
  122.  
  123.    trace_dump_member(bool, state, flatshade);
  124.    trace_dump_member(bool, state, light_twoside);
  125.    trace_dump_member(bool, state, clamp_vertex_color);
  126.    trace_dump_member(bool, state, clamp_fragment_color);
  127.    trace_dump_member(uint, state, front_ccw);
  128.    trace_dump_member(uint, state, cull_face);
  129.    trace_dump_member(uint, state, fill_front);
  130.    trace_dump_member(uint, state, fill_back);
  131.    trace_dump_member(bool, state, offset_point);
  132.    trace_dump_member(bool, state, offset_line);
  133.    trace_dump_member(bool, state, offset_tri);
  134.    trace_dump_member(bool, state, scissor);
  135.    trace_dump_member(bool, state, poly_smooth);
  136.    trace_dump_member(bool, state, poly_stipple_enable);
  137.    trace_dump_member(bool, state, point_smooth);
  138.    trace_dump_member(uint, state, sprite_coord_enable);
  139.    trace_dump_member(bool, state, sprite_coord_mode);
  140.    trace_dump_member(bool, state, point_quad_rasterization);
  141.    trace_dump_member(bool, state, point_size_per_vertex);
  142.    trace_dump_member(bool, state, multisample);
  143.    trace_dump_member(bool, state, line_smooth);
  144.    trace_dump_member(bool, state, line_stipple_enable);
  145.    trace_dump_member(uint, state, line_stipple_factor);
  146.    trace_dump_member(uint, state, line_stipple_pattern);
  147.    trace_dump_member(bool, state, line_last_pixel);
  148.    trace_dump_member(bool, state, flatshade_first);
  149.    trace_dump_member(bool, state, half_pixel_center);
  150.    trace_dump_member(bool, state, bottom_edge_rule);
  151.    trace_dump_member(bool, state, rasterizer_discard);
  152.    trace_dump_member(bool, state, depth_clip);
  153.    trace_dump_member(bool, state, clip_halfz);
  154.    trace_dump_member(uint, state, clip_plane_enable);
  155.  
  156.    trace_dump_member(float, state, line_width);
  157.    trace_dump_member(float, state, point_size);
  158.    trace_dump_member(float, state, offset_units);
  159.    trace_dump_member(float, state, offset_scale);
  160.    trace_dump_member(float, state, offset_clamp);
  161.  
  162.    trace_dump_struct_end();
  163. }
  164.  
  165.  
  166. void trace_dump_poly_stipple(const struct pipe_poly_stipple *state)
  167. {
  168.    if (!trace_dumping_enabled_locked())
  169.       return;
  170.  
  171.    if(!state) {
  172.       trace_dump_null();
  173.       return;
  174.    }
  175.  
  176.    trace_dump_struct_begin("pipe_poly_stipple");
  177.  
  178.    trace_dump_member_begin("stipple");
  179.    trace_dump_array(uint,
  180.                     state->stipple,
  181.                     Elements(state->stipple));
  182.    trace_dump_member_end();
  183.  
  184.    trace_dump_struct_end();
  185. }
  186.  
  187.  
  188. void trace_dump_viewport_state(const struct pipe_viewport_state *state)
  189. {
  190.    if (!trace_dumping_enabled_locked())
  191.       return;
  192.  
  193.    if(!state) {
  194.       trace_dump_null();
  195.       return;
  196.    }
  197.  
  198.    trace_dump_struct_begin("pipe_viewport_state");
  199.  
  200.    trace_dump_member_array(float, state, scale);
  201.    trace_dump_member_array(float, state, translate);
  202.  
  203.    trace_dump_struct_end();
  204. }
  205.  
  206.  
  207. void trace_dump_scissor_state(const struct pipe_scissor_state *state)
  208. {
  209.    if (!trace_dumping_enabled_locked())
  210.       return;
  211.  
  212.    if(!state) {
  213.       trace_dump_null();
  214.       return;
  215.    }
  216.  
  217.    trace_dump_struct_begin("pipe_scissor_state");
  218.  
  219.    trace_dump_member(uint, state, minx);
  220.    trace_dump_member(uint, state, miny);
  221.    trace_dump_member(uint, state, maxx);
  222.    trace_dump_member(uint, state, maxy);
  223.  
  224.    trace_dump_struct_end();
  225. }
  226.  
  227.  
  228. void trace_dump_clip_state(const struct pipe_clip_state *state)
  229. {
  230.    unsigned i;
  231.  
  232.    if (!trace_dumping_enabled_locked())
  233.       return;
  234.  
  235.    if(!state) {
  236.       trace_dump_null();
  237.       return;
  238.    }
  239.  
  240.    trace_dump_struct_begin("pipe_clip_state");
  241.  
  242.    trace_dump_member_begin("ucp");
  243.    trace_dump_array_begin();
  244.    for(i = 0; i < PIPE_MAX_CLIP_PLANES; ++i) {
  245.       trace_dump_elem_begin();
  246.       trace_dump_array(float, state->ucp[i], 4);
  247.       trace_dump_elem_end();
  248.    }
  249.    trace_dump_array_end();
  250.    trace_dump_member_end();
  251.  
  252.    trace_dump_struct_end();
  253. }
  254.  
  255.  
  256. void trace_dump_shader_state(const struct pipe_shader_state *state)
  257. {
  258.    static char str[8192];
  259.    unsigned i;
  260.  
  261.    if (!trace_dumping_enabled_locked())
  262.       return;
  263.  
  264.    if(!state) {
  265.       trace_dump_null();
  266.       return;
  267.    }
  268.  
  269.    tgsi_dump_str(state->tokens, 0, str, sizeof(str));
  270.  
  271.    trace_dump_struct_begin("pipe_shader_state");
  272.  
  273.    trace_dump_member_begin("tokens");
  274.    trace_dump_string(str);
  275.    trace_dump_member_end();
  276.  
  277.    trace_dump_member_begin("stream_output");
  278.    trace_dump_struct_begin("pipe_stream_output_info");
  279.    trace_dump_member(uint, &state->stream_output, num_outputs);
  280.    trace_dump_member_array(uint, &state->stream_output, stride);
  281.    trace_dump_member_begin("output");
  282.    trace_dump_array_begin();
  283.    for(i = 0; i < state->stream_output.num_outputs; ++i) {
  284.       trace_dump_elem_begin();
  285.       trace_dump_struct_begin(""); /* anonymous */
  286.       trace_dump_member(uint, &state->stream_output.output[i], register_index);
  287.       trace_dump_member(uint, &state->stream_output.output[i], start_component);
  288.       trace_dump_member(uint, &state->stream_output.output[i], num_components);
  289.       trace_dump_member(uint, &state->stream_output.output[i], output_buffer);
  290.       trace_dump_member(uint, &state->stream_output.output[i], dst_offset);
  291.       trace_dump_struct_end();
  292.       trace_dump_elem_end();
  293.    }
  294.    trace_dump_array_end();
  295.    trace_dump_member_end(); // output
  296.    trace_dump_struct_end();
  297.    trace_dump_member_end(); // stream_output
  298.  
  299.    trace_dump_struct_end();
  300. }
  301.  
  302.  
  303. void trace_dump_depth_stencil_alpha_state(const struct pipe_depth_stencil_alpha_state *state)
  304. {
  305.    unsigned i;
  306.  
  307.    if (!trace_dumping_enabled_locked())
  308.       return;
  309.  
  310.    if(!state) {
  311.       trace_dump_null();
  312.       return;
  313.    }
  314.  
  315.    trace_dump_struct_begin("pipe_depth_stencil_alpha_state");
  316.  
  317.    trace_dump_member_begin("depth");
  318.    trace_dump_struct_begin("pipe_depth_state");
  319.    trace_dump_member(bool, &state->depth, enabled);
  320.    trace_dump_member(bool, &state->depth, writemask);
  321.    trace_dump_member(uint, &state->depth, func);
  322.    trace_dump_struct_end();
  323.    trace_dump_member_end();
  324.  
  325.    trace_dump_member_begin("stencil");
  326.    trace_dump_array_begin();
  327.    for(i = 0; i < Elements(state->stencil); ++i) {
  328.       trace_dump_elem_begin();
  329.       trace_dump_struct_begin("pipe_stencil_state");
  330.       trace_dump_member(bool, &state->stencil[i], enabled);
  331.       trace_dump_member(uint, &state->stencil[i], func);
  332.       trace_dump_member(uint, &state->stencil[i], fail_op);
  333.       trace_dump_member(uint, &state->stencil[i], zpass_op);
  334.       trace_dump_member(uint, &state->stencil[i], zfail_op);
  335.       trace_dump_member(uint, &state->stencil[i], valuemask);
  336.       trace_dump_member(uint, &state->stencil[i], writemask);
  337.       trace_dump_struct_end();
  338.       trace_dump_elem_end();
  339.    }
  340.    trace_dump_array_end();
  341.    trace_dump_member_end();
  342.  
  343.    trace_dump_member_begin("alpha");
  344.    trace_dump_struct_begin("pipe_alpha_state");
  345.    trace_dump_member(bool, &state->alpha, enabled);
  346.    trace_dump_member(uint, &state->alpha, func);
  347.    trace_dump_member(float, &state->alpha, ref_value);
  348.    trace_dump_struct_end();
  349.    trace_dump_member_end();
  350.  
  351.    trace_dump_struct_end();
  352. }
  353.  
  354. static void trace_dump_rt_blend_state(const struct pipe_rt_blend_state *state)
  355. {
  356.    trace_dump_struct_begin("pipe_rt_blend_state");
  357.  
  358.    trace_dump_member(uint, state, blend_enable);
  359.  
  360.    trace_dump_member(uint, state, rgb_func);
  361.    trace_dump_member(uint, state, rgb_src_factor);
  362.    trace_dump_member(uint, state, rgb_dst_factor);
  363.  
  364.    trace_dump_member(uint, state, alpha_func);
  365.    trace_dump_member(uint, state, alpha_src_factor);
  366.    trace_dump_member(uint, state, alpha_dst_factor);
  367.  
  368.    trace_dump_member(uint, state, colormask);
  369.  
  370.    trace_dump_struct_end();
  371. }
  372.  
  373. void trace_dump_blend_state(const struct pipe_blend_state *state)
  374. {
  375.    unsigned valid_entries = 1;
  376.  
  377.    if (!trace_dumping_enabled_locked())
  378.       return;
  379.  
  380.    if(!state) {
  381.       trace_dump_null();
  382.       return;
  383.    }
  384.  
  385.    trace_dump_struct_begin("pipe_blend_state");
  386.  
  387.    trace_dump_member(bool, state, dither);
  388.  
  389.    trace_dump_member(bool, state, logicop_enable);
  390.    trace_dump_member(uint, state, logicop_func);
  391.  
  392.    trace_dump_member(bool, state, independent_blend_enable);
  393.  
  394.    trace_dump_member_begin("rt");
  395.    if (state->independent_blend_enable)
  396.       valid_entries = PIPE_MAX_COLOR_BUFS;
  397.    trace_dump_struct_array(rt_blend_state, state->rt, valid_entries);
  398.    trace_dump_member_end();
  399.  
  400.    trace_dump_struct_end();
  401. }
  402.  
  403.  
  404. void trace_dump_blend_color(const struct pipe_blend_color *state)
  405. {
  406.    if (!trace_dumping_enabled_locked())
  407.       return;
  408.  
  409.    if(!state) {
  410.       trace_dump_null();
  411.       return;
  412.    }
  413.  
  414.    trace_dump_struct_begin("pipe_blend_color");
  415.  
  416.    trace_dump_member_array(float, state, color);
  417.  
  418.    trace_dump_struct_end();
  419. }
  420.  
  421. void trace_dump_stencil_ref(const struct pipe_stencil_ref *state)
  422. {
  423.    if (!trace_dumping_enabled_locked())
  424.       return;
  425.  
  426.    if(!state) {
  427.       trace_dump_null();
  428.       return;
  429.    }
  430.  
  431.    trace_dump_struct_begin("pipe_stencil_ref");
  432.  
  433.    trace_dump_member_array(uint, state, ref_value);
  434.  
  435.    trace_dump_struct_end();
  436. }
  437.  
  438. void trace_dump_framebuffer_state(const struct pipe_framebuffer_state *state)
  439. {
  440.    if (!trace_dumping_enabled_locked())
  441.       return;
  442.  
  443.    trace_dump_struct_begin("pipe_framebuffer_state");
  444.  
  445.    trace_dump_member(uint, state, width);
  446.    trace_dump_member(uint, state, height);
  447.    trace_dump_member(uint, state, nr_cbufs);
  448.    trace_dump_member_array(ptr, state, cbufs);
  449.    trace_dump_member(ptr, state, zsbuf);
  450.  
  451.    trace_dump_struct_end();
  452. }
  453.  
  454.  
  455. void trace_dump_sampler_state(const struct pipe_sampler_state *state)
  456. {
  457.    if (!trace_dumping_enabled_locked())
  458.       return;
  459.  
  460.    if(!state) {
  461.       trace_dump_null();
  462.       return;
  463.    }
  464.  
  465.    trace_dump_struct_begin("pipe_sampler_state");
  466.  
  467.    trace_dump_member(uint, state, wrap_s);
  468.    trace_dump_member(uint, state, wrap_t);
  469.    trace_dump_member(uint, state, wrap_r);
  470.    trace_dump_member(uint, state, min_img_filter);
  471.    trace_dump_member(uint, state, min_mip_filter);
  472.    trace_dump_member(uint, state, mag_img_filter);
  473.    trace_dump_member(uint, state, compare_mode);
  474.    trace_dump_member(uint, state, compare_func);
  475.    trace_dump_member(bool, state, normalized_coords);
  476.    trace_dump_member(uint, state, max_anisotropy);
  477.    trace_dump_member(float, state, lod_bias);
  478.    trace_dump_member(float, state, min_lod);
  479.    trace_dump_member(float, state, max_lod);
  480.    trace_dump_member_array(float, state, border_color.f);
  481.  
  482.    trace_dump_struct_end();
  483. }
  484.  
  485.  
  486. void trace_dump_sampler_view_template(const struct pipe_sampler_view *state,
  487.                                       enum pipe_texture_target target)
  488. {
  489.    if (!trace_dumping_enabled_locked())
  490.       return;
  491.  
  492.    if(!state) {
  493.       trace_dump_null();
  494.       return;
  495.    }
  496.  
  497.    trace_dump_struct_begin("pipe_sampler_view");
  498.  
  499.    trace_dump_member(format, state, format);
  500.  
  501.    trace_dump_member_begin("u");
  502.    trace_dump_struct_begin(""); /* anonymous */
  503.    if (target == PIPE_BUFFER) {
  504.       trace_dump_member_begin("buf");
  505.       trace_dump_struct_begin(""); /* anonymous */
  506.       trace_dump_member(uint, &state->u.buf, first_element);
  507.       trace_dump_member(uint, &state->u.buf, last_element);
  508.       trace_dump_struct_end(); /* anonymous */
  509.       trace_dump_member_end(); /* buf */
  510.    } else {
  511.       trace_dump_member_begin("tex");
  512.       trace_dump_struct_begin(""); /* anonymous */
  513.       trace_dump_member(uint, &state->u.tex, first_layer);
  514.       trace_dump_member(uint, &state->u.tex, last_layer);
  515.       trace_dump_member(uint, &state->u.tex, first_level);
  516.       trace_dump_member(uint, &state->u.tex, last_level);
  517.       trace_dump_struct_end(); /* anonymous */
  518.       trace_dump_member_end(); /* tex */
  519.    }
  520.    trace_dump_struct_end(); /* anonymous */
  521.    trace_dump_member_end(); /* u */
  522.  
  523.    trace_dump_member(uint, state, swizzle_r);
  524.    trace_dump_member(uint, state, swizzle_g);
  525.    trace_dump_member(uint, state, swizzle_b);
  526.    trace_dump_member(uint, state, swizzle_a);
  527.  
  528.    trace_dump_struct_end();
  529. }
  530.  
  531.  
  532. void trace_dump_surface_template(const struct pipe_surface *state,
  533.                                  enum pipe_texture_target target)
  534. {
  535.    if (!trace_dumping_enabled_locked())
  536.       return;
  537.  
  538.    if(!state) {
  539.       trace_dump_null();
  540.       return;
  541.    }
  542.  
  543.    trace_dump_struct_begin("pipe_surface");
  544.  
  545.    trace_dump_member(format, state, format);
  546.    trace_dump_member(uint, state, width);
  547.    trace_dump_member(uint, state, height);
  548.  
  549.    trace_dump_member_begin("u");
  550.    trace_dump_struct_begin(""); /* anonymous */
  551.    if (target == PIPE_BUFFER) {
  552.       trace_dump_member_begin("buf");
  553.       trace_dump_struct_begin(""); /* anonymous */
  554.       trace_dump_member(uint, &state->u.buf, first_element);
  555.       trace_dump_member(uint, &state->u.buf, last_element);
  556.       trace_dump_struct_end(); /* anonymous */
  557.       trace_dump_member_end(); /* buf */
  558.    } else {
  559.       trace_dump_member_begin("tex");
  560.       trace_dump_struct_begin(""); /* anonymous */
  561.       trace_dump_member(uint, &state->u.tex, level);
  562.       trace_dump_member(uint, &state->u.tex, first_layer);
  563.       trace_dump_member(uint, &state->u.tex, last_layer);
  564.       trace_dump_struct_end(); /* anonymous */
  565.       trace_dump_member_end(); /* tex */
  566.    }
  567.    trace_dump_struct_end(); /* anonymous */
  568.    trace_dump_member_end(); /* u */
  569.  
  570.    trace_dump_struct_end();
  571. }
  572.  
  573.  
  574. void trace_dump_transfer(const struct pipe_transfer *state)
  575. {
  576.    if (!trace_dumping_enabled_locked())
  577.       return;
  578.  
  579.    if(!state) {
  580.       trace_dump_null();
  581.       return;
  582.    }
  583.  
  584.    trace_dump_struct_begin("pipe_transfer");
  585.  
  586.    trace_dump_member(uint, state, box.x);
  587.    trace_dump_member(uint, state, box.y);
  588.    trace_dump_member(uint, state, box.z);
  589.    trace_dump_member(uint, state, box.width);
  590.    trace_dump_member(uint, state, box.height);
  591.    trace_dump_member(uint, state, box.depth);
  592.  
  593.    trace_dump_member(uint, state, stride);
  594.    trace_dump_member(uint, state, layer_stride);
  595.    trace_dump_member(uint, state, usage);
  596.  
  597.    trace_dump_member(ptr, state, resource);
  598.  
  599.    trace_dump_struct_end();
  600. }
  601.  
  602.  
  603. void trace_dump_vertex_buffer(const struct pipe_vertex_buffer *state)
  604. {
  605.    if (!trace_dumping_enabled_locked())
  606.       return;
  607.  
  608.    if(!state) {
  609.       trace_dump_null();
  610.       return;
  611.    }
  612.  
  613.    trace_dump_struct_begin("pipe_vertex_buffer");
  614.  
  615.    trace_dump_member(uint, state, stride);
  616.    trace_dump_member(uint, state, buffer_offset);
  617.    trace_dump_member(resource_ptr, state, buffer);
  618.  
  619.    trace_dump_struct_end();
  620. }
  621.  
  622.  
  623. void trace_dump_index_buffer(const struct pipe_index_buffer *state)
  624. {
  625.    if (!trace_dumping_enabled_locked())
  626.       return;
  627.  
  628.    if(!state) {
  629.       trace_dump_null();
  630.       return;
  631.    }
  632.  
  633.    trace_dump_struct_begin("pipe_index_buffer");
  634.  
  635.    trace_dump_member(uint, state, index_size);
  636.    trace_dump_member(uint, state, offset);
  637.    trace_dump_member(resource_ptr, state, buffer);
  638.  
  639.    trace_dump_struct_end();
  640. }
  641.  
  642.  
  643. void trace_dump_vertex_element(const struct pipe_vertex_element *state)
  644. {
  645.    if (!trace_dumping_enabled_locked())
  646.       return;
  647.  
  648.    if(!state) {
  649.       trace_dump_null();
  650.       return;
  651.    }
  652.  
  653.    trace_dump_struct_begin("pipe_vertex_element");
  654.  
  655.    trace_dump_member(uint, state, src_offset);
  656.  
  657.    trace_dump_member(uint, state, vertex_buffer_index);
  658.  
  659.    trace_dump_member(format, state, src_format);
  660.  
  661.    trace_dump_struct_end();
  662. }
  663.  
  664.  
  665. void trace_dump_constant_buffer(const struct pipe_constant_buffer *state)
  666. {
  667.    if (!trace_dumping_enabled_locked())
  668.       return;
  669.  
  670.    if(!state) {
  671.       trace_dump_null();
  672.       return;
  673.    }
  674.  
  675.    trace_dump_struct_begin("pipe_constant_buffer");
  676.    trace_dump_member(ptr, state, buffer);
  677.    trace_dump_member(uint, state, buffer_offset);
  678.    trace_dump_member(uint, state, buffer_size);
  679.    trace_dump_struct_end();
  680. }
  681.  
  682.  
  683. void trace_dump_draw_info(const struct pipe_draw_info *state)
  684. {
  685.    if (!trace_dumping_enabled_locked())
  686.       return;
  687.  
  688.    if(!state) {
  689.       trace_dump_null();
  690.       return;
  691.    }
  692.  
  693.    trace_dump_struct_begin("pipe_draw_info");
  694.  
  695.    trace_dump_member(bool, state, indexed);
  696.  
  697.    trace_dump_member(uint, state, mode);
  698.    trace_dump_member(uint, state, start);
  699.    trace_dump_member(uint, state, count);
  700.  
  701.    trace_dump_member(uint, state, start_instance);
  702.    trace_dump_member(uint, state, instance_count);
  703.  
  704.    trace_dump_member(int,  state, index_bias);
  705.    trace_dump_member(uint, state, min_index);
  706.    trace_dump_member(uint, state, max_index);
  707.  
  708.    trace_dump_member(bool, state, primitive_restart);
  709.    trace_dump_member(uint, state, restart_index);
  710.  
  711.    trace_dump_member(ptr, state, count_from_stream_output);
  712.  
  713.    trace_dump_struct_end();
  714. }
  715.  
  716. void trace_dump_blit_info(const struct pipe_blit_info *info)
  717. {
  718.    char mask[7];
  719.  
  720.    if (!trace_dumping_enabled_locked())
  721.       return;
  722.  
  723.    if (!info) {
  724.       trace_dump_null();
  725.       return;
  726.    }
  727.  
  728.    trace_dump_struct_begin("pipe_blit_info");
  729.  
  730.    trace_dump_member_begin("dst");
  731.    trace_dump_struct_begin("dst");
  732.    trace_dump_member(resource_ptr, &info->dst, resource);
  733.    trace_dump_member(uint, &info->dst, level);
  734.    trace_dump_member(format, &info->dst, format);
  735.    trace_dump_member_begin("box");
  736.    trace_dump_box(&info->dst.box);
  737.    trace_dump_member_end();
  738.    trace_dump_struct_end();
  739.    trace_dump_member_end();
  740.  
  741.    trace_dump_member_begin("src");
  742.    trace_dump_struct_begin("src");
  743.    trace_dump_member(resource_ptr, &info->src, resource);
  744.    trace_dump_member(uint, &info->src, level);
  745.    trace_dump_member(format, &info->src, format);
  746.    trace_dump_member_begin("box");
  747.    trace_dump_box(&info->src.box);
  748.    trace_dump_member_end();
  749.    trace_dump_struct_end();
  750.    trace_dump_member_end();
  751.  
  752.    mask[0] = (info->mask & PIPE_MASK_R) ? 'R' : '-';
  753.    mask[1] = (info->mask & PIPE_MASK_G) ? 'G' : '-';
  754.    mask[2] = (info->mask & PIPE_MASK_B) ? 'B' : '-';
  755.    mask[3] = (info->mask & PIPE_MASK_A) ? 'A' : '-';
  756.    mask[4] = (info->mask & PIPE_MASK_Z) ? 'Z' : '-';
  757.    mask[5] = (info->mask & PIPE_MASK_S) ? 'S' : '-';
  758.    mask[6] = 0;
  759.  
  760.    trace_dump_member_begin("mask");
  761.    trace_dump_string(mask);
  762.    trace_dump_member_end();
  763.    trace_dump_member(uint, info, filter);
  764.  
  765.    trace_dump_member(bool, info, scissor_enable);
  766.    trace_dump_member_begin("scissor");
  767.    trace_dump_scissor_state(&info->scissor);
  768.    trace_dump_member_end();
  769.  
  770.    trace_dump_struct_end();
  771. }
  772.