1 /************************************************************************** 2 * 3 * Copyright 2010 VMware, Inc. 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 VMWARE 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_context.h" 30 #include "util/u_memory.h" 31 #include "util/u_inlines.h" 32 #include "util/simple_list.h" 33 34 #include "rbug/rbug_context.h" 35 36 #include "rbug_context.h" 37 #include "rbug_objects.h" 38 39 40 static void 41 rbug_destroy(struct pipe_context *_pipe) 42 { 43 struct rbug_screen *rb_screen = rbug_screen(_pipe->screen); 44 struct rbug_context *rb_pipe = rbug_context(_pipe); 45 struct pipe_context *pipe = rb_pipe->pipe; 46 47 rbug_screen_remove_from_list(rb_screen, contexts, rb_pipe); 48 49 pipe_mutex_lock(rb_pipe->call_mutex); 50 pipe->destroy(pipe); 51 rb_pipe->pipe = NULL; 52 pipe_mutex_unlock(rb_pipe->call_mutex); 53 54 FREE(rb_pipe); 55 } 56 57 static void 58 rbug_draw_block_locked(struct rbug_context *rb_pipe, int flag) 59 { 60 61 if (rb_pipe->draw_blocker & flag) { 62 rb_pipe->draw_blocked |= flag; 63 } else if ((rb_pipe->draw_rule.blocker & flag) && 64 (rb_pipe->draw_blocker & RBUG_BLOCK_RULE)) { 65 unsigned k; 66 boolean block = FALSE; 67 unsigned sh; 68 69 debug_printf("%s (%p %p) (%p %p) (%p %u) (%p %u)\n", __FUNCTION__, 70 (void *) rb_pipe->draw_rule.shader[PIPE_SHADER_FRAGMENT], 71 (void *) rb_pipe->curr.shader[PIPE_SHADER_FRAGMENT], 72 (void *) rb_pipe->draw_rule.shader[PIPE_SHADER_VERTEX], 73 (void *) rb_pipe->curr.shader[PIPE_SHADER_VERTEX], 74 (void *) rb_pipe->draw_rule.surf, 0, 75 (void *) rb_pipe->draw_rule.texture, 0); 76 for (sh = 0; sh < PIPE_SHADER_TYPES; sh++) { 77 if (rb_pipe->draw_rule.shader[sh] && 78 rb_pipe->draw_rule.shader[sh] == rb_pipe->curr.shader[sh]) 79 block = TRUE; 80 } 81 82 if (rb_pipe->draw_rule.surf && 83 rb_pipe->draw_rule.surf == rb_pipe->curr.zsbuf) 84 block = TRUE; 85 if (rb_pipe->draw_rule.surf) 86 for (k = 0; k < rb_pipe->curr.nr_cbufs; k++) 87 if (rb_pipe->draw_rule.surf == rb_pipe->curr.cbufs[k]) 88 block = TRUE; 89 if (rb_pipe->draw_rule.texture) { 90 for (sh = 0; sh < ARRAY_SIZE(rb_pipe->curr.num_views); sh++) { 91 for (k = 0; k < rb_pipe->curr.num_views[sh]; k++) { 92 if (rb_pipe->draw_rule.texture == rb_pipe->curr.texs[sh][k]) { 93 block = TRUE; 94 sh = PIPE_SHADER_TYPES; /* to break out of both loops */ 95 break; 96 } 97 } 98 } 99 } 100 101 if (block) 102 rb_pipe->draw_blocked |= (flag | RBUG_BLOCK_RULE); 103 } 104 105 if (rb_pipe->draw_blocked) 106 rbug_notify_draw_blocked(rb_pipe); 107 108 /* wait for rbug to clear the blocked flag */ 109 while (rb_pipe->draw_blocked & flag) { 110 rb_pipe->draw_blocked |= flag; 111 pipe_condvar_wait(rb_pipe->draw_cond, rb_pipe->draw_mutex); 112 } 113 114 } 115 116 static void 117 rbug_draw_vbo(struct pipe_context *_pipe, const struct pipe_draw_info *info) 118 { 119 struct rbug_context *rb_pipe = rbug_context(_pipe); 120 struct pipe_context *pipe = rb_pipe->pipe; 121 122 pipe_mutex_lock(rb_pipe->draw_mutex); 123 rbug_draw_block_locked(rb_pipe, RBUG_BLOCK_BEFORE); 124 125 pipe_mutex_lock(rb_pipe->call_mutex); 126 /* XXX loop over PIPE_SHADER_x here */ 127 if (!(rb_pipe->curr.shader[PIPE_SHADER_FRAGMENT] && rb_pipe->curr.shader[PIPE_SHADER_FRAGMENT]->disabled) && 128 !(rb_pipe->curr.shader[PIPE_SHADER_GEOMETRY] && rb_pipe->curr.shader[PIPE_SHADER_GEOMETRY]->disabled) && 129 !(rb_pipe->curr.shader[PIPE_SHADER_VERTEX] && rb_pipe->curr.shader[PIPE_SHADER_VERTEX]->disabled)) 130 pipe->draw_vbo(pipe, info); 131 pipe_mutex_unlock(rb_pipe->call_mutex); 132 133 rbug_draw_block_locked(rb_pipe, RBUG_BLOCK_AFTER); 134 pipe_mutex_unlock(rb_pipe->draw_mutex); 135 } 136 137 static struct pipe_query * 138 rbug_create_query(struct pipe_context *_pipe, 139 unsigned query_type, 140 unsigned index) 141 { 142 struct rbug_context *rb_pipe = rbug_context(_pipe); 143 struct pipe_context *pipe = rb_pipe->pipe; 144 struct pipe_query *query; 145 146 pipe_mutex_lock(rb_pipe->call_mutex); 147 query = pipe->create_query(pipe, 148 query_type, 149 index); 150 pipe_mutex_unlock(rb_pipe->call_mutex); 151 return query; 152 } 153 154 static void 155 rbug_destroy_query(struct pipe_context *_pipe, 156 struct pipe_query *query) 157 { 158 struct rbug_context *rb_pipe = rbug_context(_pipe); 159 struct pipe_context *pipe = rb_pipe->pipe; 160 161 pipe_mutex_lock(rb_pipe->call_mutex); 162 pipe->destroy_query(pipe, 163 query); 164 pipe_mutex_unlock(rb_pipe->call_mutex); 165 } 166 167 static boolean 168 rbug_begin_query(struct pipe_context *_pipe, 169 struct pipe_query *query) 170 { 171 struct rbug_context *rb_pipe = rbug_context(_pipe); 172 struct pipe_context *pipe = rb_pipe->pipe; 173 boolean ret; 174 175 pipe_mutex_lock(rb_pipe->call_mutex); 176 ret = pipe->begin_query(pipe, query); 177 pipe_mutex_unlock(rb_pipe->call_mutex); 178 return ret; 179 } 180 181 static bool 182 rbug_end_query(struct pipe_context *_pipe, 183 struct pipe_query *query) 184 { 185 struct rbug_context *rb_pipe = rbug_context(_pipe); 186 struct pipe_context *pipe = rb_pipe->pipe; 187 bool ret; 188 189 pipe_mutex_lock(rb_pipe->call_mutex); 190 ret = pipe->end_query(pipe, 191 query); 192 pipe_mutex_unlock(rb_pipe->call_mutex); 193 194 return ret; 195 } 196 197 static boolean 198 rbug_get_query_result(struct pipe_context *_pipe, 199 struct pipe_query *query, 200 boolean wait, 201 union pipe_query_result *result) 202 { 203 struct rbug_context *rb_pipe = rbug_context(_pipe); 204 struct pipe_context *pipe = rb_pipe->pipe; 205 boolean ret; 206 207 pipe_mutex_lock(rb_pipe->call_mutex); 208 ret = pipe->get_query_result(pipe, 209 query, 210 wait, 211 result); 212 pipe_mutex_unlock(rb_pipe->call_mutex); 213 214 return ret; 215 } 216 217 static void 218 rbug_set_active_query_state(struct pipe_context *_pipe, boolean enable) 219 { 220 struct rbug_context *rb_pipe = rbug_context(_pipe); 221 struct pipe_context *pipe = rb_pipe->pipe; 222 223 pipe_mutex_lock(rb_pipe->call_mutex); 224 pipe->set_active_query_state(pipe, enable); 225 pipe_mutex_unlock(rb_pipe->call_mutex); 226 } 227 228 static void * 229 rbug_create_blend_state(struct pipe_context *_pipe, 230 const struct pipe_blend_state *blend) 231 { 232 struct rbug_context *rb_pipe = rbug_context(_pipe); 233 struct pipe_context *pipe = rb_pipe->pipe; 234 void *ret; 235 236 pipe_mutex_lock(rb_pipe->call_mutex); 237 ret = pipe->create_blend_state(pipe, 238 blend); 239 pipe_mutex_unlock(rb_pipe->call_mutex); 240 241 return ret; 242 } 243 244 static void 245 rbug_bind_blend_state(struct pipe_context *_pipe, 246 void *blend) 247 { 248 struct rbug_context *rb_pipe = rbug_context(_pipe); 249 struct pipe_context *pipe = rb_pipe->pipe; 250 251 pipe_mutex_lock(rb_pipe->call_mutex); 252 pipe->bind_blend_state(pipe, 253 blend); 254 pipe_mutex_unlock(rb_pipe->call_mutex); 255 } 256 257 static void 258 rbug_delete_blend_state(struct pipe_context *_pipe, 259 void *blend) 260 { 261 struct rbug_context *rb_pipe = rbug_context(_pipe); 262 struct pipe_context *pipe = rb_pipe->pipe; 263 264 pipe_mutex_lock(rb_pipe->call_mutex); 265 pipe->delete_blend_state(pipe, 266 blend); 267 pipe_mutex_unlock(rb_pipe->call_mutex); 268 } 269 270 static void * 271 rbug_create_sampler_state(struct pipe_context *_pipe, 272 const struct pipe_sampler_state *sampler) 273 { 274 struct rbug_context *rb_pipe = rbug_context(_pipe); 275 struct pipe_context *pipe = rb_pipe->pipe; 276 void *ret; 277 278 pipe_mutex_lock(rb_pipe->call_mutex); 279 ret = pipe->create_sampler_state(pipe, 280 sampler); 281 pipe_mutex_unlock(rb_pipe->call_mutex); 282 283 return ret; 284 } 285 286 static void 287 rbug_bind_sampler_states(struct pipe_context *_pipe, 288 enum pipe_shader_type shader, 289 unsigned start, unsigned count, 290 void **samplers) 291 { 292 struct rbug_context *rb_pipe = rbug_context(_pipe); 293 struct pipe_context *pipe = rb_pipe->pipe; 294 295 pipe_mutex_lock(rb_pipe->call_mutex); 296 pipe->bind_sampler_states(pipe, shader, start, count, samplers); 297 pipe_mutex_unlock(rb_pipe->call_mutex); 298 } 299 300 static void 301 rbug_delete_sampler_state(struct pipe_context *_pipe, 302 void *sampler) 303 { 304 struct rbug_context *rb_pipe = rbug_context(_pipe); 305 struct pipe_context *pipe = rb_pipe->pipe; 306 307 pipe_mutex_lock(rb_pipe->call_mutex); 308 pipe->delete_sampler_state(pipe, 309 sampler); 310 pipe_mutex_unlock(rb_pipe->call_mutex); 311 } 312 313 static void * 314 rbug_create_rasterizer_state(struct pipe_context *_pipe, 315 const struct pipe_rasterizer_state *rasterizer) 316 { 317 struct rbug_context *rb_pipe = rbug_context(_pipe); 318 struct pipe_context *pipe = rb_pipe->pipe; 319 void *ret; 320 321 pipe_mutex_lock(rb_pipe->call_mutex); 322 ret = pipe->create_rasterizer_state(pipe, 323 rasterizer); 324 pipe_mutex_unlock(rb_pipe->call_mutex); 325 326 return ret; 327 } 328 329 static void 330 rbug_bind_rasterizer_state(struct pipe_context *_pipe, 331 void *rasterizer) 332 { 333 struct rbug_context *rb_pipe = rbug_context(_pipe); 334 struct pipe_context *pipe = rb_pipe->pipe; 335 336 pipe_mutex_lock(rb_pipe->call_mutex); 337 pipe->bind_rasterizer_state(pipe, 338 rasterizer); 339 pipe_mutex_unlock(rb_pipe->call_mutex); 340 } 341 342 static void 343 rbug_delete_rasterizer_state(struct pipe_context *_pipe, 344 void *rasterizer) 345 { 346 struct rbug_context *rb_pipe = rbug_context(_pipe); 347 struct pipe_context *pipe = rb_pipe->pipe; 348 349 pipe_mutex_lock(rb_pipe->call_mutex); 350 pipe->delete_rasterizer_state(pipe, 351 rasterizer); 352 pipe_mutex_unlock(rb_pipe->call_mutex); 353 } 354 355 static void * 356 rbug_create_depth_stencil_alpha_state(struct pipe_context *_pipe, 357 const struct pipe_depth_stencil_alpha_state *depth_stencil_alpha) 358 { 359 struct rbug_context *rb_pipe = rbug_context(_pipe); 360 struct pipe_context *pipe = rb_pipe->pipe; 361 void *ret; 362 363 pipe_mutex_lock(rb_pipe->call_mutex); 364 ret = pipe->create_depth_stencil_alpha_state(pipe, 365 depth_stencil_alpha); 366 pipe_mutex_unlock(rb_pipe->call_mutex); 367 368 return ret; 369 } 370 371 static void 372 rbug_bind_depth_stencil_alpha_state(struct pipe_context *_pipe, 373 void *depth_stencil_alpha) 374 { 375 struct rbug_context *rb_pipe = rbug_context(_pipe); 376 struct pipe_context *pipe = rb_pipe->pipe; 377 378 pipe_mutex_lock(rb_pipe->call_mutex); 379 pipe->bind_depth_stencil_alpha_state(pipe, 380 depth_stencil_alpha); 381 pipe_mutex_unlock(rb_pipe->call_mutex); 382 } 383 384 static void 385 rbug_delete_depth_stencil_alpha_state(struct pipe_context *_pipe, 386 void *depth_stencil_alpha) 387 { 388 struct rbug_context *rb_pipe = rbug_context(_pipe); 389 struct pipe_context *pipe = rb_pipe->pipe; 390 391 pipe_mutex_lock(rb_pipe->call_mutex); 392 pipe->delete_depth_stencil_alpha_state(pipe, 393 depth_stencil_alpha); 394 pipe_mutex_unlock(rb_pipe->call_mutex); 395 } 396 397 static void * 398 rbug_create_fs_state(struct pipe_context *_pipe, 399 const struct pipe_shader_state *state) 400 { 401 struct rbug_context *rb_pipe = rbug_context(_pipe); 402 struct pipe_context *pipe = rb_pipe->pipe; 403 void *result; 404 405 pipe_mutex_lock(rb_pipe->call_mutex); 406 result = pipe->create_fs_state(pipe, state); 407 pipe_mutex_unlock(rb_pipe->call_mutex); 408 409 if (!result) 410 return NULL; 411 412 return rbug_shader_create(rb_pipe, state, result, RBUG_SHADER_FRAGMENT); 413 } 414 415 static void 416 rbug_bind_fs_state(struct pipe_context *_pipe, 417 void *_fs) 418 { 419 struct rbug_context *rb_pipe = rbug_context(_pipe); 420 struct pipe_context *pipe = rb_pipe->pipe; 421 void *fs; 422 423 pipe_mutex_lock(rb_pipe->call_mutex); 424 425 fs = rbug_shader_unwrap(_fs); 426 rb_pipe->curr.shader[PIPE_SHADER_FRAGMENT] = rbug_shader(_fs); 427 pipe->bind_fs_state(pipe, 428 fs); 429 430 pipe_mutex_unlock(rb_pipe->call_mutex); 431 } 432 433 static void 434 rbug_delete_fs_state(struct pipe_context *_pipe, 435 void *_fs) 436 { 437 struct rbug_context *rb_pipe = rbug_context(_pipe); 438 struct rbug_shader *rb_shader = rbug_shader(_fs); 439 440 pipe_mutex_lock(rb_pipe->call_mutex); 441 rbug_shader_destroy(rb_pipe, rb_shader); 442 pipe_mutex_unlock(rb_pipe->call_mutex); 443 } 444 445 static void * 446 rbug_create_vs_state(struct pipe_context *_pipe, 447 const struct pipe_shader_state *state) 448 { 449 struct rbug_context *rb_pipe = rbug_context(_pipe); 450 struct pipe_context *pipe = rb_pipe->pipe; 451 void *result; 452 453 pipe_mutex_lock(rb_pipe->call_mutex); 454 result = pipe->create_vs_state(pipe, state); 455 pipe_mutex_unlock(rb_pipe->call_mutex); 456 457 if (!result) 458 return NULL; 459 460 return rbug_shader_create(rb_pipe, state, result, RBUG_SHADER_VERTEX); 461 } 462 463 static void 464 rbug_bind_vs_state(struct pipe_context *_pipe, 465 void *_vs) 466 { 467 struct rbug_context *rb_pipe = rbug_context(_pipe); 468 struct pipe_context *pipe = rb_pipe->pipe; 469 void *vs; 470 471 pipe_mutex_lock(rb_pipe->call_mutex); 472 473 vs = rbug_shader_unwrap(_vs); 474 rb_pipe->curr.shader[PIPE_SHADER_VERTEX] = rbug_shader(_vs); 475 pipe->bind_vs_state(pipe, 476 vs); 477 478 pipe_mutex_unlock(rb_pipe->call_mutex); 479 } 480 481 static void 482 rbug_delete_vs_state(struct pipe_context *_pipe, 483 void *_vs) 484 { 485 struct rbug_context *rb_pipe = rbug_context(_pipe); 486 struct rbug_shader *rb_shader = rbug_shader(_vs); 487 488 pipe_mutex_unlock(rb_pipe->call_mutex); 489 rbug_shader_destroy(rb_pipe, rb_shader); 490 pipe_mutex_unlock(rb_pipe->call_mutex); 491 } 492 493 static void * 494 rbug_create_gs_state(struct pipe_context *_pipe, 495 const struct pipe_shader_state *state) 496 { 497 struct rbug_context *rb_pipe = rbug_context(_pipe); 498 struct pipe_context *pipe = rb_pipe->pipe; 499 void *result; 500 501 pipe_mutex_lock(rb_pipe->call_mutex); 502 result = pipe->create_gs_state(pipe, state); 503 pipe_mutex_unlock(rb_pipe->call_mutex); 504 505 if (!result) 506 return NULL; 507 508 return rbug_shader_create(rb_pipe, state, result, RBUG_SHADER_GEOM); 509 } 510 511 static void 512 rbug_bind_gs_state(struct pipe_context *_pipe, 513 void *_gs) 514 { 515 struct rbug_context *rb_pipe = rbug_context(_pipe); 516 struct pipe_context *pipe = rb_pipe->pipe; 517 void *gs; 518 519 pipe_mutex_lock(rb_pipe->call_mutex); 520 521 gs = rbug_shader_unwrap(_gs); 522 rb_pipe->curr.shader[PIPE_SHADER_GEOMETRY] = rbug_shader(_gs); 523 pipe->bind_gs_state(pipe, 524 gs); 525 526 pipe_mutex_unlock(rb_pipe->call_mutex); 527 } 528 529 static void 530 rbug_delete_gs_state(struct pipe_context *_pipe, 531 void *_gs) 532 { 533 struct rbug_context *rb_pipe = rbug_context(_pipe); 534 struct rbug_shader *rb_shader = rbug_shader(_gs); 535 536 pipe_mutex_lock(rb_pipe->call_mutex); 537 rbug_shader_destroy(rb_pipe, rb_shader); 538 pipe_mutex_unlock(rb_pipe->call_mutex); 539 } 540 541 static void * 542 rbug_create_vertex_elements_state(struct pipe_context *_pipe, 543 unsigned num_elements, 544 const struct pipe_vertex_element *vertex_elements) 545 { 546 struct rbug_context *rb_pipe = rbug_context(_pipe); 547 struct pipe_context *pipe = rb_pipe->pipe; 548 void *ret; 549 550 pipe_mutex_lock(rb_pipe->call_mutex); 551 ret = pipe->create_vertex_elements_state(pipe, 552 num_elements, 553 vertex_elements); 554 pipe_mutex_unlock(rb_pipe->call_mutex); 555 556 return ret; 557 } 558 559 static void 560 rbug_bind_vertex_elements_state(struct pipe_context *_pipe, 561 void *velems) 562 { 563 struct rbug_context *rb_pipe = rbug_context(_pipe); 564 struct pipe_context *pipe = rb_pipe->pipe; 565 566 pipe_mutex_lock(rb_pipe->call_mutex); 567 pipe->bind_vertex_elements_state(pipe, 568 velems); 569 pipe_mutex_unlock(rb_pipe->call_mutex); 570 } 571 572 static void 573 rbug_delete_vertex_elements_state(struct pipe_context *_pipe, 574 void *velems) 575 { 576 struct rbug_context *rb_pipe = rbug_context(_pipe); 577 struct pipe_context *pipe = rb_pipe->pipe; 578 579 pipe_mutex_lock(rb_pipe->call_mutex); 580 pipe->delete_vertex_elements_state(pipe, 581 velems); 582 pipe_mutex_unlock(rb_pipe->call_mutex); 583 } 584 585 static void 586 rbug_set_blend_color(struct pipe_context *_pipe, 587 const struct pipe_blend_color *blend_color) 588 { 589 struct rbug_context *rb_pipe = rbug_context(_pipe); 590 struct pipe_context *pipe = rb_pipe->pipe; 591 592 pipe_mutex_lock(rb_pipe->call_mutex); 593 pipe->set_blend_color(pipe, 594 blend_color); 595 pipe_mutex_unlock(rb_pipe->call_mutex); 596 } 597 598 static void 599 rbug_set_stencil_ref(struct pipe_context *_pipe, 600 const struct pipe_stencil_ref *stencil_ref) 601 { 602 struct rbug_context *rb_pipe = rbug_context(_pipe); 603 struct pipe_context *pipe = rb_pipe->pipe; 604 605 pipe_mutex_lock(rb_pipe->call_mutex); 606 pipe->set_stencil_ref(pipe, 607 stencil_ref); 608 pipe_mutex_unlock(rb_pipe->call_mutex); 609 } 610 611 static void 612 rbug_set_clip_state(struct pipe_context *_pipe, 613 const struct pipe_clip_state *clip) 614 { 615 struct rbug_context *rb_pipe = rbug_context(_pipe); 616 struct pipe_context *pipe = rb_pipe->pipe; 617 618 pipe_mutex_lock(rb_pipe->call_mutex); 619 pipe->set_clip_state(pipe, 620 clip); 621 pipe_mutex_unlock(rb_pipe->call_mutex); 622 } 623 624 static void 625 rbug_set_constant_buffer(struct pipe_context *_pipe, 626 uint shader, 627 uint index, 628 const struct pipe_constant_buffer *_cb) 629 { 630 struct rbug_context *rb_pipe = rbug_context(_pipe); 631 struct pipe_context *pipe = rb_pipe->pipe; 632 struct pipe_constant_buffer cb; 633 634 /* XXX hmm? unwrap the input state */ 635 if (_cb) { 636 cb = *_cb; 637 cb.buffer = rbug_resource_unwrap(_cb->buffer); 638 } 639 640 pipe_mutex_lock(rb_pipe->call_mutex); 641 pipe->set_constant_buffer(pipe, 642 shader, 643 index, 644 _cb ? &cb : NULL); 645 pipe_mutex_unlock(rb_pipe->call_mutex); 646 } 647 648 static void 649 rbug_set_framebuffer_state(struct pipe_context *_pipe, 650 const struct pipe_framebuffer_state *_state) 651 { 652 struct rbug_context *rb_pipe = rbug_context(_pipe); 653 struct pipe_context *pipe = rb_pipe->pipe; 654 struct pipe_framebuffer_state unwrapped_state; 655 struct pipe_framebuffer_state *state = NULL; 656 unsigned i; 657 658 /* must protect curr status */ 659 pipe_mutex_lock(rb_pipe->call_mutex); 660 661 rb_pipe->curr.nr_cbufs = 0; 662 memset(rb_pipe->curr.cbufs, 0, sizeof(rb_pipe->curr.cbufs)); 663 rb_pipe->curr.zsbuf = NULL; 664 665 /* unwrap the input state */ 666 if (_state) { 667 memcpy(&unwrapped_state, _state, sizeof(unwrapped_state)); 668 669 rb_pipe->curr.nr_cbufs = _state->nr_cbufs; 670 for(i = 0; i < _state->nr_cbufs; i++) { 671 unwrapped_state.cbufs[i] = rbug_surface_unwrap(_state->cbufs[i]); 672 if (_state->cbufs[i]) 673 rb_pipe->curr.cbufs[i] = rbug_resource(_state->cbufs[i]->texture); 674 } 675 unwrapped_state.zsbuf = rbug_surface_unwrap(_state->zsbuf); 676 if (_state->zsbuf) 677 rb_pipe->curr.zsbuf = rbug_resource(_state->zsbuf->texture); 678 state = &unwrapped_state; 679 } 680 681 pipe->set_framebuffer_state(pipe, 682 state); 683 684 pipe_mutex_unlock(rb_pipe->call_mutex); 685 } 686 687 static void 688 rbug_set_polygon_stipple(struct pipe_context *_pipe, 689 const struct pipe_poly_stipple *poly_stipple) 690 { 691 struct rbug_context *rb_pipe = rbug_context(_pipe); 692 struct pipe_context *pipe = rb_pipe->pipe; 693 694 pipe_mutex_lock(rb_pipe->call_mutex); 695 pipe->set_polygon_stipple(pipe, 696 poly_stipple); 697 pipe_mutex_unlock(rb_pipe->call_mutex); 698 } 699 700 static void 701 rbug_set_scissor_states(struct pipe_context *_pipe, 702 unsigned start_slot, 703 unsigned num_scissors, 704 const struct pipe_scissor_state *scissor) 705 { 706 struct rbug_context *rb_pipe = rbug_context(_pipe); 707 struct pipe_context *pipe = rb_pipe->pipe; 708 709 pipe_mutex_lock(rb_pipe->call_mutex); 710 pipe->set_scissor_states(pipe, start_slot, num_scissors, scissor); 711 pipe_mutex_unlock(rb_pipe->call_mutex); 712 } 713 714 static void 715 rbug_set_viewport_states(struct pipe_context *_pipe, 716 unsigned start_slot, 717 unsigned num_viewports, 718 const struct pipe_viewport_state *viewport) 719 { 720 struct rbug_context *rb_pipe = rbug_context(_pipe); 721 struct pipe_context *pipe = rb_pipe->pipe; 722 723 pipe_mutex_lock(rb_pipe->call_mutex); 724 pipe->set_viewport_states(pipe, start_slot, num_viewports, viewport); 725 pipe_mutex_unlock(rb_pipe->call_mutex); 726 } 727 728 static void 729 rbug_set_sampler_views(struct pipe_context *_pipe, 730 enum pipe_shader_type shader, 731 unsigned start, 732 unsigned num, 733 struct pipe_sampler_view **_views) 734 { 735 struct rbug_context *rb_pipe = rbug_context(_pipe); 736 struct pipe_context *pipe = rb_pipe->pipe; 737 struct pipe_sampler_view *unwrapped_views[PIPE_MAX_SHADER_SAMPLER_VIEWS]; 738 struct pipe_sampler_view **views = NULL; 739 unsigned i; 740 741 assert(start == 0); /* XXX fix */ 742 743 /* must protect curr status */ 744 pipe_mutex_lock(rb_pipe->call_mutex); 745 746 rb_pipe->curr.num_views[shader] = 0; 747 memset(rb_pipe->curr.views[shader], 0, sizeof(rb_pipe->curr.views[shader])); 748 memset(rb_pipe->curr.texs[shader], 0, sizeof(rb_pipe->curr.texs[shader])); 749 memset(unwrapped_views, 0, sizeof(unwrapped_views)); 750 751 if (_views) { 752 rb_pipe->curr.num_views[shader] = num; 753 for (i = 0; i < num; i++) { 754 rb_pipe->curr.views[shader][i] = rbug_sampler_view(_views[i]); 755 rb_pipe->curr.texs[shader][i] = rbug_resource(_views[i] ? _views[i]->texture : NULL); 756 unwrapped_views[i] = rbug_sampler_view_unwrap(_views[i]); 757 } 758 views = unwrapped_views; 759 } 760 761 pipe->set_sampler_views(pipe, shader, start, num, views); 762 763 pipe_mutex_unlock(rb_pipe->call_mutex); 764 } 765 766 static void 767 rbug_set_vertex_buffers(struct pipe_context *_pipe, 768 unsigned start_slot, unsigned num_buffers, 769 const struct pipe_vertex_buffer *_buffers) 770 { 771 struct rbug_context *rb_pipe = rbug_context(_pipe); 772 struct pipe_context *pipe = rb_pipe->pipe; 773 struct pipe_vertex_buffer unwrapped_buffers[PIPE_MAX_SHADER_INPUTS]; 774 struct pipe_vertex_buffer *buffers = NULL; 775 unsigned i; 776 777 pipe_mutex_lock(rb_pipe->call_mutex); 778 779 if (num_buffers && _buffers) { 780 memcpy(unwrapped_buffers, _buffers, num_buffers * sizeof(*_buffers)); 781 for (i = 0; i < num_buffers; i++) 782 unwrapped_buffers[i].buffer = rbug_resource_unwrap(_buffers[i].buffer); 783 buffers = unwrapped_buffers; 784 } 785 786 pipe->set_vertex_buffers(pipe, start_slot, 787 num_buffers, 788 buffers); 789 790 pipe_mutex_unlock(rb_pipe->call_mutex); 791 } 792 793 static void 794 rbug_set_index_buffer(struct pipe_context *_pipe, 795 const struct pipe_index_buffer *_ib) 796 { 797 struct rbug_context *rb_pipe = rbug_context(_pipe); 798 struct pipe_context *pipe = rb_pipe->pipe; 799 struct pipe_index_buffer unwrapped_ib, *ib = NULL; 800 801 if (_ib) { 802 unwrapped_ib = *_ib; 803 unwrapped_ib.buffer = rbug_resource_unwrap(_ib->buffer); 804 ib = &unwrapped_ib; 805 } 806 807 pipe_mutex_lock(rb_pipe->call_mutex); 808 pipe->set_index_buffer(pipe, ib); 809 pipe_mutex_unlock(rb_pipe->call_mutex); 810 } 811 812 static void 813 rbug_set_sample_mask(struct pipe_context *_pipe, 814 unsigned sample_mask) 815 { 816 struct rbug_context *rb_pipe = rbug_context(_pipe); 817 struct pipe_context *pipe = rb_pipe->pipe; 818 819 pipe_mutex_lock(rb_pipe->call_mutex); 820 pipe->set_sample_mask(pipe, sample_mask); 821 pipe_mutex_unlock(rb_pipe->call_mutex); 822 } 823 824 static struct pipe_stream_output_target * 825 rbug_create_stream_output_target(struct pipe_context *_pipe, 826 struct pipe_resource *_res, 827 unsigned buffer_offset, unsigned buffer_size) 828 { 829 struct rbug_context *rb_pipe = rbug_context(_pipe); 830 struct pipe_context *pipe = rb_pipe->pipe; 831 struct pipe_resource *res = rbug_resource_unwrap(_res); 832 struct pipe_stream_output_target *target; 833 834 pipe_mutex_lock(rb_pipe->call_mutex); 835 target = pipe->create_stream_output_target(pipe, res, buffer_offset, 836 buffer_size); 837 pipe_mutex_unlock(rb_pipe->call_mutex); 838 return target; 839 } 840 841 static void 842 rbug_stream_output_target_destroy(struct pipe_context *_pipe, 843 struct pipe_stream_output_target *target) 844 { 845 struct rbug_context *rb_pipe = rbug_context(_pipe); 846 struct pipe_context *pipe = rb_pipe->pipe; 847 848 pipe_mutex_lock(rb_pipe->call_mutex); 849 pipe->stream_output_target_destroy(pipe, target); 850 pipe_mutex_unlock(rb_pipe->call_mutex); 851 } 852 853 static void 854 rbug_set_stream_output_targets(struct pipe_context *_pipe, 855 unsigned num_targets, 856 struct pipe_stream_output_target **targets, 857 const unsigned *offsets) 858 { 859 struct rbug_context *rb_pipe = rbug_context(_pipe); 860 struct pipe_context *pipe = rb_pipe->pipe; 861 862 pipe_mutex_lock(rb_pipe->call_mutex); 863 pipe->set_stream_output_targets(pipe, num_targets, targets, offsets); 864 pipe_mutex_unlock(rb_pipe->call_mutex); 865 } 866 867 static void 868 rbug_resource_copy_region(struct pipe_context *_pipe, 869 struct pipe_resource *_dst, 870 unsigned dst_level, 871 unsigned dstx, 872 unsigned dsty, 873 unsigned dstz, 874 struct pipe_resource *_src, 875 unsigned src_level, 876 const struct pipe_box *src_box) 877 { 878 struct rbug_context *rb_pipe = rbug_context(_pipe); 879 struct rbug_resource *rb_resource_dst = rbug_resource(_dst); 880 struct rbug_resource *rb_resource_src = rbug_resource(_src); 881 struct pipe_context *pipe = rb_pipe->pipe; 882 struct pipe_resource *dst = rb_resource_dst->resource; 883 struct pipe_resource *src = rb_resource_src->resource; 884 885 pipe_mutex_lock(rb_pipe->call_mutex); 886 pipe->resource_copy_region(pipe, 887 dst, 888 dst_level, 889 dstx, 890 dsty, 891 dstz, 892 src, 893 src_level, 894 src_box); 895 pipe_mutex_unlock(rb_pipe->call_mutex); 896 } 897 898 static void 899 rbug_blit(struct pipe_context *_pipe, const struct pipe_blit_info *_blit_info) 900 { 901 struct rbug_context *rb_pipe = rbug_context(_pipe); 902 struct rbug_resource *rb_resource_dst = rbug_resource(_blit_info->dst.resource); 903 struct rbug_resource *rb_resource_src = rbug_resource(_blit_info->src.resource); 904 struct pipe_context *pipe = rb_pipe->pipe; 905 struct pipe_resource *dst = rb_resource_dst->resource; 906 struct pipe_resource *src = rb_resource_src->resource; 907 struct pipe_blit_info blit_info; 908 909 blit_info = *_blit_info; 910 blit_info.dst.resource = dst; 911 blit_info.src.resource = src; 912 913 pipe_mutex_lock(rb_pipe->call_mutex); 914 pipe->blit(pipe, &blit_info); 915 pipe_mutex_unlock(rb_pipe->call_mutex); 916 } 917 918 static void 919 rbug_flush_resource(struct pipe_context *_pipe, 920 struct pipe_resource *_res) 921 { 922 struct rbug_context *rb_pipe = rbug_context(_pipe); 923 struct rbug_resource *rb_resource_res = rbug_resource(_res); 924 struct pipe_context *pipe = rb_pipe->pipe; 925 struct pipe_resource *res = rb_resource_res->resource; 926 927 pipe_mutex_lock(rb_pipe->call_mutex); 928 pipe->flush_resource(pipe, res); 929 pipe_mutex_unlock(rb_pipe->call_mutex); 930 } 931 932 static void 933 rbug_clear(struct pipe_context *_pipe, 934 unsigned buffers, 935 const union pipe_color_union *color, 936 double depth, 937 unsigned stencil) 938 { 939 struct rbug_context *rb_pipe = rbug_context(_pipe); 940 struct pipe_context *pipe = rb_pipe->pipe; 941 942 pipe_mutex_lock(rb_pipe->call_mutex); 943 pipe->clear(pipe, 944 buffers, 945 color, 946 depth, 947 stencil); 948 pipe_mutex_unlock(rb_pipe->call_mutex); 949 } 950 951 static void 952 rbug_clear_render_target(struct pipe_context *_pipe, 953 struct pipe_surface *_dst, 954 const union pipe_color_union *color, 955 unsigned dstx, unsigned dsty, 956 unsigned width, unsigned height, 957 bool render_condition_enabled) 958 { 959 struct rbug_context *rb_pipe = rbug_context(_pipe); 960 struct rbug_surface *rb_surface_dst = rbug_surface(_dst); 961 struct pipe_context *pipe = rb_pipe->pipe; 962 struct pipe_surface *dst = rb_surface_dst->surface; 963 964 pipe_mutex_lock(rb_pipe->call_mutex); 965 pipe->clear_render_target(pipe, 966 dst, 967 color, 968 dstx, 969 dsty, 970 width, 971 height, 972 render_condition_enabled); 973 pipe_mutex_unlock(rb_pipe->call_mutex); 974 } 975 976 static void 977 rbug_clear_depth_stencil(struct pipe_context *_pipe, 978 struct pipe_surface *_dst, 979 unsigned clear_flags, 980 double depth, 981 unsigned stencil, 982 unsigned dstx, unsigned dsty, 983 unsigned width, unsigned height, 984 bool render_condition_enabled) 985 { 986 struct rbug_context *rb_pipe = rbug_context(_pipe); 987 struct rbug_surface *rb_surface_dst = rbug_surface(_dst); 988 struct pipe_context *pipe = rb_pipe->pipe; 989 struct pipe_surface *dst = rb_surface_dst->surface; 990 991 pipe_mutex_lock(rb_pipe->call_mutex); 992 pipe->clear_depth_stencil(pipe, 993 dst, 994 clear_flags, 995 depth, 996 stencil, 997 dstx, 998 dsty, 999 width, 1000 height, 1001 render_condition_enabled); 1002 pipe_mutex_unlock(rb_pipe->call_mutex); 1003 } 1004 1005 static void 1006 rbug_flush(struct pipe_context *_pipe, 1007 struct pipe_fence_handle **fence, 1008 unsigned flags) 1009 { 1010 struct rbug_context *rb_pipe = rbug_context(_pipe); 1011 struct pipe_context *pipe = rb_pipe->pipe; 1012 1013 pipe_mutex_lock(rb_pipe->call_mutex); 1014 pipe->flush(pipe, fence, flags); 1015 pipe_mutex_unlock(rb_pipe->call_mutex); 1016 } 1017 1018 static struct pipe_sampler_view * 1019 rbug_context_create_sampler_view(struct pipe_context *_pipe, 1020 struct pipe_resource *_resource, 1021 const struct pipe_sampler_view *templ) 1022 { 1023 struct rbug_context *rb_pipe = rbug_context(_pipe); 1024 struct rbug_resource *rb_resource = rbug_resource(_resource); 1025 struct pipe_context *pipe = rb_pipe->pipe; 1026 struct pipe_resource *resource = rb_resource->resource; 1027 struct pipe_sampler_view *result; 1028 1029 pipe_mutex_lock(rb_pipe->call_mutex); 1030 result = pipe->create_sampler_view(pipe, 1031 resource, 1032 templ); 1033 pipe_mutex_unlock(rb_pipe->call_mutex); 1034 1035 if (result) 1036 return rbug_sampler_view_create(rb_pipe, rb_resource, result); 1037 return NULL; 1038 } 1039 1040 static void 1041 rbug_context_sampler_view_destroy(struct pipe_context *_pipe, 1042 struct pipe_sampler_view *_view) 1043 { 1044 rbug_sampler_view_destroy(rbug_context(_pipe), 1045 rbug_sampler_view(_view)); 1046 } 1047 1048 static struct pipe_surface * 1049 rbug_context_create_surface(struct pipe_context *_pipe, 1050 struct pipe_resource *_resource, 1051 const struct pipe_surface *surf_tmpl) 1052 { 1053 struct rbug_context *rb_pipe = rbug_context(_pipe); 1054 struct rbug_resource *rb_resource = rbug_resource(_resource); 1055 struct pipe_context *pipe = rb_pipe->pipe; 1056 struct pipe_resource *resource = rb_resource->resource; 1057 struct pipe_surface *result; 1058 1059 pipe_mutex_lock(rb_pipe->call_mutex); 1060 result = pipe->create_surface(pipe, 1061 resource, 1062 surf_tmpl); 1063 pipe_mutex_unlock(rb_pipe->call_mutex); 1064 1065 if (result) 1066 return rbug_surface_create(rb_pipe, rb_resource, result); 1067 return NULL; 1068 } 1069 1070 static void 1071 rbug_context_surface_destroy(struct pipe_context *_pipe, 1072 struct pipe_surface *_surface) 1073 { 1074 struct rbug_context *rb_pipe = rbug_context(_pipe); 1075 struct rbug_surface *rb_surface = rbug_surface(_surface); 1076 1077 pipe_mutex_lock(rb_pipe->call_mutex); 1078 rbug_surface_destroy(rb_pipe, 1079 rb_surface); 1080 pipe_mutex_unlock(rb_pipe->call_mutex); 1081 } 1082 1083 1084 1085 static void * 1086 rbug_context_transfer_map(struct pipe_context *_context, 1087 struct pipe_resource *_resource, 1088 unsigned level, 1089 unsigned usage, 1090 const struct pipe_box *box, 1091 struct pipe_transfer **transfer) 1092 { 1093 struct rbug_context *rb_pipe = rbug_context(_context); 1094 struct rbug_resource *rb_resource = rbug_resource(_resource); 1095 struct pipe_context *context = rb_pipe->pipe; 1096 struct pipe_resource *resource = rb_resource->resource; 1097 struct pipe_transfer *result; 1098 void *map; 1099 1100 pipe_mutex_lock(rb_pipe->call_mutex); 1101 map = context->transfer_map(context, 1102 resource, 1103 level, 1104 usage, 1105 box, &result); 1106 pipe_mutex_unlock(rb_pipe->call_mutex); 1107 1108 *transfer = rbug_transfer_create(rb_pipe, rb_resource, result); 1109 return *transfer ? map : NULL; 1110 } 1111 1112 static void 1113 rbug_context_transfer_flush_region(struct pipe_context *_context, 1114 struct pipe_transfer *_transfer, 1115 const struct pipe_box *box) 1116 { 1117 struct rbug_context *rb_pipe = rbug_context(_context); 1118 struct rbug_transfer *rb_transfer = rbug_transfer(_transfer); 1119 struct pipe_context *context = rb_pipe->pipe; 1120 struct pipe_transfer *transfer = rb_transfer->transfer; 1121 1122 pipe_mutex_lock(rb_pipe->call_mutex); 1123 context->transfer_flush_region(context, 1124 transfer, 1125 box); 1126 pipe_mutex_unlock(rb_pipe->call_mutex); 1127 } 1128 1129 1130 static void 1131 rbug_context_transfer_unmap(struct pipe_context *_context, 1132 struct pipe_transfer *_transfer) 1133 { 1134 struct rbug_context *rb_pipe = rbug_context(_context); 1135 struct rbug_transfer *rb_transfer = rbug_transfer(_transfer); 1136 struct pipe_context *context = rb_pipe->pipe; 1137 struct pipe_transfer *transfer = rb_transfer->transfer; 1138 1139 pipe_mutex_lock(rb_pipe->call_mutex); 1140 context->transfer_unmap(context, 1141 transfer); 1142 rbug_transfer_destroy(rb_pipe, 1143 rb_transfer); 1144 pipe_mutex_unlock(rb_pipe->call_mutex); 1145 } 1146 1147 1148 static void 1149 rbug_context_buffer_subdata(struct pipe_context *_context, 1150 struct pipe_resource *_resource, 1151 unsigned usage, unsigned offset, 1152 unsigned size, const void *data) 1153 { 1154 struct rbug_context *rb_pipe = rbug_context(_context); 1155 struct rbug_resource *rb_resource = rbug_resource(_resource); 1156 struct pipe_context *context = rb_pipe->pipe; 1157 struct pipe_resource *resource = rb_resource->resource; 1158 1159 pipe_mutex_lock(rb_pipe->call_mutex); 1160 context->buffer_subdata(context, resource, usage, offset, size, data); 1161 pipe_mutex_unlock(rb_pipe->call_mutex); 1162 } 1163 1164 1165 static void 1166 rbug_context_texture_subdata(struct pipe_context *_context, 1167 struct pipe_resource *_resource, 1168 unsigned level, 1169 unsigned usage, 1170 const struct pipe_box *box, 1171 const void *data, 1172 unsigned stride, 1173 unsigned layer_stride) 1174 { 1175 struct rbug_context *rb_pipe = rbug_context(_context); 1176 struct rbug_resource *rb_resource = rbug_resource(_resource); 1177 struct pipe_context *context = rb_pipe->pipe; 1178 struct pipe_resource *resource = rb_resource->resource; 1179 1180 pipe_mutex_lock(rb_pipe->call_mutex); 1181 context->texture_subdata(context, 1182 resource, 1183 level, 1184 usage, 1185 box, 1186 data, 1187 stride, 1188 layer_stride); 1189 pipe_mutex_unlock(rb_pipe->call_mutex); 1190 } 1191 1192 1193 struct pipe_context * 1194 rbug_context_create(struct pipe_screen *_screen, struct pipe_context *pipe) 1195 { 1196 struct rbug_context *rb_pipe; 1197 struct rbug_screen *rb_screen = rbug_screen(_screen); 1198 1199 if (!rb_screen) 1200 return NULL; 1201 1202 rb_pipe = CALLOC_STRUCT(rbug_context); 1203 if (!rb_pipe) 1204 return NULL; 1205 1206 pipe_mutex_init(rb_pipe->draw_mutex); 1207 pipe_condvar_init(rb_pipe->draw_cond); 1208 pipe_mutex_init(rb_pipe->call_mutex); 1209 pipe_mutex_init(rb_pipe->list_mutex); 1210 make_empty_list(&rb_pipe->shaders); 1211 1212 rb_pipe->base.screen = _screen; 1213 rb_pipe->base.priv = pipe->priv; /* expose wrapped data */ 1214 rb_pipe->base.draw = NULL; 1215 1216 rb_pipe->base.destroy = rbug_destroy; 1217 rb_pipe->base.draw_vbo = rbug_draw_vbo; 1218 rb_pipe->base.create_query = rbug_create_query; 1219 rb_pipe->base.destroy_query = rbug_destroy_query; 1220 rb_pipe->base.begin_query = rbug_begin_query; 1221 rb_pipe->base.end_query = rbug_end_query; 1222 rb_pipe->base.get_query_result = rbug_get_query_result; 1223 rb_pipe->base.set_active_query_state = rbug_set_active_query_state; 1224 rb_pipe->base.create_blend_state = rbug_create_blend_state; 1225 rb_pipe->base.bind_blend_state = rbug_bind_blend_state; 1226 rb_pipe->base.delete_blend_state = rbug_delete_blend_state; 1227 rb_pipe->base.create_sampler_state = rbug_create_sampler_state; 1228 rb_pipe->base.bind_sampler_states = rbug_bind_sampler_states; 1229 rb_pipe->base.delete_sampler_state = rbug_delete_sampler_state; 1230 rb_pipe->base.create_rasterizer_state = rbug_create_rasterizer_state; 1231 rb_pipe->base.bind_rasterizer_state = rbug_bind_rasterizer_state; 1232 rb_pipe->base.delete_rasterizer_state = rbug_delete_rasterizer_state; 1233 rb_pipe->base.create_depth_stencil_alpha_state = rbug_create_depth_stencil_alpha_state; 1234 rb_pipe->base.bind_depth_stencil_alpha_state = rbug_bind_depth_stencil_alpha_state; 1235 rb_pipe->base.delete_depth_stencil_alpha_state = rbug_delete_depth_stencil_alpha_state; 1236 rb_pipe->base.create_fs_state = rbug_create_fs_state; 1237 rb_pipe->base.bind_fs_state = rbug_bind_fs_state; 1238 rb_pipe->base.delete_fs_state = rbug_delete_fs_state; 1239 rb_pipe->base.create_vs_state = rbug_create_vs_state; 1240 rb_pipe->base.bind_vs_state = rbug_bind_vs_state; 1241 rb_pipe->base.delete_vs_state = rbug_delete_vs_state; 1242 rb_pipe->base.create_gs_state = rbug_create_gs_state; 1243 rb_pipe->base.bind_gs_state = rbug_bind_gs_state; 1244 rb_pipe->base.delete_gs_state = rbug_delete_gs_state; 1245 rb_pipe->base.create_vertex_elements_state = rbug_create_vertex_elements_state; 1246 rb_pipe->base.bind_vertex_elements_state = rbug_bind_vertex_elements_state; 1247 rb_pipe->base.delete_vertex_elements_state = rbug_delete_vertex_elements_state; 1248 rb_pipe->base.set_blend_color = rbug_set_blend_color; 1249 rb_pipe->base.set_stencil_ref = rbug_set_stencil_ref; 1250 rb_pipe->base.set_clip_state = rbug_set_clip_state; 1251 rb_pipe->base.set_constant_buffer = rbug_set_constant_buffer; 1252 rb_pipe->base.set_framebuffer_state = rbug_set_framebuffer_state; 1253 rb_pipe->base.set_polygon_stipple = rbug_set_polygon_stipple; 1254 rb_pipe->base.set_scissor_states = rbug_set_scissor_states; 1255 rb_pipe->base.set_viewport_states = rbug_set_viewport_states; 1256 rb_pipe->base.set_sampler_views = rbug_set_sampler_views; 1257 rb_pipe->base.set_vertex_buffers = rbug_set_vertex_buffers; 1258 rb_pipe->base.set_index_buffer = rbug_set_index_buffer; 1259 rb_pipe->base.set_sample_mask = rbug_set_sample_mask; 1260 rb_pipe->base.create_stream_output_target = rbug_create_stream_output_target; 1261 rb_pipe->base.stream_output_target_destroy = rbug_stream_output_target_destroy; 1262 rb_pipe->base.set_stream_output_targets = rbug_set_stream_output_targets; 1263 rb_pipe->base.resource_copy_region = rbug_resource_copy_region; 1264 rb_pipe->base.blit = rbug_blit; 1265 rb_pipe->base.flush_resource = rbug_flush_resource; 1266 rb_pipe->base.clear = rbug_clear; 1267 rb_pipe->base.clear_render_target = rbug_clear_render_target; 1268 rb_pipe->base.clear_depth_stencil = rbug_clear_depth_stencil; 1269 rb_pipe->base.flush = rbug_flush; 1270 rb_pipe->base.create_sampler_view = rbug_context_create_sampler_view; 1271 rb_pipe->base.sampler_view_destroy = rbug_context_sampler_view_destroy; 1272 rb_pipe->base.create_surface = rbug_context_create_surface; 1273 rb_pipe->base.surface_destroy = rbug_context_surface_destroy; 1274 rb_pipe->base.transfer_map = rbug_context_transfer_map; 1275 rb_pipe->base.transfer_unmap = rbug_context_transfer_unmap; 1276 rb_pipe->base.transfer_flush_region = rbug_context_transfer_flush_region; 1277 rb_pipe->base.buffer_subdata = rbug_context_buffer_subdata; 1278 rb_pipe->base.texture_subdata = rbug_context_texture_subdata; 1279 1280 rb_pipe->pipe = pipe; 1281 1282 rbug_screen_add_to_list(rb_screen, contexts, rb_pipe); 1283 1284 if (debug_get_bool_option("GALLIUM_RBUG_START_BLOCKED", FALSE)) { 1285 rb_pipe->draw_blocked = RBUG_BLOCK_BEFORE; 1286 } 1287 1288 return &rb_pipe->base; 1289 } 1290
