tr_dump_state.c revision 11a981fda189515d4ea51ef1709b15e7ce90507d
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_shader_state(const struct pipe_shader_state *state) 231{ 232 static char str[8192]; 233 234 if (!trace_dumping_enabled_locked()) 235 return; 236 237 if(!state) { 238 trace_dump_null(); 239 return; 240 } 241 242 tgsi_dump_str(state->tokens, 0, str, sizeof(str)); 243 244 trace_dump_struct_begin("pipe_shader_state"); 245 246 trace_dump_member_begin("tokens"); 247 trace_dump_string(str); 248 trace_dump_member_end(); 249 250 trace_dump_struct_end(); 251} 252 253 254void trace_dump_depth_stencil_alpha_state(const struct pipe_depth_stencil_alpha_state *state) 255{ 256 unsigned i; 257 258 if (!trace_dumping_enabled_locked()) 259 return; 260 261 if(!state) { 262 trace_dump_null(); 263 return; 264 } 265 266 trace_dump_struct_begin("pipe_depth_stencil_alpha_state"); 267 268 trace_dump_member_begin("depth"); 269 trace_dump_struct_begin("pipe_depth_state"); 270 trace_dump_member(bool, &state->depth, enabled); 271 trace_dump_member(bool, &state->depth, writemask); 272 trace_dump_member(uint, &state->depth, func); 273 trace_dump_struct_end(); 274 trace_dump_member_end(); 275 276 trace_dump_member_begin("stencil"); 277 trace_dump_array_begin(); 278 for(i = 0; i < Elements(state->stencil); ++i) { 279 trace_dump_elem_begin(); 280 trace_dump_struct_begin("pipe_stencil_state"); 281 trace_dump_member(bool, &state->stencil[i], enabled); 282 trace_dump_member(uint, &state->stencil[i], func); 283 trace_dump_member(uint, &state->stencil[i], fail_op); 284 trace_dump_member(uint, &state->stencil[i], zpass_op); 285 trace_dump_member(uint, &state->stencil[i], zfail_op); 286 trace_dump_member(uint, &state->stencil[i], valuemask); 287 trace_dump_member(uint, &state->stencil[i], writemask); 288 trace_dump_struct_end(); 289 trace_dump_elem_end(); 290 } 291 trace_dump_array_end(); 292 trace_dump_member_end(); 293 294 trace_dump_member_begin("alpha"); 295 trace_dump_struct_begin("pipe_alpha_state"); 296 trace_dump_member(bool, &state->alpha, enabled); 297 trace_dump_member(uint, &state->alpha, func); 298 trace_dump_member(float, &state->alpha, ref_value); 299 trace_dump_struct_end(); 300 trace_dump_member_end(); 301 302 trace_dump_struct_end(); 303} 304 305static void trace_dump_rt_blend_state(const struct pipe_rt_blend_state *state) 306{ 307 trace_dump_struct_begin("pipe_rt_blend_state"); 308 309 trace_dump_member(uint, state, blend_enable); 310 311 trace_dump_member(uint, state, rgb_func); 312 trace_dump_member(uint, state, rgb_src_factor); 313 trace_dump_member(uint, state, rgb_dst_factor); 314 315 trace_dump_member(uint, state, alpha_func); 316 trace_dump_member(uint, state, alpha_src_factor); 317 trace_dump_member(uint, state, alpha_dst_factor); 318 319 trace_dump_member(uint, state, colormask); 320 321 trace_dump_struct_end(); 322} 323 324void trace_dump_blend_state(const struct pipe_blend_state *state) 325{ 326 unsigned valid_entries = 1; 327 328 if (!trace_dumping_enabled_locked()) 329 return; 330 331 if(!state) { 332 trace_dump_null(); 333 return; 334 } 335 336 trace_dump_struct_begin("pipe_blend_state"); 337 338 trace_dump_member(bool, state, dither); 339 340 trace_dump_member(bool, state, logicop_enable); 341 trace_dump_member(uint, state, logicop_func); 342 343 trace_dump_member(bool, state, independent_blend_enable); 344 345 trace_dump_member_begin("rt"); 346 if (state->independent_blend_enable) 347 valid_entries = PIPE_MAX_COLOR_BUFS; 348 trace_dump_struct_array(rt_blend_state, state->rt, valid_entries); 349 trace_dump_member_end(); 350 351 trace_dump_struct_end(); 352} 353 354 355void trace_dump_blend_color(const struct pipe_blend_color *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_blend_color"); 366 367 trace_dump_member_array(float, state, color); 368 369 trace_dump_struct_end(); 370} 371 372void trace_dump_stencil_ref(const struct pipe_stencil_ref *state) 373{ 374 if (!trace_dumping_enabled_locked()) 375 return; 376 377 if(!state) { 378 trace_dump_null(); 379 return; 380 } 381 382 trace_dump_struct_begin("pipe_stencil_ref"); 383 384 trace_dump_member_array(uint, state, ref_value); 385 386 trace_dump_struct_end(); 387} 388 389void trace_dump_framebuffer_state(const struct pipe_framebuffer_state *state) 390{ 391 if (!trace_dumping_enabled_locked()) 392 return; 393 394 trace_dump_struct_begin("pipe_framebuffer_state"); 395 396 trace_dump_member(uint, state, width); 397 trace_dump_member(uint, state, height); 398 trace_dump_member(uint, state, nr_cbufs); 399 trace_dump_member_array(ptr, state, cbufs); 400 trace_dump_member(ptr, state, zsbuf); 401 402 trace_dump_struct_end(); 403} 404 405 406void trace_dump_sampler_state(const struct pipe_sampler_state *state) 407{ 408 if (!trace_dumping_enabled_locked()) 409 return; 410 411 if(!state) { 412 trace_dump_null(); 413 return; 414 } 415 416 trace_dump_struct_begin("pipe_sampler_state"); 417 418 trace_dump_member(uint, state, wrap_s); 419 trace_dump_member(uint, state, wrap_t); 420 trace_dump_member(uint, state, wrap_r); 421 trace_dump_member(uint, state, min_img_filter); 422 trace_dump_member(uint, state, min_mip_filter); 423 trace_dump_member(uint, state, mag_img_filter); 424 trace_dump_member(uint, state, compare_mode); 425 trace_dump_member(uint, state, compare_func); 426 trace_dump_member(bool, state, normalized_coords); 427 trace_dump_member(uint, state, max_anisotropy); 428 trace_dump_member(float, state, lod_bias); 429 trace_dump_member(float, state, min_lod); 430 trace_dump_member(float, state, max_lod); 431 trace_dump_member_array(float, state, border_color); 432 433 trace_dump_struct_end(); 434} 435 436 437void trace_dump_surface(const struct pipe_surface *state) 438{ 439 if (!trace_dumping_enabled_locked()) 440 return; 441 442 if(!state) { 443 trace_dump_null(); 444 return; 445 } 446 447 trace_dump_struct_begin("pipe_surface"); 448 449 trace_dump_reference(&state->reference); 450 451 trace_dump_member(format, state, format); 452 trace_dump_member(uint, state, width); 453 trace_dump_member(uint, state, height); 454 455 trace_dump_member(uint, state, layout); 456 trace_dump_member(uint, state, offset); 457 trace_dump_member(uint, state, usage); 458 459 trace_dump_member(ptr, state, texture); 460 trace_dump_member(uint, state, face); 461 trace_dump_member(uint, state, level); 462 trace_dump_member(uint, state, zslice); 463 464 trace_dump_struct_end(); 465} 466 467 468void trace_dump_transfer(const struct pipe_transfer *state) 469{ 470 if (!trace_dumping_enabled_locked()) 471 return; 472 473 if(!state) { 474 trace_dump_null(); 475 return; 476 } 477 478 trace_dump_struct_begin("pipe_transfer"); 479 480 trace_dump_member(uint, state, width); 481 trace_dump_member(uint, state, height); 482 483 trace_dump_member(uint, state, stride); 484 trace_dump_member(uint, state, usage); 485 486 trace_dump_member(ptr, state, texture); 487 trace_dump_member(uint, state, face); 488 trace_dump_member(uint, state, level); 489 trace_dump_member(uint, state, zslice); 490 491 trace_dump_struct_end(); 492} 493 494 495void trace_dump_vertex_buffer(const struct pipe_vertex_buffer *state) 496{ 497 if (!trace_dumping_enabled_locked()) 498 return; 499 500 if(!state) { 501 trace_dump_null(); 502 return; 503 } 504 505 trace_dump_struct_begin("pipe_vertex_buffer"); 506 507 trace_dump_member(uint, state, stride); 508 trace_dump_member(uint, state, max_index); 509 trace_dump_member(uint, state, buffer_offset); 510 trace_dump_member(buffer_ptr, state, buffer); 511 512 trace_dump_struct_end(); 513} 514 515 516void trace_dump_vertex_element(const struct pipe_vertex_element *state) 517{ 518 if (!trace_dumping_enabled_locked()) 519 return; 520 521 if(!state) { 522 trace_dump_null(); 523 return; 524 } 525 526 trace_dump_struct_begin("pipe_vertex_element"); 527 528 trace_dump_member(uint, state, src_offset); 529 530 trace_dump_member(uint, state, vertex_buffer_index); 531 trace_dump_member(uint, state, nr_components); 532 533 trace_dump_member(format, state, src_format); 534 535 trace_dump_struct_end(); 536} 537