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