tr_dump_state.c revision b750b9fc3d12e4c23ef74181a6252e0e054a3985
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 46void trace_dump_block(const struct pipe_format_block *block) 47{ 48 if (!trace_dumping_enabled_locked()) 49 return; 50 51 trace_dump_struct_begin("pipe_format_block"); 52 trace_dump_member(uint, block, size); 53 trace_dump_member(uint, block, width); 54 trace_dump_member(uint, block, height); 55 trace_dump_struct_end(); 56} 57 58 59static void trace_dump_reference(const struct pipe_reference *reference) 60{ 61 if (!trace_dumping_enabled_locked()) 62 return; 63 64 trace_dump_struct_begin("pipe_reference"); 65 trace_dump_member(int, &reference->count, count); 66 trace_dump_struct_end(); 67} 68 69 70void trace_dump_template(const struct pipe_texture *templat) 71{ 72 if (!trace_dumping_enabled_locked()) 73 return; 74 75 if(!templat) { 76 trace_dump_null(); 77 return; 78 } 79 80 trace_dump_struct_begin("pipe_texture"); 81 82 trace_dump_member(int, templat, target); 83 trace_dump_member(format, templat, format); 84 85 trace_dump_member_begin("width"); 86 trace_dump_array(uint, templat->width, 1); 87 trace_dump_member_end(); 88 89 trace_dump_member_begin("height"); 90 trace_dump_array(uint, templat->height, 1); 91 trace_dump_member_end(); 92 93 trace_dump_member_begin("depth"); 94 trace_dump_array(uint, templat->depth, 1); 95 trace_dump_member_end(); 96 97 trace_dump_member_begin("block"); 98 trace_dump_block(&templat->block); 99 trace_dump_member_end(); 100 101 trace_dump_member(uint, templat, last_level); 102 trace_dump_member(uint, templat, tex_usage); 103 104 trace_dump_struct_end(); 105} 106 107 108void trace_dump_rasterizer_state(const struct pipe_rasterizer_state *state) 109{ 110 if (!trace_dumping_enabled_locked()) 111 return; 112 113 if(!state) { 114 trace_dump_null(); 115 return; 116 } 117 118 trace_dump_struct_begin("pipe_rasterizer_state"); 119 120 trace_dump_member(bool, state, flatshade); 121 trace_dump_member(bool, state, light_twoside); 122 trace_dump_member(uint, state, front_winding); 123 trace_dump_member(uint, state, cull_mode); 124 trace_dump_member(uint, state, fill_cw); 125 trace_dump_member(uint, state, fill_ccw); 126 trace_dump_member(bool, state, offset_cw); 127 trace_dump_member(bool, state, offset_ccw); 128 trace_dump_member(bool, state, scissor); 129 trace_dump_member(bool, state, poly_smooth); 130 trace_dump_member(bool, state, poly_stipple_enable); 131 trace_dump_member(bool, state, point_smooth); 132 trace_dump_member(bool, state, point_sprite); 133 trace_dump_member(bool, state, point_size_per_vertex); 134 trace_dump_member(bool, state, multisample); 135 trace_dump_member(bool, state, line_smooth); 136 trace_dump_member(bool, state, line_stipple_enable); 137 trace_dump_member(uint, state, line_stipple_factor); 138 trace_dump_member(uint, state, line_stipple_pattern); 139 trace_dump_member(bool, state, line_last_pixel); 140 trace_dump_member(bool, state, bypass_vs_clip_and_viewport); 141 trace_dump_member(bool, state, flatshade_first); 142 trace_dump_member(bool, state, gl_rasterization_rules); 143 144 trace_dump_member(float, state, line_width); 145 trace_dump_member(float, state, point_size); 146 trace_dump_member(float, state, point_size_min); 147 trace_dump_member(float, state, point_size_max); 148 trace_dump_member(float, state, offset_units); 149 trace_dump_member(float, state, offset_scale); 150 151 trace_dump_member_array(uint, state, sprite_coord_mode); 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_constant_buffer(const struct pipe_constant_buffer *state) 250{ 251 if (!trace_dumping_enabled_locked()) 252 return; 253 254 if(!state) { 255 trace_dump_null(); 256 return; 257 } 258 259 trace_dump_struct_begin("pipe_constant_buffer"); 260 261 trace_dump_member(buffer_ptr, state, buffer); 262 263 trace_dump_struct_end(); 264} 265 266 267void trace_dump_shader_state(const struct pipe_shader_state *state) 268{ 269 static char str[8192]; 270 271 if (!trace_dumping_enabled_locked()) 272 return; 273 274 if(!state) { 275 trace_dump_null(); 276 return; 277 } 278 279 tgsi_dump_str(state->tokens, 0, str, sizeof(str)); 280 281 trace_dump_struct_begin("pipe_shader_state"); 282 283 trace_dump_member_begin("tokens"); 284 trace_dump_string(str); 285 trace_dump_member_end(); 286 287 trace_dump_struct_end(); 288} 289 290 291void trace_dump_depth_stencil_alpha_state(const struct pipe_depth_stencil_alpha_state *state) 292{ 293 unsigned i; 294 295 if (!trace_dumping_enabled_locked()) 296 return; 297 298 if(!state) { 299 trace_dump_null(); 300 return; 301 } 302 303 trace_dump_struct_begin("pipe_depth_stencil_alpha_state"); 304 305 trace_dump_member_begin("depth"); 306 trace_dump_struct_begin("pipe_depth_state"); 307 trace_dump_member(bool, &state->depth, enabled); 308 trace_dump_member(bool, &state->depth, writemask); 309 trace_dump_member(uint, &state->depth, func); 310 trace_dump_struct_end(); 311 trace_dump_member_end(); 312 313 trace_dump_member_begin("stencil"); 314 trace_dump_array_begin(); 315 for(i = 0; i < Elements(state->stencil); ++i) { 316 trace_dump_elem_begin(); 317 trace_dump_struct_begin("pipe_stencil_state"); 318 trace_dump_member(bool, &state->stencil[i], enabled); 319 trace_dump_member(uint, &state->stencil[i], func); 320 trace_dump_member(uint, &state->stencil[i], fail_op); 321 trace_dump_member(uint, &state->stencil[i], zpass_op); 322 trace_dump_member(uint, &state->stencil[i], zfail_op); 323 trace_dump_member(uint, &state->stencil[i], ref_value); 324 trace_dump_member(uint, &state->stencil[i], valuemask); 325 trace_dump_member(uint, &state->stencil[i], writemask); 326 trace_dump_struct_end(); 327 trace_dump_elem_end(); 328 } 329 trace_dump_array_end(); 330 trace_dump_member_end(); 331 332 trace_dump_member_begin("alpha"); 333 trace_dump_struct_begin("pipe_alpha_state"); 334 trace_dump_member(bool, &state->alpha, enabled); 335 trace_dump_member(uint, &state->alpha, func); 336 trace_dump_member(float, &state->alpha, ref_value); 337 trace_dump_struct_end(); 338 trace_dump_member_end(); 339 340 trace_dump_struct_end(); 341} 342 343 344void trace_dump_blend_state(const struct pipe_blend_state *state) 345{ 346 if (!trace_dumping_enabled_locked()) 347 return; 348 349 if(!state) { 350 trace_dump_null(); 351 return; 352 } 353 354 trace_dump_struct_begin("pipe_blend_state"); 355 356 trace_dump_member(bool, state, blend_enable); 357 358 trace_dump_member(uint, state, rgb_func); 359 trace_dump_member(uint, state, rgb_src_factor); 360 trace_dump_member(uint, state, rgb_dst_factor); 361 362 trace_dump_member(uint, state, alpha_func); 363 trace_dump_member(uint, state, alpha_src_factor); 364 trace_dump_member(uint, state, alpha_dst_factor); 365 366 trace_dump_member(bool, state, logicop_enable); 367 trace_dump_member(uint, state, logicop_func); 368 369 trace_dump_member(uint, state, colormask); 370 trace_dump_member(bool, state, dither); 371 372 trace_dump_struct_end(); 373} 374 375 376void trace_dump_blend_color(const struct pipe_blend_color *state) 377{ 378 if (!trace_dumping_enabled_locked()) 379 return; 380 381 if(!state) { 382 trace_dump_null(); 383 return; 384 } 385 386 trace_dump_struct_begin("pipe_blend_color"); 387 388 trace_dump_member_array(float, state, color); 389 390 trace_dump_struct_end(); 391} 392 393 394void trace_dump_framebuffer_state(const struct pipe_framebuffer_state *state) 395{ 396 if (!trace_dumping_enabled_locked()) 397 return; 398 399 trace_dump_struct_begin("pipe_framebuffer_state"); 400 401 trace_dump_member(uint, state, width); 402 trace_dump_member(uint, state, height); 403 trace_dump_member(uint, state, nr_cbufs); 404 trace_dump_member_array(ptr, state, cbufs); 405 trace_dump_member(ptr, state, zsbuf); 406 407 trace_dump_struct_end(); 408} 409 410 411void trace_dump_sampler_state(const struct pipe_sampler_state *state) 412{ 413 if (!trace_dumping_enabled_locked()) 414 return; 415 416 if(!state) { 417 trace_dump_null(); 418 return; 419 } 420 421 trace_dump_struct_begin("pipe_sampler_state"); 422 423 trace_dump_member(uint, state, wrap_s); 424 trace_dump_member(uint, state, wrap_t); 425 trace_dump_member(uint, state, wrap_r); 426 trace_dump_member(uint, state, min_img_filter); 427 trace_dump_member(uint, state, min_mip_filter); 428 trace_dump_member(uint, state, mag_img_filter); 429 trace_dump_member(bool, state, compare_mode); 430 trace_dump_member(uint, state, compare_func); 431 trace_dump_member(bool, state, normalized_coords); 432 trace_dump_member(uint, state, prefilter); 433 trace_dump_member(float, state, lod_bias); 434 trace_dump_member(float, state, min_lod); 435 trace_dump_member(float, state, max_lod); 436 trace_dump_member_array(float, state, border_color); 437 trace_dump_member(float, state, max_anisotropy); 438 439 trace_dump_struct_end(); 440} 441 442 443void trace_dump_surface(const struct pipe_surface *state) 444{ 445 if (!trace_dumping_enabled_locked()) 446 return; 447 448 if(!state) { 449 trace_dump_null(); 450 return; 451 } 452 453 trace_dump_struct_begin("pipe_surface"); 454 455 trace_dump_reference(&state->reference); 456 457 trace_dump_member(format, state, format); 458 trace_dump_member(uint, state, width); 459 trace_dump_member(uint, state, height); 460 461 trace_dump_member(uint, state, layout); 462 trace_dump_member(uint, state, offset); 463 trace_dump_member(uint, state, usage); 464 465 trace_dump_member(ptr, state, texture); 466 trace_dump_member(uint, state, face); 467 trace_dump_member(uint, state, level); 468 trace_dump_member(uint, state, zslice); 469 470 trace_dump_struct_end(); 471} 472 473 474void trace_dump_transfer(const struct pipe_transfer *state) 475{ 476 if (!trace_dumping_enabled_locked()) 477 return; 478 479 if(!state) { 480 trace_dump_null(); 481 return; 482 } 483 484 trace_dump_struct_begin("pipe_transfer"); 485 486 trace_dump_member(format, state, format); 487 trace_dump_member(uint, state, width); 488 trace_dump_member(uint, state, height); 489 490 trace_dump_member_begin("block"); 491 trace_dump_block(&state->block); 492 trace_dump_member_end(); 493 494 trace_dump_member(uint, state, nblocksx); 495 trace_dump_member(uint, state, nblocksy); 496 trace_dump_member(uint, state, stride); 497 trace_dump_member(uint, state, usage); 498 499 trace_dump_member(ptr, state, texture); 500 trace_dump_member(uint, state, face); 501 trace_dump_member(uint, state, level); 502 trace_dump_member(uint, state, zslice); 503 504 trace_dump_struct_end(); 505} 506 507 508void trace_dump_vertex_buffer(const struct pipe_vertex_buffer *state) 509{ 510 if (!trace_dumping_enabled_locked()) 511 return; 512 513 if(!state) { 514 trace_dump_null(); 515 return; 516 } 517 518 trace_dump_struct_begin("pipe_vertex_buffer"); 519 520 trace_dump_member(uint, state, stride); 521 trace_dump_member(uint, state, max_index); 522 trace_dump_member(uint, state, buffer_offset); 523 trace_dump_member(buffer_ptr, state, buffer); 524 525 trace_dump_struct_end(); 526} 527 528 529void trace_dump_vertex_element(const struct pipe_vertex_element *state) 530{ 531 if (!trace_dumping_enabled_locked()) 532 return; 533 534 if(!state) { 535 trace_dump_null(); 536 return; 537 } 538 539 trace_dump_struct_begin("pipe_vertex_element"); 540 541 trace_dump_member(uint, state, src_offset); 542 543 trace_dump_member(uint, state, vertex_buffer_index); 544 trace_dump_member(uint, state, nr_components); 545 546 trace_dump_member(format, state, src_format); 547 548 trace_dump_struct_end(); 549} 550