tr_dump_state.c revision cdca3c58aa2d9549f5188910e2a77b438516714f
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 324void trace_dump_blend_state(const struct pipe_blend_state *state) 325{ 326 if (!trace_dumping_enabled_locked()) 327 return; 328 329 if(!state) { 330 trace_dump_null(); 331 return; 332 } 333 334 trace_dump_bytes(state, sizeof *state); 335} 336 337 338void trace_dump_blend_color(const struct pipe_blend_color *state) 339{ 340 if (!trace_dumping_enabled_locked()) 341 return; 342 343 if(!state) { 344 trace_dump_null(); 345 return; 346 } 347 348 trace_dump_struct_begin("pipe_blend_color"); 349 350 trace_dump_member_array(float, state, color); 351 352 trace_dump_struct_end(); 353} 354 355void trace_dump_stencil_ref(const struct pipe_stencil_ref *state) 356{ 357 if (!trace_dumping_enabled_locked()) 358 return; 359 360 if(!state) { 361 trace_dump_null(); 362 return; 363 } 364 365 trace_dump_struct_begin("pipe_stencil_ref"); 366 367 trace_dump_member_array(uint, state, ref_value); 368 369 trace_dump_struct_end(); 370} 371 372void trace_dump_framebuffer_state(const struct pipe_framebuffer_state *state) 373{ 374 if (!trace_dumping_enabled_locked()) 375 return; 376 377 trace_dump_struct_begin("pipe_framebuffer_state"); 378 379 trace_dump_member(uint, state, width); 380 trace_dump_member(uint, state, height); 381 trace_dump_member(uint, state, nr_cbufs); 382 trace_dump_member_array(ptr, state, cbufs); 383 trace_dump_member(ptr, state, zsbuf); 384 385 trace_dump_struct_end(); 386} 387 388 389void trace_dump_sampler_state(const struct pipe_sampler_state *state) 390{ 391 if (!trace_dumping_enabled_locked()) 392 return; 393 394 if(!state) { 395 trace_dump_null(); 396 return; 397 } 398 399 trace_dump_struct_begin("pipe_sampler_state"); 400 401 trace_dump_member(uint, state, wrap_s); 402 trace_dump_member(uint, state, wrap_t); 403 trace_dump_member(uint, state, wrap_r); 404 trace_dump_member(uint, state, min_img_filter); 405 trace_dump_member(uint, state, min_mip_filter); 406 trace_dump_member(uint, state, mag_img_filter); 407 trace_dump_member(uint, state, compare_mode); 408 trace_dump_member(uint, state, compare_func); 409 trace_dump_member(bool, state, normalized_coords); 410 trace_dump_member(uint, state, max_anisotropy); 411 trace_dump_member(float, state, lod_bias); 412 trace_dump_member(float, state, min_lod); 413 trace_dump_member(float, state, max_lod); 414 trace_dump_member_array(float, state, border_color); 415 416 trace_dump_struct_end(); 417} 418 419 420void trace_dump_sampler_view_template(const struct pipe_sampler_view *state) 421{ 422 if (!trace_dumping_enabled_locked()) 423 return; 424 425 if(!state) { 426 trace_dump_null(); 427 return; 428 } 429 430 trace_dump_struct_begin("pipe_sampler_view"); 431 432 trace_dump_member(format, state, format); 433 /* XXX */ 434 trace_dump_member(uint, state, u.tex.first_level); 435 trace_dump_member(uint, state, u.tex.last_level); 436 trace_dump_member(uint, state, u.tex.first_layer); 437 trace_dump_member(uint, state, u.tex.last_layer); 438 trace_dump_member(uint, state, u.buf.first_element); 439 trace_dump_member(uint, state, u.buf.last_element); 440 trace_dump_member(uint, state, swizzle_r); 441 trace_dump_member(uint, state, swizzle_g); 442 trace_dump_member(uint, state, swizzle_b); 443 trace_dump_member(uint, state, swizzle_a); 444 445 trace_dump_struct_end(); 446} 447 448 449void trace_dump_surface(const struct pipe_surface *state) 450{ 451 if (!trace_dumping_enabled_locked()) 452 return; 453 454 if(!state) { 455 trace_dump_null(); 456 return; 457 } 458 459 trace_dump_struct_begin("pipe_surface"); 460 461 trace_dump_member(format, state, format); 462 trace_dump_member(uint, state, width); 463 trace_dump_member(uint, state, height); 464 465 trace_dump_member(uint, state, usage); 466 467 trace_dump_member(ptr, state, texture); 468 trace_dump_member(uint, state, u.tex.level); 469 trace_dump_member(uint, state, u.tex.first_layer); 470 trace_dump_member(uint, state, u.tex.last_layer); 471 trace_dump_member(uint, state, u.buf.first_element); 472 trace_dump_member(uint, state, u.buf.last_element); 473 474 trace_dump_struct_end(); 475} 476 477 478void trace_dump_transfer(const struct pipe_transfer *state) 479{ 480 if (!trace_dumping_enabled_locked()) 481 return; 482 483 if(!state) { 484 trace_dump_null(); 485 return; 486 } 487 488 trace_dump_struct_begin("pipe_transfer"); 489 490 trace_dump_member(uint, state, box.x); 491 trace_dump_member(uint, state, box.y); 492 trace_dump_member(uint, state, box.z); 493 trace_dump_member(uint, state, box.width); 494 trace_dump_member(uint, state, box.height); 495 trace_dump_member(uint, state, box.depth); 496 497 trace_dump_member(uint, state, stride); 498 trace_dump_member(uint, state, layer_stride); 499 trace_dump_member(uint, state, usage); 500 501 trace_dump_member(ptr, state, resource); 502 503 trace_dump_struct_end(); 504} 505 506 507void trace_dump_vertex_buffer(const struct pipe_vertex_buffer *state) 508{ 509 if (!trace_dumping_enabled_locked()) 510 return; 511 512 if(!state) { 513 trace_dump_null(); 514 return; 515 } 516 517 trace_dump_struct_begin("pipe_vertex_buffer"); 518 519 trace_dump_member(uint, state, stride); 520 trace_dump_member(uint, state, buffer_offset); 521 trace_dump_member(resource_ptr, state, buffer); 522 523 trace_dump_struct_end(); 524} 525 526 527void trace_dump_index_buffer(const struct pipe_index_buffer *state) 528{ 529 if (!trace_dumping_enabled_locked()) 530 return; 531 532 if(!state) { 533 trace_dump_null(); 534 return; 535 } 536 537 trace_dump_struct_begin("pipe_index_buffer"); 538 539 trace_dump_member(uint, state, index_size); 540 trace_dump_member(uint, state, offset); 541 trace_dump_member(resource_ptr, state, buffer); 542 543 trace_dump_struct_end(); 544} 545 546 547void trace_dump_vertex_element(const struct pipe_vertex_element *state) 548{ 549 if (!trace_dumping_enabled_locked()) 550 return; 551 552 if(!state) { 553 trace_dump_null(); 554 return; 555 } 556 557 trace_dump_struct_begin("pipe_vertex_element"); 558 559 trace_dump_member(uint, state, src_offset); 560 561 trace_dump_member(uint, state, vertex_buffer_index); 562 563 trace_dump_member(format, state, src_format); 564 565 trace_dump_struct_end(); 566} 567 568 569void trace_dump_draw_info(const struct pipe_draw_info *state) 570{ 571 if (!trace_dumping_enabled_locked()) 572 return; 573 574 if(!state) { 575 trace_dump_null(); 576 return; 577 } 578 579 trace_dump_struct_begin("pipe_draw_info"); 580 581 trace_dump_member(bool, state, indexed); 582 583 trace_dump_member(uint, state, mode); 584 trace_dump_member(uint, state, start); 585 trace_dump_member(uint, state, count); 586 587 trace_dump_member(uint, state, start_instance); 588 trace_dump_member(uint, state, instance_count); 589 590 trace_dump_member(int, state, index_bias); 591 trace_dump_member(uint, state, min_index); 592 trace_dump_member(uint, state, max_index); 593 594 trace_dump_struct_end(); 595} 596