1 /************************************************************************** 2 * 3 * Copyright 2007 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 * @file 30 * 31 * Wrap the cso cache & hash mechanisms in a simplified 32 * pipe-driver-specific interface. 33 * 34 * @author Zack Rusin <zackr (at) vmware.com> 35 * @author Keith Whitwell <keithw (at) vmware.com> 36 */ 37 38 #include "pipe/p_state.h" 39 #include "util/u_draw.h" 40 #include "util/u_framebuffer.h" 41 #include "util/u_inlines.h" 42 #include "util/u_math.h" 43 #include "util/u_memory.h" 44 #include "util/u_vbuf.h" 45 #include "tgsi/tgsi_parse.h" 46 47 #include "cso_cache/cso_context.h" 48 #include "cso_cache/cso_cache.h" 49 #include "cso_cache/cso_hash.h" 50 #include "cso_context.h" 51 52 53 /** 54 * Per-shader sampler information. 55 */ 56 struct sampler_info 57 { 58 struct cso_sampler *cso_samplers[PIPE_MAX_SAMPLERS]; 59 void *samplers[PIPE_MAX_SAMPLERS]; 60 unsigned nr_samplers; 61 }; 62 63 64 65 struct cso_context { 66 struct pipe_context *pipe; 67 struct cso_cache *cache; 68 struct u_vbuf *vbuf; 69 70 boolean has_geometry_shader; 71 boolean has_tessellation; 72 boolean has_compute_shader; 73 boolean has_streamout; 74 75 unsigned saved_state; /**< bitmask of CSO_BIT_x flags */ 76 77 struct pipe_sampler_view *fragment_views[PIPE_MAX_SHADER_SAMPLER_VIEWS]; 78 unsigned nr_fragment_views; 79 80 struct pipe_sampler_view *fragment_views_saved[PIPE_MAX_SHADER_SAMPLER_VIEWS]; 81 unsigned nr_fragment_views_saved; 82 83 struct sampler_info fragment_samplers_saved; 84 struct sampler_info samplers[PIPE_SHADER_TYPES]; 85 86 struct pipe_vertex_buffer aux_vertex_buffer_current; 87 struct pipe_vertex_buffer aux_vertex_buffer_saved; 88 unsigned aux_vertex_buffer_index; 89 90 struct pipe_constant_buffer aux_constbuf_current[PIPE_SHADER_TYPES]; 91 struct pipe_constant_buffer aux_constbuf_saved[PIPE_SHADER_TYPES]; 92 93 struct pipe_image_view fragment_image0_current; 94 struct pipe_image_view fragment_image0_saved; 95 96 unsigned nr_so_targets; 97 struct pipe_stream_output_target *so_targets[PIPE_MAX_SO_BUFFERS]; 98 99 unsigned nr_so_targets_saved; 100 struct pipe_stream_output_target *so_targets_saved[PIPE_MAX_SO_BUFFERS]; 101 102 /** Current and saved state. 103 * The saved state is used as a 1-deep stack. 104 */ 105 void *blend, *blend_saved; 106 void *depth_stencil, *depth_stencil_saved; 107 void *rasterizer, *rasterizer_saved; 108 void *fragment_shader, *fragment_shader_saved; 109 void *vertex_shader, *vertex_shader_saved; 110 void *geometry_shader, *geometry_shader_saved; 111 void *tessctrl_shader, *tessctrl_shader_saved; 112 void *tesseval_shader, *tesseval_shader_saved; 113 void *compute_shader; 114 void *velements, *velements_saved; 115 struct pipe_query *render_condition, *render_condition_saved; 116 uint render_condition_mode, render_condition_mode_saved; 117 boolean render_condition_cond, render_condition_cond_saved; 118 119 struct pipe_framebuffer_state fb, fb_saved; 120 struct pipe_viewport_state vp, vp_saved; 121 struct pipe_blend_color blend_color; 122 unsigned sample_mask, sample_mask_saved; 123 unsigned min_samples, min_samples_saved; 124 struct pipe_stencil_ref stencil_ref, stencil_ref_saved; 125 }; 126 127 128 static boolean delete_blend_state(struct cso_context *ctx, void *state) 129 { 130 struct cso_blend *cso = (struct cso_blend *)state; 131 132 if (ctx->blend == cso->data) 133 return FALSE; 134 135 if (cso->delete_state) 136 cso->delete_state(cso->context, cso->data); 137 FREE(state); 138 return TRUE; 139 } 140 141 static boolean delete_depth_stencil_state(struct cso_context *ctx, void *state) 142 { 143 struct cso_depth_stencil_alpha *cso = 144 (struct cso_depth_stencil_alpha *)state; 145 146 if (ctx->depth_stencil == cso->data) 147 return FALSE; 148 149 if (cso->delete_state) 150 cso->delete_state(cso->context, cso->data); 151 FREE(state); 152 153 return TRUE; 154 } 155 156 static boolean delete_sampler_state(struct cso_context *ctx, void *state) 157 { 158 struct cso_sampler *cso = (struct cso_sampler *)state; 159 if (cso->delete_state) 160 cso->delete_state(cso->context, cso->data); 161 FREE(state); 162 return TRUE; 163 } 164 165 static boolean delete_rasterizer_state(struct cso_context *ctx, void *state) 166 { 167 struct cso_rasterizer *cso = (struct cso_rasterizer *)state; 168 169 if (ctx->rasterizer == cso->data) 170 return FALSE; 171 if (cso->delete_state) 172 cso->delete_state(cso->context, cso->data); 173 FREE(state); 174 return TRUE; 175 } 176 177 static boolean delete_vertex_elements(struct cso_context *ctx, 178 void *state) 179 { 180 struct cso_velements *cso = (struct cso_velements *)state; 181 182 if (ctx->velements == cso->data) 183 return FALSE; 184 185 if (cso->delete_state) 186 cso->delete_state(cso->context, cso->data); 187 FREE(state); 188 return TRUE; 189 } 190 191 192 static inline boolean delete_cso(struct cso_context *ctx, 193 void *state, enum cso_cache_type type) 194 { 195 switch (type) { 196 case CSO_BLEND: 197 return delete_blend_state(ctx, state); 198 case CSO_SAMPLER: 199 return delete_sampler_state(ctx, state); 200 case CSO_DEPTH_STENCIL_ALPHA: 201 return delete_depth_stencil_state(ctx, state); 202 case CSO_RASTERIZER: 203 return delete_rasterizer_state(ctx, state); 204 case CSO_VELEMENTS: 205 return delete_vertex_elements(ctx, state); 206 default: 207 assert(0); 208 FREE(state); 209 } 210 return FALSE; 211 } 212 213 static inline void 214 sanitize_hash(struct cso_hash *hash, enum cso_cache_type type, 215 int max_size, void *user_data) 216 { 217 struct cso_context *ctx = (struct cso_context *)user_data; 218 /* if we're approach the maximum size, remove fourth of the entries 219 * otherwise every subsequent call will go through the same */ 220 int hash_size = cso_hash_size(hash); 221 int max_entries = (max_size > hash_size) ? max_size : hash_size; 222 int to_remove = (max_size < max_entries) * max_entries/4; 223 struct cso_hash_iter iter; 224 struct cso_sampler **samplers_to_restore = NULL; 225 unsigned to_restore = 0; 226 227 if (hash_size > max_size) 228 to_remove += hash_size - max_size; 229 230 if (to_remove == 0) 231 return; 232 233 if (type == CSO_SAMPLER) { 234 int i, j; 235 236 samplers_to_restore = MALLOC(PIPE_SHADER_TYPES * PIPE_MAX_SAMPLERS * 237 sizeof(*samplers_to_restore)); 238 239 /* Temporarily remove currently bound sampler states from the hash 240 * table, to prevent them from being deleted 241 */ 242 for (i = 0; i < PIPE_SHADER_TYPES; i++) { 243 for (j = 0; j < ctx->samplers[i].nr_samplers; j++) { 244 struct cso_sampler *sampler = ctx->samplers[i].cso_samplers[j]; 245 246 if (sampler && cso_hash_take(hash, sampler->hash_key)) 247 samplers_to_restore[to_restore++] = sampler; 248 } 249 } 250 } 251 252 iter = cso_hash_first_node(hash); 253 while (to_remove) { 254 /*remove elements until we're good */ 255 /*fixme: currently we pick the nodes to remove at random*/ 256 void *cso = cso_hash_iter_data(iter); 257 258 if (!cso) 259 break; 260 261 if (delete_cso(ctx, cso, type)) { 262 iter = cso_hash_erase(hash, iter); 263 --to_remove; 264 } else 265 iter = cso_hash_iter_next(iter); 266 } 267 268 if (type == CSO_SAMPLER) { 269 /* Put currently bound sampler states back into the hash table */ 270 while (to_restore--) { 271 struct cso_sampler *sampler = samplers_to_restore[to_restore]; 272 273 cso_hash_insert(hash, sampler->hash_key, sampler); 274 } 275 276 FREE(samplers_to_restore); 277 } 278 } 279 280 static void cso_init_vbuf(struct cso_context *cso) 281 { 282 struct u_vbuf_caps caps; 283 284 /* Install u_vbuf if there is anything unsupported. */ 285 if (u_vbuf_get_caps(cso->pipe->screen, &caps)) { 286 cso->vbuf = u_vbuf_create(cso->pipe, &caps, 287 cso->aux_vertex_buffer_index); 288 } 289 } 290 291 struct cso_context *cso_create_context( struct pipe_context *pipe ) 292 { 293 struct cso_context *ctx = CALLOC_STRUCT(cso_context); 294 if (!ctx) 295 return NULL; 296 297 ctx->cache = cso_cache_create(); 298 if (ctx->cache == NULL) 299 goto out; 300 cso_cache_set_sanitize_callback(ctx->cache, 301 sanitize_hash, 302 ctx); 303 304 ctx->pipe = pipe; 305 ctx->sample_mask = ~0; 306 307 ctx->aux_vertex_buffer_index = 0; /* 0 for now */ 308 309 cso_init_vbuf(ctx); 310 311 /* Enable for testing: */ 312 if (0) cso_set_maximum_cache_size( ctx->cache, 4 ); 313 314 if (pipe->screen->get_shader_param(pipe->screen, PIPE_SHADER_GEOMETRY, 315 PIPE_SHADER_CAP_MAX_INSTRUCTIONS) > 0) { 316 ctx->has_geometry_shader = TRUE; 317 } 318 if (pipe->screen->get_shader_param(pipe->screen, PIPE_SHADER_TESS_CTRL, 319 PIPE_SHADER_CAP_MAX_INSTRUCTIONS) > 0) { 320 ctx->has_tessellation = TRUE; 321 } 322 if (pipe->screen->get_shader_param(pipe->screen, PIPE_SHADER_COMPUTE, 323 PIPE_SHADER_CAP_MAX_INSTRUCTIONS) > 0) { 324 int supported_irs = 325 pipe->screen->get_shader_param(pipe->screen, PIPE_SHADER_COMPUTE, 326 PIPE_SHADER_CAP_SUPPORTED_IRS); 327 if (supported_irs & (1 << PIPE_SHADER_IR_TGSI)) { 328 ctx->has_compute_shader = TRUE; 329 } 330 } 331 if (pipe->screen->get_param(pipe->screen, 332 PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS) != 0) { 333 ctx->has_streamout = TRUE; 334 } 335 336 return ctx; 337 338 out: 339 cso_destroy_context( ctx ); 340 return NULL; 341 } 342 343 /** 344 * Free the CSO context. 345 */ 346 void cso_destroy_context( struct cso_context *ctx ) 347 { 348 unsigned i; 349 350 if (ctx->pipe) { 351 ctx->pipe->set_index_buffer(ctx->pipe, NULL); 352 353 ctx->pipe->bind_blend_state( ctx->pipe, NULL ); 354 ctx->pipe->bind_rasterizer_state( ctx->pipe, NULL ); 355 356 { 357 static struct pipe_sampler_view *views[PIPE_MAX_SHADER_SAMPLER_VIEWS] = { NULL }; 358 static void *zeros[PIPE_MAX_SAMPLERS] = { NULL }; 359 struct pipe_screen *scr = ctx->pipe->screen; 360 enum pipe_shader_type sh; 361 for (sh = 0; sh < PIPE_SHADER_TYPES; sh++) { 362 int maxsam = scr->get_shader_param(scr, sh, 363 PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS); 364 int maxview = scr->get_shader_param(scr, sh, 365 PIPE_SHADER_CAP_MAX_SAMPLER_VIEWS); 366 assert(maxsam <= PIPE_MAX_SAMPLERS); 367 assert(maxview <= PIPE_MAX_SHADER_SAMPLER_VIEWS); 368 if (maxsam > 0) { 369 ctx->pipe->bind_sampler_states(ctx->pipe, sh, 0, maxsam, zeros); 370 } 371 if (maxview > 0) { 372 ctx->pipe->set_sampler_views(ctx->pipe, sh, 0, maxview, views); 373 } 374 } 375 } 376 377 ctx->pipe->bind_depth_stencil_alpha_state( ctx->pipe, NULL ); 378 ctx->pipe->bind_fs_state( ctx->pipe, NULL ); 379 ctx->pipe->set_constant_buffer(ctx->pipe, PIPE_SHADER_FRAGMENT, 0, NULL); 380 ctx->pipe->bind_vs_state( ctx->pipe, NULL ); 381 ctx->pipe->set_constant_buffer(ctx->pipe, PIPE_SHADER_VERTEX, 0, NULL); 382 if (ctx->has_geometry_shader) { 383 ctx->pipe->bind_gs_state(ctx->pipe, NULL); 384 ctx->pipe->set_constant_buffer(ctx->pipe, PIPE_SHADER_GEOMETRY, 0, NULL); 385 } 386 if (ctx->has_tessellation) { 387 ctx->pipe->bind_tcs_state(ctx->pipe, NULL); 388 ctx->pipe->set_constant_buffer(ctx->pipe, PIPE_SHADER_TESS_CTRL, 0, NULL); 389 ctx->pipe->bind_tes_state(ctx->pipe, NULL); 390 ctx->pipe->set_constant_buffer(ctx->pipe, PIPE_SHADER_TESS_EVAL, 0, NULL); 391 } 392 if (ctx->has_compute_shader) { 393 ctx->pipe->bind_compute_state(ctx->pipe, NULL); 394 ctx->pipe->set_constant_buffer(ctx->pipe, PIPE_SHADER_COMPUTE, 0, NULL); 395 } 396 ctx->pipe->bind_vertex_elements_state( ctx->pipe, NULL ); 397 398 if (ctx->has_streamout) 399 ctx->pipe->set_stream_output_targets(ctx->pipe, 0, NULL, NULL); 400 } 401 402 for (i = 0; i < PIPE_MAX_SHADER_SAMPLER_VIEWS; i++) { 403 pipe_sampler_view_reference(&ctx->fragment_views[i], NULL); 404 pipe_sampler_view_reference(&ctx->fragment_views_saved[i], NULL); 405 } 406 407 util_unreference_framebuffer_state(&ctx->fb); 408 util_unreference_framebuffer_state(&ctx->fb_saved); 409 410 pipe_resource_reference(&ctx->aux_vertex_buffer_current.buffer, NULL); 411 pipe_resource_reference(&ctx->aux_vertex_buffer_saved.buffer, NULL); 412 413 for (i = 0; i < PIPE_SHADER_TYPES; i++) { 414 pipe_resource_reference(&ctx->aux_constbuf_current[i].buffer, NULL); 415 pipe_resource_reference(&ctx->aux_constbuf_saved[i].buffer, NULL); 416 } 417 418 pipe_resource_reference(&ctx->fragment_image0_current.resource, NULL); 419 pipe_resource_reference(&ctx->fragment_image0_saved.resource, NULL); 420 421 for (i = 0; i < PIPE_MAX_SO_BUFFERS; i++) { 422 pipe_so_target_reference(&ctx->so_targets[i], NULL); 423 pipe_so_target_reference(&ctx->so_targets_saved[i], NULL); 424 } 425 426 if (ctx->cache) { 427 cso_cache_delete( ctx->cache ); 428 ctx->cache = NULL; 429 } 430 431 if (ctx->vbuf) 432 u_vbuf_destroy(ctx->vbuf); 433 FREE( ctx ); 434 } 435 436 437 /* Those function will either find the state of the given template 438 * in the cache or they will create a new state from the given 439 * template, insert it in the cache and return it. 440 */ 441 442 /* 443 * If the driver returns 0 from the create method then they will assign 444 * the data member of the cso to be the template itself. 445 */ 446 447 enum pipe_error cso_set_blend(struct cso_context *ctx, 448 const struct pipe_blend_state *templ) 449 { 450 unsigned key_size, hash_key; 451 struct cso_hash_iter iter; 452 void *handle; 453 454 key_size = templ->independent_blend_enable ? 455 sizeof(struct pipe_blend_state) : 456 (char *)&(templ->rt[1]) - (char *)templ; 457 hash_key = cso_construct_key((void*)templ, key_size); 458 iter = cso_find_state_template(ctx->cache, hash_key, CSO_BLEND, 459 (void*)templ, key_size); 460 461 if (cso_hash_iter_is_null(iter)) { 462 struct cso_blend *cso = MALLOC(sizeof(struct cso_blend)); 463 if (!cso) 464 return PIPE_ERROR_OUT_OF_MEMORY; 465 466 memset(&cso->state, 0, sizeof cso->state); 467 memcpy(&cso->state, templ, key_size); 468 cso->data = ctx->pipe->create_blend_state(ctx->pipe, &cso->state); 469 cso->delete_state = (cso_state_callback)ctx->pipe->delete_blend_state; 470 cso->context = ctx->pipe; 471 472 iter = cso_insert_state(ctx->cache, hash_key, CSO_BLEND, cso); 473 if (cso_hash_iter_is_null(iter)) { 474 FREE(cso); 475 return PIPE_ERROR_OUT_OF_MEMORY; 476 } 477 478 handle = cso->data; 479 } 480 else { 481 handle = ((struct cso_blend *)cso_hash_iter_data(iter))->data; 482 } 483 484 if (ctx->blend != handle) { 485 ctx->blend = handle; 486 ctx->pipe->bind_blend_state(ctx->pipe, handle); 487 } 488 return PIPE_OK; 489 } 490 491 static void 492 cso_save_blend(struct cso_context *ctx) 493 { 494 assert(!ctx->blend_saved); 495 ctx->blend_saved = ctx->blend; 496 } 497 498 static void 499 cso_restore_blend(struct cso_context *ctx) 500 { 501 if (ctx->blend != ctx->blend_saved) { 502 ctx->blend = ctx->blend_saved; 503 ctx->pipe->bind_blend_state(ctx->pipe, ctx->blend_saved); 504 } 505 ctx->blend_saved = NULL; 506 } 507 508 509 510 enum pipe_error 511 cso_set_depth_stencil_alpha(struct cso_context *ctx, 512 const struct pipe_depth_stencil_alpha_state *templ) 513 { 514 unsigned key_size = sizeof(struct pipe_depth_stencil_alpha_state); 515 unsigned hash_key = cso_construct_key((void*)templ, key_size); 516 struct cso_hash_iter iter = cso_find_state_template(ctx->cache, 517 hash_key, 518 CSO_DEPTH_STENCIL_ALPHA, 519 (void*)templ, key_size); 520 void *handle; 521 522 if (cso_hash_iter_is_null(iter)) { 523 struct cso_depth_stencil_alpha *cso = 524 MALLOC(sizeof(struct cso_depth_stencil_alpha)); 525 if (!cso) 526 return PIPE_ERROR_OUT_OF_MEMORY; 527 528 memcpy(&cso->state, templ, sizeof(*templ)); 529 cso->data = ctx->pipe->create_depth_stencil_alpha_state(ctx->pipe, 530 &cso->state); 531 cso->delete_state = 532 (cso_state_callback)ctx->pipe->delete_depth_stencil_alpha_state; 533 cso->context = ctx->pipe; 534 535 iter = cso_insert_state(ctx->cache, hash_key, 536 CSO_DEPTH_STENCIL_ALPHA, cso); 537 if (cso_hash_iter_is_null(iter)) { 538 FREE(cso); 539 return PIPE_ERROR_OUT_OF_MEMORY; 540 } 541 542 handle = cso->data; 543 } 544 else { 545 handle = ((struct cso_depth_stencil_alpha *) 546 cso_hash_iter_data(iter))->data; 547 } 548 549 if (ctx->depth_stencil != handle) { 550 ctx->depth_stencil = handle; 551 ctx->pipe->bind_depth_stencil_alpha_state(ctx->pipe, handle); 552 } 553 return PIPE_OK; 554 } 555 556 static void 557 cso_save_depth_stencil_alpha(struct cso_context *ctx) 558 { 559 assert(!ctx->depth_stencil_saved); 560 ctx->depth_stencil_saved = ctx->depth_stencil; 561 } 562 563 static void 564 cso_restore_depth_stencil_alpha(struct cso_context *ctx) 565 { 566 if (ctx->depth_stencil != ctx->depth_stencil_saved) { 567 ctx->depth_stencil = ctx->depth_stencil_saved; 568 ctx->pipe->bind_depth_stencil_alpha_state(ctx->pipe, 569 ctx->depth_stencil_saved); 570 } 571 ctx->depth_stencil_saved = NULL; 572 } 573 574 575 576 enum pipe_error cso_set_rasterizer(struct cso_context *ctx, 577 const struct pipe_rasterizer_state *templ) 578 { 579 unsigned key_size = sizeof(struct pipe_rasterizer_state); 580 unsigned hash_key = cso_construct_key((void*)templ, key_size); 581 struct cso_hash_iter iter = cso_find_state_template(ctx->cache, 582 hash_key, 583 CSO_RASTERIZER, 584 (void*)templ, key_size); 585 void *handle = NULL; 586 587 if (cso_hash_iter_is_null(iter)) { 588 struct cso_rasterizer *cso = MALLOC(sizeof(struct cso_rasterizer)); 589 if (!cso) 590 return PIPE_ERROR_OUT_OF_MEMORY; 591 592 memcpy(&cso->state, templ, sizeof(*templ)); 593 cso->data = ctx->pipe->create_rasterizer_state(ctx->pipe, &cso->state); 594 cso->delete_state = 595 (cso_state_callback)ctx->pipe->delete_rasterizer_state; 596 cso->context = ctx->pipe; 597 598 iter = cso_insert_state(ctx->cache, hash_key, CSO_RASTERIZER, cso); 599 if (cso_hash_iter_is_null(iter)) { 600 FREE(cso); 601 return PIPE_ERROR_OUT_OF_MEMORY; 602 } 603 604 handle = cso->data; 605 } 606 else { 607 handle = ((struct cso_rasterizer *)cso_hash_iter_data(iter))->data; 608 } 609 610 if (ctx->rasterizer != handle) { 611 ctx->rasterizer = handle; 612 ctx->pipe->bind_rasterizer_state(ctx->pipe, handle); 613 } 614 return PIPE_OK; 615 } 616 617 static void 618 cso_save_rasterizer(struct cso_context *ctx) 619 { 620 assert(!ctx->rasterizer_saved); 621 ctx->rasterizer_saved = ctx->rasterizer; 622 } 623 624 static void 625 cso_restore_rasterizer(struct cso_context *ctx) 626 { 627 if (ctx->rasterizer != ctx->rasterizer_saved) { 628 ctx->rasterizer = ctx->rasterizer_saved; 629 ctx->pipe->bind_rasterizer_state(ctx->pipe, ctx->rasterizer_saved); 630 } 631 ctx->rasterizer_saved = NULL; 632 } 633 634 635 void cso_set_fragment_shader_handle(struct cso_context *ctx, void *handle ) 636 { 637 if (ctx->fragment_shader != handle) { 638 ctx->fragment_shader = handle; 639 ctx->pipe->bind_fs_state(ctx->pipe, handle); 640 } 641 } 642 643 void cso_delete_fragment_shader(struct cso_context *ctx, void *handle ) 644 { 645 if (handle == ctx->fragment_shader) { 646 /* unbind before deleting */ 647 ctx->pipe->bind_fs_state(ctx->pipe, NULL); 648 ctx->fragment_shader = NULL; 649 } 650 ctx->pipe->delete_fs_state(ctx->pipe, handle); 651 } 652 653 static void 654 cso_save_fragment_shader(struct cso_context *ctx) 655 { 656 assert(!ctx->fragment_shader_saved); 657 ctx->fragment_shader_saved = ctx->fragment_shader; 658 } 659 660 static void 661 cso_restore_fragment_shader(struct cso_context *ctx) 662 { 663 if (ctx->fragment_shader_saved != ctx->fragment_shader) { 664 ctx->pipe->bind_fs_state(ctx->pipe, ctx->fragment_shader_saved); 665 ctx->fragment_shader = ctx->fragment_shader_saved; 666 } 667 ctx->fragment_shader_saved = NULL; 668 } 669 670 671 void cso_set_vertex_shader_handle(struct cso_context *ctx, void *handle) 672 { 673 if (ctx->vertex_shader != handle) { 674 ctx->vertex_shader = handle; 675 ctx->pipe->bind_vs_state(ctx->pipe, handle); 676 } 677 } 678 679 void cso_delete_vertex_shader(struct cso_context *ctx, void *handle ) 680 { 681 if (handle == ctx->vertex_shader) { 682 /* unbind before deleting */ 683 ctx->pipe->bind_vs_state(ctx->pipe, NULL); 684 ctx->vertex_shader = NULL; 685 } 686 ctx->pipe->delete_vs_state(ctx->pipe, handle); 687 } 688 689 static void 690 cso_save_vertex_shader(struct cso_context *ctx) 691 { 692 assert(!ctx->vertex_shader_saved); 693 ctx->vertex_shader_saved = ctx->vertex_shader; 694 } 695 696 static void 697 cso_restore_vertex_shader(struct cso_context *ctx) 698 { 699 if (ctx->vertex_shader_saved != ctx->vertex_shader) { 700 ctx->pipe->bind_vs_state(ctx->pipe, ctx->vertex_shader_saved); 701 ctx->vertex_shader = ctx->vertex_shader_saved; 702 } 703 ctx->vertex_shader_saved = NULL; 704 } 705 706 707 void cso_set_framebuffer(struct cso_context *ctx, 708 const struct pipe_framebuffer_state *fb) 709 { 710 if (memcmp(&ctx->fb, fb, sizeof(*fb)) != 0) { 711 util_copy_framebuffer_state(&ctx->fb, fb); 712 ctx->pipe->set_framebuffer_state(ctx->pipe, fb); 713 } 714 } 715 716 static void 717 cso_save_framebuffer(struct cso_context *ctx) 718 { 719 util_copy_framebuffer_state(&ctx->fb_saved, &ctx->fb); 720 } 721 722 static void 723 cso_restore_framebuffer(struct cso_context *ctx) 724 { 725 if (memcmp(&ctx->fb, &ctx->fb_saved, sizeof(ctx->fb))) { 726 util_copy_framebuffer_state(&ctx->fb, &ctx->fb_saved); 727 ctx->pipe->set_framebuffer_state(ctx->pipe, &ctx->fb); 728 util_unreference_framebuffer_state(&ctx->fb_saved); 729 } 730 } 731 732 733 void cso_set_viewport(struct cso_context *ctx, 734 const struct pipe_viewport_state *vp) 735 { 736 if (memcmp(&ctx->vp, vp, sizeof(*vp))) { 737 ctx->vp = *vp; 738 ctx->pipe->set_viewport_states(ctx->pipe, 0, 1, vp); 739 } 740 } 741 742 /** 743 * Setup viewport state for given width and height (position is always (0,0)). 744 * Invert the Y axis if 'invert' is true. 745 */ 746 void 747 cso_set_viewport_dims(struct cso_context *ctx, 748 float width, float height, boolean invert) 749 { 750 struct pipe_viewport_state vp; 751 vp.scale[0] = width * 0.5f; 752 vp.scale[1] = height * (invert ? -0.5f : 0.5f); 753 vp.scale[2] = 0.5f; 754 vp.translate[0] = 0.5f * width; 755 vp.translate[1] = 0.5f * height; 756 vp.translate[2] = 0.5f; 757 cso_set_viewport(ctx, &vp); 758 } 759 760 static void 761 cso_save_viewport(struct cso_context *ctx) 762 { 763 ctx->vp_saved = ctx->vp; 764 } 765 766 767 static void 768 cso_restore_viewport(struct cso_context *ctx) 769 { 770 if (memcmp(&ctx->vp, &ctx->vp_saved, sizeof(ctx->vp))) { 771 ctx->vp = ctx->vp_saved; 772 ctx->pipe->set_viewport_states(ctx->pipe, 0, 1, &ctx->vp); 773 } 774 } 775 776 777 void cso_set_blend_color(struct cso_context *ctx, 778 const struct pipe_blend_color *bc) 779 { 780 if (memcmp(&ctx->blend_color, bc, sizeof(ctx->blend_color))) { 781 ctx->blend_color = *bc; 782 ctx->pipe->set_blend_color(ctx->pipe, bc); 783 } 784 } 785 786 void cso_set_sample_mask(struct cso_context *ctx, unsigned sample_mask) 787 { 788 if (ctx->sample_mask != sample_mask) { 789 ctx->sample_mask = sample_mask; 790 ctx->pipe->set_sample_mask(ctx->pipe, sample_mask); 791 } 792 } 793 794 static void 795 cso_save_sample_mask(struct cso_context *ctx) 796 { 797 ctx->sample_mask_saved = ctx->sample_mask; 798 } 799 800 static void 801 cso_restore_sample_mask(struct cso_context *ctx) 802 { 803 cso_set_sample_mask(ctx, ctx->sample_mask_saved); 804 } 805 806 void cso_set_min_samples(struct cso_context *ctx, unsigned min_samples) 807 { 808 if (ctx->min_samples != min_samples && ctx->pipe->set_min_samples) { 809 ctx->min_samples = min_samples; 810 ctx->pipe->set_min_samples(ctx->pipe, min_samples); 811 } 812 } 813 814 static void 815 cso_save_min_samples(struct cso_context *ctx) 816 { 817 ctx->min_samples_saved = ctx->min_samples; 818 } 819 820 static void 821 cso_restore_min_samples(struct cso_context *ctx) 822 { 823 cso_set_min_samples(ctx, ctx->min_samples_saved); 824 } 825 826 void cso_set_stencil_ref(struct cso_context *ctx, 827 const struct pipe_stencil_ref *sr) 828 { 829 if (memcmp(&ctx->stencil_ref, sr, sizeof(ctx->stencil_ref))) { 830 ctx->stencil_ref = *sr; 831 ctx->pipe->set_stencil_ref(ctx->pipe, sr); 832 } 833 } 834 835 static void 836 cso_save_stencil_ref(struct cso_context *ctx) 837 { 838 ctx->stencil_ref_saved = ctx->stencil_ref; 839 } 840 841 842 static void 843 cso_restore_stencil_ref(struct cso_context *ctx) 844 { 845 if (memcmp(&ctx->stencil_ref, &ctx->stencil_ref_saved, 846 sizeof(ctx->stencil_ref))) { 847 ctx->stencil_ref = ctx->stencil_ref_saved; 848 ctx->pipe->set_stencil_ref(ctx->pipe, &ctx->stencil_ref); 849 } 850 } 851 852 void cso_set_render_condition(struct cso_context *ctx, 853 struct pipe_query *query, 854 boolean condition, uint mode) 855 { 856 struct pipe_context *pipe = ctx->pipe; 857 858 if (ctx->render_condition != query || 859 ctx->render_condition_mode != mode || 860 ctx->render_condition_cond != condition) { 861 pipe->render_condition(pipe, query, condition, mode); 862 ctx->render_condition = query; 863 ctx->render_condition_cond = condition; 864 ctx->render_condition_mode = mode; 865 } 866 } 867 868 static void 869 cso_save_render_condition(struct cso_context *ctx) 870 { 871 ctx->render_condition_saved = ctx->render_condition; 872 ctx->render_condition_cond_saved = ctx->render_condition_cond; 873 ctx->render_condition_mode_saved = ctx->render_condition_mode; 874 } 875 876 static void 877 cso_restore_render_condition(struct cso_context *ctx) 878 { 879 cso_set_render_condition(ctx, ctx->render_condition_saved, 880 ctx->render_condition_cond_saved, 881 ctx->render_condition_mode_saved); 882 } 883 884 void cso_set_geometry_shader_handle(struct cso_context *ctx, void *handle) 885 { 886 assert(ctx->has_geometry_shader || !handle); 887 888 if (ctx->has_geometry_shader && ctx->geometry_shader != handle) { 889 ctx->geometry_shader = handle; 890 ctx->pipe->bind_gs_state(ctx->pipe, handle); 891 } 892 } 893 894 void cso_delete_geometry_shader(struct cso_context *ctx, void *handle) 895 { 896 if (handle == ctx->geometry_shader) { 897 /* unbind before deleting */ 898 ctx->pipe->bind_gs_state(ctx->pipe, NULL); 899 ctx->geometry_shader = NULL; 900 } 901 ctx->pipe->delete_gs_state(ctx->pipe, handle); 902 } 903 904 static void 905 cso_save_geometry_shader(struct cso_context *ctx) 906 { 907 if (!ctx->has_geometry_shader) { 908 return; 909 } 910 911 assert(!ctx->geometry_shader_saved); 912 ctx->geometry_shader_saved = ctx->geometry_shader; 913 } 914 915 static void 916 cso_restore_geometry_shader(struct cso_context *ctx) 917 { 918 if (!ctx->has_geometry_shader) { 919 return; 920 } 921 922 if (ctx->geometry_shader_saved != ctx->geometry_shader) { 923 ctx->pipe->bind_gs_state(ctx->pipe, ctx->geometry_shader_saved); 924 ctx->geometry_shader = ctx->geometry_shader_saved; 925 } 926 ctx->geometry_shader_saved = NULL; 927 } 928 929 void cso_set_tessctrl_shader_handle(struct cso_context *ctx, void *handle) 930 { 931 assert(ctx->has_tessellation || !handle); 932 933 if (ctx->has_tessellation && ctx->tessctrl_shader != handle) { 934 ctx->tessctrl_shader = handle; 935 ctx->pipe->bind_tcs_state(ctx->pipe, handle); 936 } 937 } 938 939 void cso_delete_tessctrl_shader(struct cso_context *ctx, void *handle) 940 { 941 if (handle == ctx->tessctrl_shader) { 942 /* unbind before deleting */ 943 ctx->pipe->bind_tcs_state(ctx->pipe, NULL); 944 ctx->tessctrl_shader = NULL; 945 } 946 ctx->pipe->delete_tcs_state(ctx->pipe, handle); 947 } 948 949 static void 950 cso_save_tessctrl_shader(struct cso_context *ctx) 951 { 952 if (!ctx->has_tessellation) { 953 return; 954 } 955 956 assert(!ctx->tessctrl_shader_saved); 957 ctx->tessctrl_shader_saved = ctx->tessctrl_shader; 958 } 959 960 static void 961 cso_restore_tessctrl_shader(struct cso_context *ctx) 962 { 963 if (!ctx->has_tessellation) { 964 return; 965 } 966 967 if (ctx->tessctrl_shader_saved != ctx->tessctrl_shader) { 968 ctx->pipe->bind_tcs_state(ctx->pipe, ctx->tessctrl_shader_saved); 969 ctx->tessctrl_shader = ctx->tessctrl_shader_saved; 970 } 971 ctx->tessctrl_shader_saved = NULL; 972 } 973 974 void cso_set_tesseval_shader_handle(struct cso_context *ctx, void *handle) 975 { 976 assert(ctx->has_tessellation || !handle); 977 978 if (ctx->has_tessellation && ctx->tesseval_shader != handle) { 979 ctx->tesseval_shader = handle; 980 ctx->pipe->bind_tes_state(ctx->pipe, handle); 981 } 982 } 983 984 void cso_delete_tesseval_shader(struct cso_context *ctx, void *handle) 985 { 986 if (handle == ctx->tesseval_shader) { 987 /* unbind before deleting */ 988 ctx->pipe->bind_tes_state(ctx->pipe, NULL); 989 ctx->tesseval_shader = NULL; 990 } 991 ctx->pipe->delete_tes_state(ctx->pipe, handle); 992 } 993 994 static void 995 cso_save_tesseval_shader(struct cso_context *ctx) 996 { 997 if (!ctx->has_tessellation) { 998 return; 999 } 1000 1001 assert(!ctx->tesseval_shader_saved); 1002 ctx->tesseval_shader_saved = ctx->tesseval_shader; 1003 } 1004 1005 static void 1006 cso_restore_tesseval_shader(struct cso_context *ctx) 1007 { 1008 if (!ctx->has_tessellation) { 1009 return; 1010 } 1011 1012 if (ctx->tesseval_shader_saved != ctx->tesseval_shader) { 1013 ctx->pipe->bind_tes_state(ctx->pipe, ctx->tesseval_shader_saved); 1014 ctx->tesseval_shader = ctx->tesseval_shader_saved; 1015 } 1016 ctx->tesseval_shader_saved = NULL; 1017 } 1018 1019 void cso_set_compute_shader_handle(struct cso_context *ctx, void *handle) 1020 { 1021 assert(ctx->has_compute_shader || !handle); 1022 1023 if (ctx->has_compute_shader && ctx->compute_shader != handle) { 1024 ctx->compute_shader = handle; 1025 ctx->pipe->bind_compute_state(ctx->pipe, handle); 1026 } 1027 } 1028 1029 void cso_delete_compute_shader(struct cso_context *ctx, void *handle) 1030 { 1031 if (handle == ctx->compute_shader) { 1032 /* unbind before deleting */ 1033 ctx->pipe->bind_compute_state(ctx->pipe, NULL); 1034 ctx->compute_shader = NULL; 1035 } 1036 ctx->pipe->delete_compute_state(ctx->pipe, handle); 1037 } 1038 1039 enum pipe_error 1040 cso_set_vertex_elements(struct cso_context *ctx, 1041 unsigned count, 1042 const struct pipe_vertex_element *states) 1043 { 1044 struct u_vbuf *vbuf = ctx->vbuf; 1045 unsigned key_size, hash_key; 1046 struct cso_hash_iter iter; 1047 void *handle; 1048 struct cso_velems_state velems_state; 1049 1050 if (vbuf) { 1051 u_vbuf_set_vertex_elements(vbuf, count, states); 1052 return PIPE_OK; 1053 } 1054 1055 /* Need to include the count into the stored state data too. 1056 * Otherwise first few count pipe_vertex_elements could be identical 1057 * even if count is different, and there's no guarantee the hash would 1058 * be different in that case neither. 1059 */ 1060 key_size = sizeof(struct pipe_vertex_element) * count + sizeof(unsigned); 1061 velems_state.count = count; 1062 memcpy(velems_state.velems, states, 1063 sizeof(struct pipe_vertex_element) * count); 1064 hash_key = cso_construct_key((void*)&velems_state, key_size); 1065 iter = cso_find_state_template(ctx->cache, hash_key, CSO_VELEMENTS, 1066 (void*)&velems_state, key_size); 1067 1068 if (cso_hash_iter_is_null(iter)) { 1069 struct cso_velements *cso = MALLOC(sizeof(struct cso_velements)); 1070 if (!cso) 1071 return PIPE_ERROR_OUT_OF_MEMORY; 1072 1073 memcpy(&cso->state, &velems_state, key_size); 1074 cso->data = ctx->pipe->create_vertex_elements_state(ctx->pipe, count, 1075 &cso->state.velems[0]); 1076 cso->delete_state = 1077 (cso_state_callback) ctx->pipe->delete_vertex_elements_state; 1078 cso->context = ctx->pipe; 1079 1080 iter = cso_insert_state(ctx->cache, hash_key, CSO_VELEMENTS, cso); 1081 if (cso_hash_iter_is_null(iter)) { 1082 FREE(cso); 1083 return PIPE_ERROR_OUT_OF_MEMORY; 1084 } 1085 1086 handle = cso->data; 1087 } 1088 else { 1089 handle = ((struct cso_velements *)cso_hash_iter_data(iter))->data; 1090 } 1091 1092 if (ctx->velements != handle) { 1093 ctx->velements = handle; 1094 ctx->pipe->bind_vertex_elements_state(ctx->pipe, handle); 1095 } 1096 return PIPE_OK; 1097 } 1098 1099 static void 1100 cso_save_vertex_elements(struct cso_context *ctx) 1101 { 1102 struct u_vbuf *vbuf = ctx->vbuf; 1103 1104 if (vbuf) { 1105 u_vbuf_save_vertex_elements(vbuf); 1106 return; 1107 } 1108 1109 assert(!ctx->velements_saved); 1110 ctx->velements_saved = ctx->velements; 1111 } 1112 1113 static void 1114 cso_restore_vertex_elements(struct cso_context *ctx) 1115 { 1116 struct u_vbuf *vbuf = ctx->vbuf; 1117 1118 if (vbuf) { 1119 u_vbuf_restore_vertex_elements(vbuf); 1120 return; 1121 } 1122 1123 if (ctx->velements != ctx->velements_saved) { 1124 ctx->velements = ctx->velements_saved; 1125 ctx->pipe->bind_vertex_elements_state(ctx->pipe, ctx->velements_saved); 1126 } 1127 ctx->velements_saved = NULL; 1128 } 1129 1130 /* vertex buffers */ 1131 1132 void cso_set_vertex_buffers(struct cso_context *ctx, 1133 unsigned start_slot, unsigned count, 1134 const struct pipe_vertex_buffer *buffers) 1135 { 1136 struct u_vbuf *vbuf = ctx->vbuf; 1137 1138 if (vbuf) { 1139 u_vbuf_set_vertex_buffers(vbuf, start_slot, count, buffers); 1140 return; 1141 } 1142 1143 /* Save what's in the auxiliary slot, so that we can save and restore it 1144 * for meta ops. */ 1145 if (start_slot <= ctx->aux_vertex_buffer_index && 1146 start_slot+count > ctx->aux_vertex_buffer_index) { 1147 if (buffers) { 1148 const struct pipe_vertex_buffer *vb = 1149 buffers + (ctx->aux_vertex_buffer_index - start_slot); 1150 1151 pipe_resource_reference(&ctx->aux_vertex_buffer_current.buffer, 1152 vb->buffer); 1153 memcpy(&ctx->aux_vertex_buffer_current, vb, 1154 sizeof(struct pipe_vertex_buffer)); 1155 } 1156 else { 1157 pipe_resource_reference(&ctx->aux_vertex_buffer_current.buffer, 1158 NULL); 1159 ctx->aux_vertex_buffer_current.user_buffer = NULL; 1160 } 1161 } 1162 1163 ctx->pipe->set_vertex_buffers(ctx->pipe, start_slot, count, buffers); 1164 } 1165 1166 static void 1167 cso_save_aux_vertex_buffer_slot(struct cso_context *ctx) 1168 { 1169 struct u_vbuf *vbuf = ctx->vbuf; 1170 1171 if (vbuf) { 1172 u_vbuf_save_aux_vertex_buffer_slot(vbuf); 1173 return; 1174 } 1175 1176 pipe_resource_reference(&ctx->aux_vertex_buffer_saved.buffer, 1177 ctx->aux_vertex_buffer_current.buffer); 1178 memcpy(&ctx->aux_vertex_buffer_saved, &ctx->aux_vertex_buffer_current, 1179 sizeof(struct pipe_vertex_buffer)); 1180 } 1181 1182 static void 1183 cso_restore_aux_vertex_buffer_slot(struct cso_context *ctx) 1184 { 1185 struct u_vbuf *vbuf = ctx->vbuf; 1186 1187 if (vbuf) { 1188 u_vbuf_restore_aux_vertex_buffer_slot(vbuf); 1189 return; 1190 } 1191 1192 cso_set_vertex_buffers(ctx, ctx->aux_vertex_buffer_index, 1, 1193 &ctx->aux_vertex_buffer_saved); 1194 pipe_resource_reference(&ctx->aux_vertex_buffer_saved.buffer, NULL); 1195 } 1196 1197 unsigned cso_get_aux_vertex_buffer_slot(struct cso_context *ctx) 1198 { 1199 return ctx->aux_vertex_buffer_index; 1200 } 1201 1202 1203 1204 enum pipe_error 1205 cso_single_sampler(struct cso_context *ctx, unsigned shader_stage, 1206 unsigned idx, const struct pipe_sampler_state *templ) 1207 { 1208 if (templ) { 1209 unsigned key_size = sizeof(struct pipe_sampler_state); 1210 unsigned hash_key = cso_construct_key((void*)templ, key_size); 1211 struct cso_sampler *cso; 1212 struct cso_hash_iter iter = 1213 cso_find_state_template(ctx->cache, 1214 hash_key, CSO_SAMPLER, 1215 (void *) templ, key_size); 1216 1217 if (cso_hash_iter_is_null(iter)) { 1218 cso = MALLOC(sizeof(struct cso_sampler)); 1219 if (!cso) 1220 return PIPE_ERROR_OUT_OF_MEMORY; 1221 1222 memcpy(&cso->state, templ, sizeof(*templ)); 1223 cso->data = ctx->pipe->create_sampler_state(ctx->pipe, &cso->state); 1224 cso->delete_state = 1225 (cso_state_callback) ctx->pipe->delete_sampler_state; 1226 cso->context = ctx->pipe; 1227 cso->hash_key = hash_key; 1228 1229 iter = cso_insert_state(ctx->cache, hash_key, CSO_SAMPLER, cso); 1230 if (cso_hash_iter_is_null(iter)) { 1231 FREE(cso); 1232 return PIPE_ERROR_OUT_OF_MEMORY; 1233 } 1234 } 1235 else { 1236 cso = cso_hash_iter_data(iter); 1237 } 1238 1239 ctx->samplers[shader_stage].cso_samplers[idx] = cso; 1240 ctx->samplers[shader_stage].samplers[idx] = cso->data; 1241 } else { 1242 ctx->samplers[shader_stage].cso_samplers[idx] = NULL; 1243 ctx->samplers[shader_stage].samplers[idx] = NULL; 1244 } 1245 1246 return PIPE_OK; 1247 } 1248 1249 1250 /** 1251 * Send staged sampler state to the driver. 1252 */ 1253 void 1254 cso_single_sampler_done(struct cso_context *ctx, 1255 enum pipe_shader_type shader_stage) 1256 { 1257 struct sampler_info *info = &ctx->samplers[shader_stage]; 1258 const unsigned old_nr_samplers = info->nr_samplers; 1259 unsigned i; 1260 1261 /* find highest non-null sampler */ 1262 for (i = PIPE_MAX_SAMPLERS; i > 0; i--) { 1263 if (info->samplers[i - 1] != NULL) 1264 break; 1265 } 1266 1267 info->nr_samplers = i; 1268 ctx->pipe->bind_sampler_states(ctx->pipe, shader_stage, 0, 1269 MAX2(old_nr_samplers, info->nr_samplers), 1270 info->samplers); 1271 } 1272 1273 1274 /* 1275 * If the function encouters any errors it will return the 1276 * last one. Done to always try to set as many samplers 1277 * as possible. 1278 */ 1279 enum pipe_error 1280 cso_set_samplers(struct cso_context *ctx, 1281 enum pipe_shader_type shader_stage, 1282 unsigned nr, 1283 const struct pipe_sampler_state **templates) 1284 { 1285 struct sampler_info *info = &ctx->samplers[shader_stage]; 1286 unsigned i; 1287 enum pipe_error temp, error = PIPE_OK; 1288 1289 for (i = 0; i < nr; i++) { 1290 temp = cso_single_sampler(ctx, shader_stage, i, templates[i]); 1291 if (temp != PIPE_OK) 1292 error = temp; 1293 } 1294 1295 for ( ; i < info->nr_samplers; i++) { 1296 temp = cso_single_sampler(ctx, shader_stage, i, NULL); 1297 if (temp != PIPE_OK) 1298 error = temp; 1299 } 1300 1301 cso_single_sampler_done(ctx, shader_stage); 1302 1303 return error; 1304 } 1305 1306 static void 1307 cso_save_fragment_samplers(struct cso_context *ctx) 1308 { 1309 struct sampler_info *info = &ctx->samplers[PIPE_SHADER_FRAGMENT]; 1310 struct sampler_info *saved = &ctx->fragment_samplers_saved; 1311 1312 saved->nr_samplers = info->nr_samplers; 1313 memcpy(saved->cso_samplers, info->cso_samplers, info->nr_samplers * 1314 sizeof(*info->cso_samplers)); 1315 memcpy(saved->samplers, info->samplers, info->nr_samplers * 1316 sizeof(*info->samplers)); 1317 } 1318 1319 1320 static void 1321 cso_restore_fragment_samplers(struct cso_context *ctx) 1322 { 1323 struct sampler_info *info = &ctx->samplers[PIPE_SHADER_FRAGMENT]; 1324 struct sampler_info *saved = &ctx->fragment_samplers_saved; 1325 int delta = (int)info->nr_samplers - saved->nr_samplers; 1326 1327 memcpy(info->cso_samplers, saved->cso_samplers, 1328 saved->nr_samplers * sizeof(*info->cso_samplers)); 1329 memcpy(info->samplers, saved->samplers, 1330 saved->nr_samplers * sizeof(*info->samplers)); 1331 1332 if (delta > 0) { 1333 memset(&info->cso_samplers[saved->nr_samplers], 0, 1334 delta * sizeof(*info->cso_samplers)); 1335 memset(&info->samplers[saved->nr_samplers], 0, 1336 delta * sizeof(*info->samplers)); 1337 } 1338 1339 cso_single_sampler_done(ctx, PIPE_SHADER_FRAGMENT); 1340 } 1341 1342 1343 void 1344 cso_set_sampler_views(struct cso_context *ctx, 1345 enum pipe_shader_type shader_stage, 1346 unsigned count, 1347 struct pipe_sampler_view **views) 1348 { 1349 if (shader_stage == PIPE_SHADER_FRAGMENT) { 1350 unsigned i; 1351 boolean any_change = FALSE; 1352 1353 /* reference new views */ 1354 for (i = 0; i < count; i++) { 1355 any_change |= ctx->fragment_views[i] != views[i]; 1356 pipe_sampler_view_reference(&ctx->fragment_views[i], views[i]); 1357 } 1358 /* unref extra old views, if any */ 1359 for (; i < ctx->nr_fragment_views; i++) { 1360 any_change |= ctx->fragment_views[i] != NULL; 1361 pipe_sampler_view_reference(&ctx->fragment_views[i], NULL); 1362 } 1363 1364 /* bind the new sampler views */ 1365 if (any_change) { 1366 ctx->pipe->set_sampler_views(ctx->pipe, shader_stage, 0, 1367 MAX2(ctx->nr_fragment_views, count), 1368 ctx->fragment_views); 1369 } 1370 1371 ctx->nr_fragment_views = count; 1372 } 1373 else 1374 ctx->pipe->set_sampler_views(ctx->pipe, shader_stage, 0, count, views); 1375 } 1376 1377 1378 static void 1379 cso_save_fragment_sampler_views(struct cso_context *ctx) 1380 { 1381 unsigned i; 1382 1383 ctx->nr_fragment_views_saved = ctx->nr_fragment_views; 1384 1385 for (i = 0; i < ctx->nr_fragment_views; i++) { 1386 assert(!ctx->fragment_views_saved[i]); 1387 pipe_sampler_view_reference(&ctx->fragment_views_saved[i], 1388 ctx->fragment_views[i]); 1389 } 1390 } 1391 1392 1393 static void 1394 cso_restore_fragment_sampler_views(struct cso_context *ctx) 1395 { 1396 unsigned i, nr_saved = ctx->nr_fragment_views_saved; 1397 unsigned num; 1398 1399 for (i = 0; i < nr_saved; i++) { 1400 pipe_sampler_view_reference(&ctx->fragment_views[i], NULL); 1401 /* move the reference from one pointer to another */ 1402 ctx->fragment_views[i] = ctx->fragment_views_saved[i]; 1403 ctx->fragment_views_saved[i] = NULL; 1404 } 1405 for (; i < ctx->nr_fragment_views; i++) { 1406 pipe_sampler_view_reference(&ctx->fragment_views[i], NULL); 1407 } 1408 1409 num = MAX2(ctx->nr_fragment_views, nr_saved); 1410 1411 /* bind the old/saved sampler views */ 1412 ctx->pipe->set_sampler_views(ctx->pipe, PIPE_SHADER_FRAGMENT, 0, num, 1413 ctx->fragment_views); 1414 1415 ctx->nr_fragment_views = nr_saved; 1416 ctx->nr_fragment_views_saved = 0; 1417 } 1418 1419 1420 void 1421 cso_set_shader_images(struct cso_context *ctx, 1422 enum pipe_shader_type shader_stage, 1423 unsigned start, unsigned count, 1424 struct pipe_image_view *images) 1425 { 1426 if (shader_stage == PIPE_SHADER_FRAGMENT && start == 0 && count >= 1) { 1427 util_copy_image_view(&ctx->fragment_image0_current, &images[0]); 1428 } 1429 1430 ctx->pipe->set_shader_images(ctx->pipe, shader_stage, start, count, images); 1431 } 1432 1433 1434 static void 1435 cso_save_fragment_image0(struct cso_context *ctx) 1436 { 1437 util_copy_image_view(&ctx->fragment_image0_saved, 1438 &ctx->fragment_image0_current); 1439 } 1440 1441 1442 static void 1443 cso_restore_fragment_image0(struct cso_context *ctx) 1444 { 1445 cso_set_shader_images(ctx, PIPE_SHADER_FRAGMENT, 0, 1, 1446 &ctx->fragment_image0_saved); 1447 } 1448 1449 1450 void 1451 cso_set_stream_outputs(struct cso_context *ctx, 1452 unsigned num_targets, 1453 struct pipe_stream_output_target **targets, 1454 const unsigned *offsets) 1455 { 1456 struct pipe_context *pipe = ctx->pipe; 1457 uint i; 1458 1459 if (!ctx->has_streamout) { 1460 assert(num_targets == 0); 1461 return; 1462 } 1463 1464 if (ctx->nr_so_targets == 0 && num_targets == 0) { 1465 /* Nothing to do. */ 1466 return; 1467 } 1468 1469 /* reference new targets */ 1470 for (i = 0; i < num_targets; i++) { 1471 pipe_so_target_reference(&ctx->so_targets[i], targets[i]); 1472 } 1473 /* unref extra old targets, if any */ 1474 for (; i < ctx->nr_so_targets; i++) { 1475 pipe_so_target_reference(&ctx->so_targets[i], NULL); 1476 } 1477 1478 pipe->set_stream_output_targets(pipe, num_targets, targets, 1479 offsets); 1480 ctx->nr_so_targets = num_targets; 1481 } 1482 1483 static void 1484 cso_save_stream_outputs(struct cso_context *ctx) 1485 { 1486 uint i; 1487 1488 if (!ctx->has_streamout) { 1489 return; 1490 } 1491 1492 ctx->nr_so_targets_saved = ctx->nr_so_targets; 1493 1494 for (i = 0; i < ctx->nr_so_targets; i++) { 1495 assert(!ctx->so_targets_saved[i]); 1496 pipe_so_target_reference(&ctx->so_targets_saved[i], ctx->so_targets[i]); 1497 } 1498 } 1499 1500 static void 1501 cso_restore_stream_outputs(struct cso_context *ctx) 1502 { 1503 struct pipe_context *pipe = ctx->pipe; 1504 uint i; 1505 unsigned offset[PIPE_MAX_SO_BUFFERS]; 1506 1507 if (!ctx->has_streamout) { 1508 return; 1509 } 1510 1511 if (ctx->nr_so_targets == 0 && ctx->nr_so_targets_saved == 0) { 1512 /* Nothing to do. */ 1513 return; 1514 } 1515 1516 assert(ctx->nr_so_targets_saved <= PIPE_MAX_SO_BUFFERS); 1517 for (i = 0; i < ctx->nr_so_targets_saved; i++) { 1518 pipe_so_target_reference(&ctx->so_targets[i], NULL); 1519 /* move the reference from one pointer to another */ 1520 ctx->so_targets[i] = ctx->so_targets_saved[i]; 1521 ctx->so_targets_saved[i] = NULL; 1522 /* -1 means append */ 1523 offset[i] = (unsigned)-1; 1524 } 1525 for (; i < ctx->nr_so_targets; i++) { 1526 pipe_so_target_reference(&ctx->so_targets[i], NULL); 1527 } 1528 1529 pipe->set_stream_output_targets(pipe, ctx->nr_so_targets_saved, 1530 ctx->so_targets, offset); 1531 1532 ctx->nr_so_targets = ctx->nr_so_targets_saved; 1533 ctx->nr_so_targets_saved = 0; 1534 } 1535 1536 /* constant buffers */ 1537 1538 void 1539 cso_set_constant_buffer(struct cso_context *cso, unsigned shader_stage, 1540 unsigned index, struct pipe_constant_buffer *cb) 1541 { 1542 struct pipe_context *pipe = cso->pipe; 1543 1544 pipe->set_constant_buffer(pipe, shader_stage, index, cb); 1545 1546 if (index == 0) { 1547 util_copy_constant_buffer(&cso->aux_constbuf_current[shader_stage], cb); 1548 } 1549 } 1550 1551 void 1552 cso_set_constant_buffer_resource(struct cso_context *cso, 1553 unsigned shader_stage, 1554 unsigned index, 1555 struct pipe_resource *buffer) 1556 { 1557 if (buffer) { 1558 struct pipe_constant_buffer cb; 1559 cb.buffer = buffer; 1560 cb.buffer_offset = 0; 1561 cb.buffer_size = buffer->width0; 1562 cb.user_buffer = NULL; 1563 cso_set_constant_buffer(cso, shader_stage, index, &cb); 1564 } else { 1565 cso_set_constant_buffer(cso, shader_stage, index, NULL); 1566 } 1567 } 1568 1569 void 1570 cso_save_constant_buffer_slot0(struct cso_context *cso, 1571 unsigned shader_stage) 1572 { 1573 util_copy_constant_buffer(&cso->aux_constbuf_saved[shader_stage], 1574 &cso->aux_constbuf_current[shader_stage]); 1575 } 1576 1577 void 1578 cso_restore_constant_buffer_slot0(struct cso_context *cso, 1579 unsigned shader_stage) 1580 { 1581 cso_set_constant_buffer(cso, shader_stage, 0, 1582 &cso->aux_constbuf_saved[shader_stage]); 1583 pipe_resource_reference(&cso->aux_constbuf_saved[shader_stage].buffer, 1584 NULL); 1585 } 1586 1587 1588 /** 1589 * Save all the CSO state items specified by the state_mask bitmask 1590 * of CSO_BIT_x flags. 1591 */ 1592 void 1593 cso_save_state(struct cso_context *cso, unsigned state_mask) 1594 { 1595 assert(cso->saved_state == 0); 1596 1597 cso->saved_state = state_mask; 1598 1599 if (state_mask & CSO_BIT_AUX_VERTEX_BUFFER_SLOT) 1600 cso_save_aux_vertex_buffer_slot(cso); 1601 if (state_mask & CSO_BIT_BLEND) 1602 cso_save_blend(cso); 1603 if (state_mask & CSO_BIT_DEPTH_STENCIL_ALPHA) 1604 cso_save_depth_stencil_alpha(cso); 1605 if (state_mask & CSO_BIT_FRAGMENT_SAMPLERS) 1606 cso_save_fragment_samplers(cso); 1607 if (state_mask & CSO_BIT_FRAGMENT_SAMPLER_VIEWS) 1608 cso_save_fragment_sampler_views(cso); 1609 if (state_mask & CSO_BIT_FRAGMENT_SHADER) 1610 cso_save_fragment_shader(cso); 1611 if (state_mask & CSO_BIT_FRAMEBUFFER) 1612 cso_save_framebuffer(cso); 1613 if (state_mask & CSO_BIT_GEOMETRY_SHADER) 1614 cso_save_geometry_shader(cso); 1615 if (state_mask & CSO_BIT_MIN_SAMPLES) 1616 cso_save_min_samples(cso); 1617 if (state_mask & CSO_BIT_RASTERIZER) 1618 cso_save_rasterizer(cso); 1619 if (state_mask & CSO_BIT_RENDER_CONDITION) 1620 cso_save_render_condition(cso); 1621 if (state_mask & CSO_BIT_SAMPLE_MASK) 1622 cso_save_sample_mask(cso); 1623 if (state_mask & CSO_BIT_STENCIL_REF) 1624 cso_save_stencil_ref(cso); 1625 if (state_mask & CSO_BIT_STREAM_OUTPUTS) 1626 cso_save_stream_outputs(cso); 1627 if (state_mask & CSO_BIT_TESSCTRL_SHADER) 1628 cso_save_tessctrl_shader(cso); 1629 if (state_mask & CSO_BIT_TESSEVAL_SHADER) 1630 cso_save_tesseval_shader(cso); 1631 if (state_mask & CSO_BIT_VERTEX_ELEMENTS) 1632 cso_save_vertex_elements(cso); 1633 if (state_mask & CSO_BIT_VERTEX_SHADER) 1634 cso_save_vertex_shader(cso); 1635 if (state_mask & CSO_BIT_VIEWPORT) 1636 cso_save_viewport(cso); 1637 if (state_mask & CSO_BIT_PAUSE_QUERIES) 1638 cso->pipe->set_active_query_state(cso->pipe, false); 1639 if (state_mask & CSO_BIT_FRAGMENT_IMAGE0) 1640 cso_save_fragment_image0(cso); 1641 } 1642 1643 1644 /** 1645 * Restore the state which was saved by cso_save_state(). 1646 */ 1647 void 1648 cso_restore_state(struct cso_context *cso) 1649 { 1650 unsigned state_mask = cso->saved_state; 1651 1652 assert(state_mask); 1653 1654 if (state_mask & CSO_BIT_AUX_VERTEX_BUFFER_SLOT) 1655 cso_restore_aux_vertex_buffer_slot(cso); 1656 if (state_mask & CSO_BIT_BLEND) 1657 cso_restore_blend(cso); 1658 if (state_mask & CSO_BIT_DEPTH_STENCIL_ALPHA) 1659 cso_restore_depth_stencil_alpha(cso); 1660 if (state_mask & CSO_BIT_FRAGMENT_SAMPLERS) 1661 cso_restore_fragment_samplers(cso); 1662 if (state_mask & CSO_BIT_FRAGMENT_SAMPLER_VIEWS) 1663 cso_restore_fragment_sampler_views(cso); 1664 if (state_mask & CSO_BIT_FRAGMENT_SHADER) 1665 cso_restore_fragment_shader(cso); 1666 if (state_mask & CSO_BIT_FRAMEBUFFER) 1667 cso_restore_framebuffer(cso); 1668 if (state_mask & CSO_BIT_GEOMETRY_SHADER) 1669 cso_restore_geometry_shader(cso); 1670 if (state_mask & CSO_BIT_MIN_SAMPLES) 1671 cso_restore_min_samples(cso); 1672 if (state_mask & CSO_BIT_RASTERIZER) 1673 cso_restore_rasterizer(cso); 1674 if (state_mask & CSO_BIT_RENDER_CONDITION) 1675 cso_restore_render_condition(cso); 1676 if (state_mask & CSO_BIT_SAMPLE_MASK) 1677 cso_restore_sample_mask(cso); 1678 if (state_mask & CSO_BIT_STENCIL_REF) 1679 cso_restore_stencil_ref(cso); 1680 if (state_mask & CSO_BIT_STREAM_OUTPUTS) 1681 cso_restore_stream_outputs(cso); 1682 if (state_mask & CSO_BIT_TESSCTRL_SHADER) 1683 cso_restore_tessctrl_shader(cso); 1684 if (state_mask & CSO_BIT_TESSEVAL_SHADER) 1685 cso_restore_tesseval_shader(cso); 1686 if (state_mask & CSO_BIT_VERTEX_ELEMENTS) 1687 cso_restore_vertex_elements(cso); 1688 if (state_mask & CSO_BIT_VERTEX_SHADER) 1689 cso_restore_vertex_shader(cso); 1690 if (state_mask & CSO_BIT_VIEWPORT) 1691 cso_restore_viewport(cso); 1692 if (state_mask & CSO_BIT_PAUSE_QUERIES) 1693 cso->pipe->set_active_query_state(cso->pipe, true); 1694 if (state_mask & CSO_BIT_FRAGMENT_IMAGE0) 1695 cso_restore_fragment_image0(cso); 1696 1697 cso->saved_state = 0; 1698 } 1699 1700 1701 1702 /* drawing */ 1703 1704 void 1705 cso_set_index_buffer(struct cso_context *cso, 1706 const struct pipe_index_buffer *ib) 1707 { 1708 struct u_vbuf *vbuf = cso->vbuf; 1709 1710 if (vbuf) { 1711 u_vbuf_set_index_buffer(vbuf, ib); 1712 } else { 1713 struct pipe_context *pipe = cso->pipe; 1714 pipe->set_index_buffer(pipe, ib); 1715 } 1716 } 1717 1718 void 1719 cso_draw_vbo(struct cso_context *cso, 1720 const struct pipe_draw_info *info) 1721 { 1722 struct u_vbuf *vbuf = cso->vbuf; 1723 1724 if (vbuf) { 1725 u_vbuf_draw_vbo(vbuf, info); 1726 } else { 1727 struct pipe_context *pipe = cso->pipe; 1728 pipe->draw_vbo(pipe, info); 1729 } 1730 } 1731 1732 void 1733 cso_draw_arrays(struct cso_context *cso, uint mode, uint start, uint count) 1734 { 1735 struct pipe_draw_info info; 1736 1737 util_draw_init_info(&info); 1738 1739 info.mode = mode; 1740 info.start = start; 1741 info.count = count; 1742 info.min_index = start; 1743 info.max_index = start + count - 1; 1744 1745 cso_draw_vbo(cso, &info); 1746 } 1747 1748 void 1749 cso_draw_arrays_instanced(struct cso_context *cso, uint mode, 1750 uint start, uint count, 1751 uint start_instance, uint instance_count) 1752 { 1753 struct pipe_draw_info info; 1754 1755 util_draw_init_info(&info); 1756 1757 info.mode = mode; 1758 info.start = start; 1759 info.count = count; 1760 info.min_index = start; 1761 info.max_index = start + count - 1; 1762 info.start_instance = start_instance; 1763 info.instance_count = instance_count; 1764 1765 cso_draw_vbo(cso, &info); 1766 } 1767
