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