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