src/gallium/drivers/trace/tr_state.c

   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 "tgsi/tgsi_dump.h"
  31
  32 #include "tr_dump.h"
  33 #include "tr_state.h"
  34
  35
  36 void trace_dump_format(struct trace_stream *stream,
  37                        enum pipe_format format)
  38 {
  39    trace_dump_enum(stream, pf_name(format) );
  40 }
  41
  42
  43 void trace_dump_block(struct trace_stream *stream,
  44                       const struct pipe_format_block *block)
  45 {
  46    trace_dump_struct_begin(stream, "pipe_format_block");
  47    trace_dump_member(stream, uint, block, size);
  48    trace_dump_member(stream, uint, block, width);
  49    trace_dump_member(stream, uint, block, height);
  50    trace_dump_struct_end(stream);
  51 }
  52
  53
  54 void trace_dump_template(struct trace_stream *stream,
  55                          const struct pipe_texture *templat)
  56 {
  57    assert(templat);
  58    if(!templat) {
  59       trace_dump_null(stream);
  60       return;
  61    }
  62
  63    trace_dump_struct_begin(stream, "pipe_texture");
  64
  65    trace_dump_member(stream, int, templat, target);
  66    trace_dump_member(stream, format, templat, format);
  67
  68    trace_dump_member_begin(stream, "width");
  69    trace_dump_array(stream, uint, templat->width, 1);
  70    trace_dump_member_end(stream);
  71
  72    trace_dump_member_begin(stream, "height");
  73    trace_dump_array(stream, uint, templat->height, 1);
  74    trace_dump_member_end(stream);
  75
  76    trace_dump_member_begin(stream, "depth");
  77    trace_dump_array(stream, uint, templat->depth, 1);
  78    trace_dump_member_end(stream);
  79
  80    trace_dump_member_begin(stream, "block");
  81    trace_dump_block(stream, &templat->block);
  82    trace_dump_member_end(stream);
  83
  84    trace_dump_member(stream, uint, templat, last_level);
  85    trace_dump_member(stream, uint, templat, tex_usage);
  86
  87    trace_dump_struct_end(stream);
  88 }
  89
  90
  91 void trace_dump_rasterizer_state(struct trace_stream *stream,
  92                                  const struct pipe_rasterizer_state *state)
  93 {
  94    assert(state);
  95    if(!state) {
  96       trace_dump_null(stream);
  97       return;
  98    }
  99
 100    trace_dump_struct_begin(stream, "pipe_rasterizer_state");
 101
 102    trace_dump_member(stream, bool, state, flatshade);
 103    trace_dump_member(stream, bool, state, light_twoside);
 104    trace_dump_member(stream, uint, state, front_winding);
 105    trace_dump_member(stream, uint, state, cull_mode);
 106    trace_dump_member(stream, uint, state, fill_cw);
 107    trace_dump_member(stream, uint, state, fill_ccw);
 108    trace_dump_member(stream, bool, state, offset_cw);
 109    trace_dump_member(stream, bool, state, offset_ccw);
 110    trace_dump_member(stream, bool, state, scissor);
 111    trace_dump_member(stream, bool, state, poly_smooth);
 112    trace_dump_member(stream, bool, state, poly_stipple_enable);
 113    trace_dump_member(stream, bool, state, point_smooth);
 114    trace_dump_member(stream, bool, state, point_sprite);
 115    trace_dump_member(stream, bool, state, point_size_per_vertex);
 116    trace_dump_member(stream, bool, state, multisample);
 117    trace_dump_member(stream, bool, state, line_smooth);
 118    trace_dump_member(stream, bool, state, line_stipple_enable);
 119    trace_dump_member(stream, uint, state, line_stipple_factor);
 120    trace_dump_member(stream, uint, state, line_stipple_pattern);
 121    trace_dump_member(stream, bool, state, line_last_pixel);
 122    trace_dump_member(stream, bool, state, bypass_clipping);
 123    trace_dump_member(stream, bool, state, bypass_vs);
 124    trace_dump_member(stream, bool, state, origin_lower_left);
 125    trace_dump_member(stream, bool, state, flatshade_first);
 126    trace_dump_member(stream, bool, state, gl_rasterization_rules);
 127
 128    trace_dump_member(stream, float, state, line_width);
 129    trace_dump_member(stream, float, state, point_size);
 130    trace_dump_member(stream, float, state, point_size_min);
 131    trace_dump_member(stream, float, state, point_size_max);
 132    trace_dump_member(stream, float, state, offset_units);
 133    trace_dump_member(stream, float, state, offset_scale);
 134
 135    trace_dump_member_array(stream, uint, state, sprite_coord_mode);
 136
 137    trace_dump_struct_end(stream);
 138 }
 139
 140
 141 void trace_dump_poly_stipple(struct trace_stream *stream,
 142                              const struct pipe_poly_stipple *state)
 143 {
 144    assert(state);
 145    if(!state) {
 146       trace_dump_null(stream);
 147       return;
 148    }
 149
 150    trace_dump_struct_begin(stream, "pipe_poly_stipple");
 151
 152    trace_dump_member_begin(stream, "stipple");
 153    trace_dump_bytes(stream,
 154                     state->stipple,
 155                     sizeof(state->stipple));
 156    trace_dump_member_end(stream);
 157
 158    trace_dump_struct_end(stream);
 159 }
 160
 161
 162 void trace_dump_viewport_state(struct trace_stream *stream,
 163                                const struct pipe_viewport_state *state)
 164 {
 165    assert(state);
 166    if(!state) {
 167       trace_dump_null(stream);
 168       return;
 169    }
 170
 171    trace_dump_struct_begin(stream, "pipe_viewport_state");
 172
 173    trace_dump_member_array(stream, float, state, scale);
 174    trace_dump_member_array(stream, float, state, translate);
 175
 176    trace_dump_struct_end(stream);
 177 }
 178
 179
 180 void trace_dump_scissor_state(struct trace_stream *stream,
 181                               const struct pipe_scissor_state *state)
 182 {
 183    assert(state);
 184    if(!state) {
 185       trace_dump_null(stream);
 186       return;
 187    }
 188
 189    trace_dump_struct_begin(stream, "pipe_scissor_state");
 190
 191    trace_dump_member(stream, uint, state, minx);
 192    trace_dump_member(stream, uint, state, miny);
 193    trace_dump_member(stream, uint, state, maxx);
 194    trace_dump_member(stream, uint, state, maxy);
 195
 196    trace_dump_struct_end(stream);
 197 }
 198
 199
 200 void trace_dump_clip_state(struct trace_stream *stream,
 201                            const struct pipe_clip_state *state)
 202 {
 203    unsigned i;
 204
 205    assert(state);
 206    if(!state) {
 207       trace_dump_null(stream);
 208       return;
 209    }
 210
 211    trace_dump_struct_begin(stream, "pipe_scissor_state");
 212
 213    trace_dump_member_begin(stream, "ucp");
 214    trace_dump_array_begin(stream);
 215    for(i = 0; i < PIPE_MAX_CLIP_PLANES; ++i)
 216       trace_dump_array(stream, float, state->ucp[i], 4);
 217    trace_dump_array_end(stream);
 218    trace_dump_member_end(stream);
 219
 220    trace_dump_member(stream, uint, state, nr);
 221
 222    trace_dump_struct_end(stream);
 223 }
 224
 225
 226 void trace_dump_constant_buffer(struct trace_stream *stream,
 227                                 const struct pipe_constant_buffer *state)
 228 {
 229    assert(state);
 230    if(!state) {
 231       trace_dump_null(stream);
 232       return;
 233    }
 234
 235    trace_dump_struct_begin(stream, "pipe_constant_buffer");
 236
 237    trace_dump_member(stream, ptr, state, buffer);
 238    trace_dump_member(stream, uint, state, size);
 239
 240    trace_dump_struct_end(stream);
 241 }
 242
 243
 244 void trace_dump_shader_state(struct trace_stream *stream,
 245                              const struct pipe_shader_state *state)
 246 {
 247    static char str[8192];
 248    assert(state);
 249    if(!state) {
 250       trace_dump_null(stream);
 251       return;
 252    }
 253
 254    tgsi_dump_str(state->tokens, 0, str, sizeof(str));
 255
 256    trace_dump_struct_begin(stream, "pipe_shader_state");
 257
 258    trace_dump_member_begin(stream, "tokens");
 259    trace_dump_string(stream, str);
 260    trace_dump_member_end(stream);
 261
 262    trace_dump_struct_end(stream);
 263 }
 264
 265
 266 void trace_dump_depth_stencil_alpha_state(struct trace_stream *stream,
 267                                           const struct pipe_depth_stencil_alpha_state *state)
 268 {
 269    unsigned i;
 270
 271    assert(state);
 272    if(!state) {
 273       trace_dump_null(stream);
 274       return;
 275    }
 276
 277    trace_dump_struct_begin(stream, "pipe_depth_stencil_alpha_state");
 278
 279    trace_dump_member_begin(stream, "depth");
 280    trace_dump_struct_begin(stream, "pipe_depth_state");
 281    trace_dump_member(stream, bool, &state->depth, enabled);
 282    trace_dump_member(stream, bool, &state->depth, writemask);
 283    trace_dump_member(stream, uint, &state->depth, func);
 284    trace_dump_member(stream, bool, &state->depth, occlusion_count);
 285    trace_dump_struct_end(stream);
 286    trace_dump_member_end(stream);
 287
 288    trace_dump_member_begin(stream, "stencil");
 289    trace_dump_array_begin(stream);
 290    for(i = 0; i < Elements(state->stencil); ++i) {
 291       trace_dump_elem_begin(stream);
 292       trace_dump_struct_begin(stream, "pipe_stencil_state");
 293       trace_dump_member(stream, bool, &state->stencil[i], enabled);
 294       trace_dump_member(stream, uint, &state->stencil[i], func);
 295       trace_dump_member(stream, uint, &state->stencil[i], fail_op);
 296       trace_dump_member(stream, uint, &state->stencil[i], zpass_op);
 297       trace_dump_member(stream, uint, &state->stencil[i], zfail_op);
 298       trace_dump_member(stream, uint, &state->stencil[i], ref_value);
 299       trace_dump_member(stream, uint, &state->stencil[i], value_mask);
 300       trace_dump_member(stream, uint, &state->stencil[i], write_mask);
 301       trace_dump_struct_end(stream);
 302       trace_dump_elem_end(stream);
 303    }
 304    trace_dump_array_end(stream);
 305    trace_dump_member_end(stream);
 306
 307    trace_dump_member_begin(stream, "alpha");
 308    trace_dump_struct_begin(stream, "pipe_alpha_state");
 309    trace_dump_member(stream, bool, &state->alpha, enabled);
 310    trace_dump_member(stream, uint, &state->alpha, func);
 311    trace_dump_member(stream, float, &state->alpha, ref);
 312    trace_dump_struct_end(stream);
 313    trace_dump_member_end(stream);
 314
 315    trace_dump_struct_end(stream);
 316 }
 317
 318
 319 void trace_dump_blend_state(struct trace_stream *stream,
 320                             const struct pipe_blend_state *state)
 321 {
 322    assert(state);
 323    if(!state) {
 324       trace_dump_null(stream);
 325       return;
 326    }
 327
 328    trace_dump_struct_begin(stream, "pipe_blend_state");
 329
 330    trace_dump_member(stream, bool, state, blend_enable);
 331
 332    trace_dump_member(stream, uint, state, rgb_func);
 333    trace_dump_member(stream, uint, state, rgb_src_factor);
 334    trace_dump_member(stream, uint, state, rgb_dst_factor);
 335
 336    trace_dump_member(stream, uint, state, alpha_func);
 337    trace_dump_member(stream, uint, state, alpha_src_factor);
 338    trace_dump_member(stream, uint, state, alpha_dst_factor);
 339
 340    trace_dump_member(stream, bool, state, logicop_enable);
 341    trace_dump_member(stream, uint, state, logicop_func);
 342
 343    trace_dump_member(stream, uint, state, colormask);
 344    trace_dump_member(stream, bool, state, dither);
 345
 346    trace_dump_struct_end(stream);
 347 }
 348
 349
 350 void trace_dump_blend_color(struct trace_stream *stream,
 351                             const struct pipe_blend_color *state)
 352 {
 353    assert(state);
 354    if(!state) {
 355       trace_dump_null(stream);
 356       return;
 357    }
 358
 359    trace_dump_struct_begin(stream, "pipe_blend_color");
 360
 361    trace_dump_member_array(stream, float, state, color);
 362
 363    trace_dump_struct_end(stream);
 364 }
 365
 366
 367 void trace_dump_framebuffer_state(struct trace_stream *stream,
 368                                   const struct pipe_framebuffer_state *state)
 369 {
 370    trace_dump_struct_begin(stream, "pipe_framebuffer_state");
 371
 372    trace_dump_member(stream, uint, state, width);
 373    trace_dump_member(stream, uint, state, height);
 374    trace_dump_member(stream, uint, state, num_cbufs);
 375    trace_dump_member_array(stream, ptr, state, cbufs);
 376    trace_dump_member(stream, ptr, state, zsbuf);
 377
 378    trace_dump_struct_end(stream);
 379 }
 380
 381
 382 void trace_dump_sampler_state(struct trace_stream *stream,
 383                               const struct pipe_sampler_state *state)
 384 {
 385    assert(state);
 386    if(!state) {
 387       trace_dump_null(stream);
 388       return;
 389    }
 390
 391    trace_dump_struct_begin(stream, "pipe_sampler_state");
 392
 393    trace_dump_member(stream, uint, state, wrap_s);
 394    trace_dump_member(stream, uint, state, wrap_t);
 395    trace_dump_member(stream, uint, state, wrap_r);
 396    trace_dump_member(stream, uint, state, min_img_filter);
 397    trace_dump_member(stream, uint, state, min_mip_filter);
 398    trace_dump_member(stream, uint, state, mag_img_filter);
 399    trace_dump_member(stream, bool, state, compare_mode);
 400    trace_dump_member(stream, uint, state, compare_func);
 401    trace_dump_member(stream, bool, state, normalized_coords);
 402    trace_dump_member(stream, uint, state, prefilter);
 403    trace_dump_member(stream, float, state, shadow_ambient);
 404    trace_dump_member(stream, float, state, lod_bias);
 405    trace_dump_member(stream, float, state, min_lod);
 406    trace_dump_member(stream, float, state, max_lod);
 407    trace_dump_member_array(stream, float, state, border_color);
 408    trace_dump_member(stream, float, state, max_anisotropy);
 409
 410    trace_dump_struct_end(stream);
 411 }
 412
 413
 414 void trace_dump_surface(struct trace_stream *stream,
 415                         const struct pipe_surface *state)
 416 {
 417    assert(state);
 418    if(!state) {
 419       trace_dump_null(stream);
 420       return;
 421    }
 422
 423    trace_dump_struct_begin(stream, "pipe_surface");
 424
 425    trace_dump_member(stream, ptr, state, buffer);
 426    trace_dump_member(stream, format, state, format);
 427    trace_dump_member(stream, uint, state, status);
 428    trace_dump_member(stream, uint, state, clear_value);
 429    trace_dump_member(stream, uint, state, width);
 430    trace_dump_member(stream, uint, state, height);
 431
 432    trace_dump_member_begin(stream, "block");
 433    trace_dump_block(stream, &state->block);
 434    trace_dump_member_end(stream);
 435
 436    trace_dump_member(stream, uint, state, nblocksx);
 437    trace_dump_member(stream, uint, state, nblocksy);
 438    trace_dump_member(stream, uint, state, stride);
 439    trace_dump_member(stream, uint, state, layout);
 440    trace_dump_member(stream, uint, state, offset);
 441    trace_dump_member(stream, uint, state, refcount);
 442    trace_dump_member(stream, uint, state, usage);
 443
 444    trace_dump_member(stream, ptr, state, texture);
 445    trace_dump_member(stream, uint, state, face);
 446    trace_dump_member(stream, uint, state, level);
 447    trace_dump_member(stream, uint, state, zslice);
 448
 449    trace_dump_struct_end(stream);
 450 }
 451
 452
 453 void trace_dump_vertex_buffer(struct trace_stream *stream,
 454                               const struct pipe_vertex_buffer *state)
 455 {
 456    assert(state);
 457    if(!state) {
 458       trace_dump_null(stream);
 459       return;
 460    }
 461
 462    trace_dump_struct_begin(stream, "pipe_vertex_buffer");
 463
 464    trace_dump_member(stream, uint, state, pitch);
 465    trace_dump_member(stream, uint, state, max_index);
 466    trace_dump_member(stream, uint, state, buffer_offset);
 467    trace_dump_member(stream, ptr, state, buffer);
 468
 469    trace_dump_struct_end(stream);
 470 }
 471
 472
 473 void trace_dump_vertex_element(struct trace_stream *stream,
 474                                const struct pipe_vertex_element *state)
 475 {
 476    assert(state);
 477    if(!state) {
 478       trace_dump_null(stream);
 479       return;
 480    }
 481
 482    trace_dump_struct_begin(stream, "pipe_vertex_element");
 483
 484    trace_dump_member(stream, uint, state, src_offset);
 485
 486    trace_dump_member(stream, uint, state, vertex_buffer_index);
 487    trace_dump_member(stream, uint, state, nr_components);
 488
 489    trace_dump_member(stream, format, state, src_format);
 490
 491    trace_dump_struct_end(stream);
 492 }