tr_dump_state.c revision 391f7147e73b752c6e088c4ae8fe11ddfd5fb537
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{ 458 if (!trace_dumping_enabled_locked()) 459 return; 460 461 if(!state) { 462 trace_dump_null(); 463 return; 464 } 465 466 trace_dump_struct_begin("pipe_sampler_view"); 467 468 trace_dump_member(format, state, format); 469 /* XXX */ 470 trace_dump_member(uint, state, u.tex.first_level); 471 trace_dump_member(uint, state, u.tex.last_level); 472 trace_dump_member(uint, state, u.tex.first_layer); 473 trace_dump_member(uint, state, u.tex.last_layer); 474 trace_dump_member(uint, state, u.buf.first_element); 475 trace_dump_member(uint, state, u.buf.last_element); 476 trace_dump_member(uint, state, swizzle_r); 477 trace_dump_member(uint, state, swizzle_g); 478 trace_dump_member(uint, state, swizzle_b); 479 trace_dump_member(uint, state, swizzle_a); 480 481 trace_dump_struct_end(); 482} 483 484 485void trace_dump_surface(const struct pipe_surface *state) 486{ 487 if (!trace_dumping_enabled_locked()) 488 return; 489 490 if(!state) { 491 trace_dump_null(); 492 return; 493 } 494 495 trace_dump_struct_begin("pipe_surface"); 496 497 trace_dump_member(format, state, format); 498 trace_dump_member(uint, state, width); 499 trace_dump_member(uint, state, height); 500 501 trace_dump_member(uint, state, usage); 502 503 trace_dump_member(ptr, state, texture); 504 trace_dump_member(uint, state, u.tex.level); 505 trace_dump_member(uint, state, u.tex.first_layer); 506 trace_dump_member(uint, state, u.tex.last_layer); 507 trace_dump_member(uint, state, u.buf.first_element); 508 trace_dump_member(uint, state, u.buf.last_element); 509 510 trace_dump_struct_end(); 511} 512 513 514void trace_dump_transfer(const struct pipe_transfer *state) 515{ 516 if (!trace_dumping_enabled_locked()) 517 return; 518 519 if(!state) { 520 trace_dump_null(); 521 return; 522 } 523 524 trace_dump_struct_begin("pipe_transfer"); 525 526 trace_dump_member(uint, state, box.x); 527 trace_dump_member(uint, state, box.y); 528 trace_dump_member(uint, state, box.z); 529 trace_dump_member(uint, state, box.width); 530 trace_dump_member(uint, state, box.height); 531 trace_dump_member(uint, state, box.depth); 532 533 trace_dump_member(uint, state, stride); 534 trace_dump_member(uint, state, layer_stride); 535 trace_dump_member(uint, state, usage); 536 537 trace_dump_member(ptr, state, resource); 538 539 trace_dump_struct_end(); 540} 541 542 543void trace_dump_vertex_buffer(const struct pipe_vertex_buffer *state) 544{ 545 if (!trace_dumping_enabled_locked()) 546 return; 547 548 if(!state) { 549 trace_dump_null(); 550 return; 551 } 552 553 trace_dump_struct_begin("pipe_vertex_buffer"); 554 555 trace_dump_member(uint, state, stride); 556 trace_dump_member(uint, state, buffer_offset); 557 trace_dump_member(resource_ptr, state, buffer); 558 559 trace_dump_struct_end(); 560} 561 562 563void trace_dump_index_buffer(const struct pipe_index_buffer *state) 564{ 565 if (!trace_dumping_enabled_locked()) 566 return; 567 568 if(!state) { 569 trace_dump_null(); 570 return; 571 } 572 573 trace_dump_struct_begin("pipe_index_buffer"); 574 575 trace_dump_member(uint, state, index_size); 576 trace_dump_member(uint, state, offset); 577 trace_dump_member(resource_ptr, state, buffer); 578 579 trace_dump_struct_end(); 580} 581 582 583void trace_dump_vertex_element(const struct pipe_vertex_element *state) 584{ 585 if (!trace_dumping_enabled_locked()) 586 return; 587 588 if(!state) { 589 trace_dump_null(); 590 return; 591 } 592 593 trace_dump_struct_begin("pipe_vertex_element"); 594 595 trace_dump_member(uint, state, src_offset); 596 597 trace_dump_member(uint, state, vertex_buffer_index); 598 599 trace_dump_member(format, state, src_format); 600 601 trace_dump_struct_end(); 602} 603 604 605void trace_dump_draw_info(const struct pipe_draw_info *state) 606{ 607 if (!trace_dumping_enabled_locked()) 608 return; 609 610 if(!state) { 611 trace_dump_null(); 612 return; 613 } 614 615 trace_dump_struct_begin("pipe_draw_info"); 616 617 trace_dump_member(bool, state, indexed); 618 619 trace_dump_member(uint, state, mode); 620 trace_dump_member(uint, state, start); 621 trace_dump_member(uint, state, count); 622 623 trace_dump_member(uint, state, start_instance); 624 trace_dump_member(uint, state, instance_count); 625 626 trace_dump_member(int, state, index_bias); 627 trace_dump_member(uint, state, min_index); 628 trace_dump_member(uint, state, max_index); 629 630 trace_dump_struct_end(); 631} 632