1/************************************************************************** 2 * 3 * Copyright 2009 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 31#include "util/u_format.h" 32#include "util/u_memory.h" 33#include "util/u_inlines.h" 34 35#include "glhd_context.h" 36#include "glhd_objects.h" 37 38 39static void 40galahad_context_destroy(struct pipe_context *_pipe) 41{ 42 struct galahad_context *glhd_pipe = galahad_context(_pipe); 43 struct pipe_context *pipe = glhd_pipe->pipe; 44 45 pipe->destroy(pipe); 46 47 FREE(glhd_pipe); 48} 49 50static void 51galahad_context_draw_vbo(struct pipe_context *_pipe, 52 const struct pipe_draw_info *info) 53{ 54 struct galahad_context *glhd_pipe = galahad_context(_pipe); 55 struct pipe_context *pipe = glhd_pipe->pipe; 56 57 /* XXX we should check that all bound resources are unmapped 58 * before drawing. 59 */ 60 61 pipe->draw_vbo(pipe, info); 62} 63 64static struct pipe_query * 65galahad_context_create_query(struct pipe_context *_pipe, 66 unsigned query_type) 67{ 68 struct galahad_context *glhd_pipe = galahad_context(_pipe); 69 struct pipe_context *pipe = glhd_pipe->pipe; 70 71 if (query_type == PIPE_QUERY_OCCLUSION_COUNTER && 72 !pipe->screen->get_param(pipe->screen, PIPE_CAP_OCCLUSION_QUERY)) { 73 glhd_error("Occlusion query requested but not supported"); 74 } 75 76 if (query_type == PIPE_QUERY_TIME_ELAPSED && 77 !pipe->screen->get_param(pipe->screen, PIPE_CAP_TIMER_QUERY)) { 78 glhd_error("Timer query requested but not supported"); 79 } 80 81 return pipe->create_query(pipe, 82 query_type); 83} 84 85static void 86galahad_context_destroy_query(struct pipe_context *_pipe, 87 struct pipe_query *query) 88{ 89 struct galahad_context *glhd_pipe = galahad_context(_pipe); 90 struct pipe_context *pipe = glhd_pipe->pipe; 91 92 pipe->destroy_query(pipe, 93 query); 94} 95 96static void 97galahad_context_begin_query(struct pipe_context *_pipe, 98 struct pipe_query *query) 99{ 100 struct galahad_context *glhd_pipe = galahad_context(_pipe); 101 struct pipe_context *pipe = glhd_pipe->pipe; 102 103 pipe->begin_query(pipe, 104 query); 105} 106 107static void 108galahad_context_end_query(struct pipe_context *_pipe, 109 struct pipe_query *query) 110{ 111 struct galahad_context *glhd_pipe = galahad_context(_pipe); 112 struct pipe_context *pipe = glhd_pipe->pipe; 113 114 pipe->end_query(pipe, 115 query); 116} 117 118static boolean 119galahad_context_get_query_result(struct pipe_context *_pipe, 120 struct pipe_query *query, 121 boolean wait, 122 union pipe_query_result *result) 123{ 124 struct galahad_context *glhd_pipe = galahad_context(_pipe); 125 struct pipe_context *pipe = glhd_pipe->pipe; 126 127 return pipe->get_query_result(pipe, 128 query, 129 wait, 130 result); 131} 132 133static void * 134galahad_context_create_blend_state(struct pipe_context *_pipe, 135 const struct pipe_blend_state *blend) 136{ 137 struct galahad_context *glhd_pipe = galahad_context(_pipe); 138 struct pipe_context *pipe = glhd_pipe->pipe; 139 140 if (blend->logicop_enable) { 141 if (blend->rt[0].blend_enable) { 142 glhd_warn("Blending enabled for render target 0, but logicops " 143 "are enabled"); 144 } 145 } 146 147 return pipe->create_blend_state(pipe, 148 blend); 149} 150 151static void 152galahad_context_bind_blend_state(struct pipe_context *_pipe, 153 void *blend) 154{ 155 struct galahad_context *glhd_pipe = galahad_context(_pipe); 156 struct pipe_context *pipe = glhd_pipe->pipe; 157 158 pipe->bind_blend_state(pipe, 159 blend); 160} 161 162static void 163galahad_context_delete_blend_state(struct pipe_context *_pipe, 164 void *blend) 165{ 166 struct galahad_context *glhd_pipe = galahad_context(_pipe); 167 struct pipe_context *pipe = glhd_pipe->pipe; 168 169 pipe->delete_blend_state(pipe, 170 blend); 171} 172 173static void * 174galahad_context_create_sampler_state(struct pipe_context *_pipe, 175 const struct pipe_sampler_state *sampler) 176{ 177 struct galahad_context *glhd_pipe = galahad_context(_pipe); 178 struct pipe_context *pipe = glhd_pipe->pipe; 179 180 return pipe->create_sampler_state(pipe, 181 sampler); 182} 183 184static void 185galahad_context_bind_sampler_states(struct pipe_context *_pipe, 186 unsigned shader, 187 unsigned start, 188 unsigned num_samplers, 189 void **samplers) 190{ 191 struct galahad_context *glhd_pipe = galahad_context(_pipe); 192 struct pipe_context *pipe = glhd_pipe->pipe; 193 194 if (num_samplers > PIPE_MAX_SAMPLERS) { 195 glhd_error("%u samplers requested, " 196 "but only %u are permitted by API", 197 num_samplers, PIPE_MAX_SAMPLERS); 198 } 199 200 switch (shader) { 201 case PIPE_SHADER_VERTEX: 202 pipe->bind_vertex_sampler_states(pipe, num_samplers, samplers); 203 break; 204 case PIPE_SHADER_FRAGMENT: 205 pipe->bind_fragment_sampler_states(pipe, num_samplers, samplers); 206 break; 207 default: 208 assert(0); 209 } 210} 211 212static void 213galahad_context_bind_vertex_sampler_states(struct pipe_context *_pipe, 214 unsigned num_samplers, 215 void **samplers) 216{ 217 galahad_context_bind_sampler_states(_pipe, PIPE_SHADER_VERTEX, 218 0, num_samplers, samplers); 219} 220 221static void 222galahad_context_bind_fragment_sampler_states(struct pipe_context *_pipe, 223 unsigned num_samplers, 224 void **samplers) 225{ 226 galahad_context_bind_sampler_states(_pipe, PIPE_SHADER_FRAGMENT, 227 0, num_samplers, samplers); 228} 229 230 231static void 232galahad_context_delete_sampler_state(struct pipe_context *_pipe, 233 void *sampler) 234{ 235 struct galahad_context *glhd_pipe = galahad_context(_pipe); 236 struct pipe_context *pipe = glhd_pipe->pipe; 237 238 pipe->delete_sampler_state(pipe, 239 sampler); 240} 241 242static void * 243galahad_context_create_rasterizer_state(struct pipe_context *_pipe, 244 const struct pipe_rasterizer_state *rasterizer) 245{ 246 struct galahad_context *glhd_pipe = galahad_context(_pipe); 247 struct pipe_context *pipe = glhd_pipe->pipe; 248 249 if (rasterizer->point_quad_rasterization) { 250 if (rasterizer->point_smooth) { 251 glhd_warn("Point smoothing requested but ignored"); 252 } 253 } else { 254 if (rasterizer->sprite_coord_enable) { 255 glhd_warn("Point sprites requested but ignored"); 256 } 257 } 258 259 return pipe->create_rasterizer_state(pipe, 260 rasterizer); 261} 262 263static void 264galahad_context_bind_rasterizer_state(struct pipe_context *_pipe, 265 void *rasterizer) 266{ 267 struct galahad_context *glhd_pipe = galahad_context(_pipe); 268 struct pipe_context *pipe = glhd_pipe->pipe; 269 270 pipe->bind_rasterizer_state(pipe, 271 rasterizer); 272} 273 274static void 275galahad_context_delete_rasterizer_state(struct pipe_context *_pipe, 276 void *rasterizer) 277{ 278 struct galahad_context *glhd_pipe = galahad_context(_pipe); 279 struct pipe_context *pipe = glhd_pipe->pipe; 280 281 pipe->delete_rasterizer_state(pipe, 282 rasterizer); 283} 284 285static void * 286galahad_context_create_depth_stencil_alpha_state(struct pipe_context *_pipe, 287 const struct pipe_depth_stencil_alpha_state *depth_stencil_alpha) 288{ 289 struct galahad_context *glhd_pipe = galahad_context(_pipe); 290 struct pipe_context *pipe = glhd_pipe->pipe; 291 292 return pipe->create_depth_stencil_alpha_state(pipe, 293 depth_stencil_alpha); 294} 295 296static void 297galahad_context_bind_depth_stencil_alpha_state(struct pipe_context *_pipe, 298 void *depth_stencil_alpha) 299{ 300 struct galahad_context *glhd_pipe = galahad_context(_pipe); 301 struct pipe_context *pipe = glhd_pipe->pipe; 302 303 pipe->bind_depth_stencil_alpha_state(pipe, 304 depth_stencil_alpha); 305} 306 307static void 308galahad_context_delete_depth_stencil_alpha_state(struct pipe_context *_pipe, 309 void *depth_stencil_alpha) 310{ 311 struct galahad_context *glhd_pipe = galahad_context(_pipe); 312 struct pipe_context *pipe = glhd_pipe->pipe; 313 314 pipe->delete_depth_stencil_alpha_state(pipe, 315 depth_stencil_alpha); 316} 317 318static void * 319galahad_context_create_fs_state(struct pipe_context *_pipe, 320 const struct pipe_shader_state *fs) 321{ 322 struct galahad_context *glhd_pipe = galahad_context(_pipe); 323 struct pipe_context *pipe = glhd_pipe->pipe; 324 325 return pipe->create_fs_state(pipe, 326 fs); 327} 328 329static void 330galahad_context_bind_fs_state(struct pipe_context *_pipe, 331 void *fs) 332{ 333 struct galahad_context *glhd_pipe = galahad_context(_pipe); 334 struct pipe_context *pipe = glhd_pipe->pipe; 335 336 pipe->bind_fs_state(pipe, 337 fs); 338} 339 340static void 341galahad_context_delete_fs_state(struct pipe_context *_pipe, 342 void *fs) 343{ 344 struct galahad_context *glhd_pipe = galahad_context(_pipe); 345 struct pipe_context *pipe = glhd_pipe->pipe; 346 347 pipe->delete_fs_state(pipe, 348 fs); 349} 350 351static void * 352galahad_context_create_vs_state(struct pipe_context *_pipe, 353 const struct pipe_shader_state *vs) 354{ 355 struct galahad_context *glhd_pipe = galahad_context(_pipe); 356 struct pipe_context *pipe = glhd_pipe->pipe; 357 358 return pipe->create_vs_state(pipe, 359 vs); 360} 361 362static void 363galahad_context_bind_vs_state(struct pipe_context *_pipe, 364 void *vs) 365{ 366 struct galahad_context *glhd_pipe = galahad_context(_pipe); 367 struct pipe_context *pipe = glhd_pipe->pipe; 368 369 pipe->bind_vs_state(pipe, 370 vs); 371} 372 373static void 374galahad_context_delete_vs_state(struct pipe_context *_pipe, 375 void *vs) 376{ 377 struct galahad_context *glhd_pipe = galahad_context(_pipe); 378 struct pipe_context *pipe = glhd_pipe->pipe; 379 380 pipe->delete_vs_state(pipe, 381 vs); 382} 383 384 385static void * 386galahad_context_create_vertex_elements_state(struct pipe_context *_pipe, 387 unsigned num_elements, 388 const struct pipe_vertex_element *vertex_elements) 389{ 390 struct galahad_context *glhd_pipe = galahad_context(_pipe); 391 struct pipe_context *pipe = glhd_pipe->pipe; 392 393 /* XXX check if stride lines up with element size, at least for floats */ 394 395 return pipe->create_vertex_elements_state(pipe, 396 num_elements, 397 vertex_elements); 398} 399 400static void 401galahad_context_bind_vertex_elements_state(struct pipe_context *_pipe, 402 void *velems) 403{ 404 struct galahad_context *glhd_pipe = galahad_context(_pipe); 405 struct pipe_context *pipe = glhd_pipe->pipe; 406 407 pipe->bind_vertex_elements_state(pipe, 408 velems); 409} 410 411static void 412galahad_context_delete_vertex_elements_state(struct pipe_context *_pipe, 413 void *velems) 414{ 415 struct galahad_context *glhd_pipe = galahad_context(_pipe); 416 struct pipe_context *pipe = glhd_pipe->pipe; 417 418 pipe->delete_vertex_elements_state(pipe, 419 velems); 420} 421 422static void 423galahad_context_set_blend_color(struct pipe_context *_pipe, 424 const struct pipe_blend_color *blend_color) 425{ 426 struct galahad_context *glhd_pipe = galahad_context(_pipe); 427 struct pipe_context *pipe = glhd_pipe->pipe; 428 429 pipe->set_blend_color(pipe, 430 blend_color); 431} 432 433static void 434galahad_context_set_stencil_ref(struct pipe_context *_pipe, 435 const struct pipe_stencil_ref *stencil_ref) 436{ 437 struct galahad_context *glhd_pipe = galahad_context(_pipe); 438 struct pipe_context *pipe = glhd_pipe->pipe; 439 440 pipe->set_stencil_ref(pipe, 441 stencil_ref); 442} 443 444static void 445galahad_context_set_clip_state(struct pipe_context *_pipe, 446 const struct pipe_clip_state *clip) 447{ 448 struct galahad_context *glhd_pipe = galahad_context(_pipe); 449 struct pipe_context *pipe = glhd_pipe->pipe; 450 451 pipe->set_clip_state(pipe, 452 clip); 453} 454 455static void 456galahad_context_set_sample_mask(struct pipe_context *_pipe, 457 unsigned sample_mask) 458{ 459 struct galahad_context *glhd_pipe = galahad_context(_pipe); 460 struct pipe_context *pipe = glhd_pipe->pipe; 461 462 pipe->set_sample_mask(pipe, 463 sample_mask); 464} 465 466static void 467galahad_context_set_constant_buffer(struct pipe_context *_pipe, 468 uint shader, 469 uint index, 470 struct pipe_constant_buffer *_cb) 471{ 472 struct galahad_context *glhd_pipe = galahad_context(_pipe); 473 struct pipe_context *pipe = glhd_pipe->pipe; 474 struct pipe_constant_buffer cb; 475 476 if (shader >= PIPE_SHADER_TYPES) { 477 glhd_error("Unknown shader type %u", shader); 478 } 479 480 if (index && 481 index >= 482 pipe->screen->get_shader_param(pipe->screen, shader, PIPE_SHADER_CAP_MAX_CONST_BUFFERS)) { 483 glhd_error("Access to constant buffer %u requested, " 484 "but only %d are supported", 485 index, 486 pipe->screen->get_shader_param(pipe->screen, shader, PIPE_SHADER_CAP_MAX_CONST_BUFFERS)); 487 } 488 489 /* XXX hmm? unwrap the input state */ 490 if (_cb) { 491 cb = *_cb; 492 cb.buffer = galahad_resource_unwrap(_cb->buffer); 493 } 494 495 pipe->set_constant_buffer(pipe, 496 shader, 497 index, 498 _cb ? &cb : NULL); 499} 500 501static void 502galahad_context_set_framebuffer_state(struct pipe_context *_pipe, 503 const struct pipe_framebuffer_state *_state) 504{ 505 struct galahad_context *glhd_pipe = galahad_context(_pipe); 506 struct pipe_context *pipe = glhd_pipe->pipe; 507 struct pipe_framebuffer_state unwrapped_state; 508 struct pipe_framebuffer_state *state = NULL; 509 unsigned i; 510 511 if (_state->nr_cbufs > PIPE_MAX_COLOR_BUFS) { 512 glhd_error("%d render targets bound, but only %d are permitted by API", 513 _state->nr_cbufs, PIPE_MAX_COLOR_BUFS); 514 } else if (_state->nr_cbufs > 515 pipe->screen->get_param(pipe->screen, PIPE_CAP_MAX_RENDER_TARGETS)) { 516 glhd_warn("%d render targets bound, but only %d are supported", 517 _state->nr_cbufs, 518 pipe->screen->get_param(pipe->screen, PIPE_CAP_MAX_RENDER_TARGETS)); 519 } 520 521 /* unwrap the input state */ 522 if (_state) { 523 memcpy(&unwrapped_state, _state, sizeof(unwrapped_state)); 524 for(i = 0; i < _state->nr_cbufs; i++) 525 unwrapped_state.cbufs[i] = galahad_surface_unwrap(_state->cbufs[i]); 526 for (; i < PIPE_MAX_COLOR_BUFS; i++) 527 unwrapped_state.cbufs[i] = NULL; 528 unwrapped_state.zsbuf = galahad_surface_unwrap(_state->zsbuf); 529 state = &unwrapped_state; 530 } 531 532 pipe->set_framebuffer_state(pipe, 533 state); 534} 535 536static void 537galahad_context_set_polygon_stipple(struct pipe_context *_pipe, 538 const struct pipe_poly_stipple *poly_stipple) 539{ 540 struct galahad_context *glhd_pipe = galahad_context(_pipe); 541 struct pipe_context *pipe = glhd_pipe->pipe; 542 543 pipe->set_polygon_stipple(pipe, 544 poly_stipple); 545} 546 547static void 548galahad_context_set_scissor_state(struct pipe_context *_pipe, 549 const struct pipe_scissor_state *scissor) 550{ 551 struct galahad_context *glhd_pipe = galahad_context(_pipe); 552 struct pipe_context *pipe = glhd_pipe->pipe; 553 554 pipe->set_scissor_state(pipe, 555 scissor); 556} 557 558static void 559galahad_context_set_viewport_state(struct pipe_context *_pipe, 560 const struct pipe_viewport_state *viewport) 561{ 562 struct galahad_context *glhd_pipe = galahad_context(_pipe); 563 struct pipe_context *pipe = glhd_pipe->pipe; 564 565 pipe->set_viewport_state(pipe, 566 viewport); 567} 568 569static void 570galahad_context_set_sampler_views(struct pipe_context *_pipe, 571 unsigned shader, 572 unsigned start, 573 unsigned num, 574 struct pipe_sampler_view **_views) 575{ 576 struct galahad_context *glhd_pipe = galahad_context(_pipe); 577 struct pipe_context *pipe = glhd_pipe->pipe; 578 struct pipe_sampler_view *unwrapped_views[PIPE_MAX_SAMPLERS]; 579 struct pipe_sampler_view **views = NULL; 580 unsigned i; 581 582 if (_views) { 583 for (i = 0; i < num; i++) 584 unwrapped_views[i] = galahad_sampler_view_unwrap(_views[i]); 585 for (; i < PIPE_MAX_SAMPLERS; i++) 586 unwrapped_views[i] = NULL; 587 588 views = unwrapped_views; 589 } 590 591 switch (shader) { 592 case PIPE_SHADER_VERTEX: 593 pipe->set_vertex_sampler_views(pipe, num, views); 594 break; 595 case PIPE_SHADER_FRAGMENT: 596 pipe->set_fragment_sampler_views(pipe, num, views); 597 break; 598 default: 599 assert(0); 600 } 601} 602 603static void 604galahad_context_set_vertex_sampler_views(struct pipe_context *_pipe, 605 unsigned num, 606 struct pipe_sampler_view **_views) 607{ 608 galahad_context_set_sampler_views(_pipe, PIPE_SHADER_VERTEX, 609 0, num, _views); 610} 611 612static void 613galahad_context_set_fragment_sampler_views(struct pipe_context *_pipe, 614 unsigned num, 615 struct pipe_sampler_view **_views) 616{ 617 galahad_context_set_sampler_views(_pipe, PIPE_SHADER_FRAGMENT, 618 0, num, _views); 619} 620 621 622static void 623galahad_context_set_vertex_buffers(struct pipe_context *_pipe, 624 unsigned num_buffers, 625 const struct pipe_vertex_buffer *_buffers) 626{ 627 struct galahad_context *glhd_pipe = galahad_context(_pipe); 628 struct pipe_context *pipe = glhd_pipe->pipe; 629 struct pipe_vertex_buffer unwrapped_buffers[PIPE_MAX_SHADER_INPUTS]; 630 struct pipe_vertex_buffer *buffers = NULL; 631 unsigned i; 632 633 if (num_buffers) { 634 memcpy(unwrapped_buffers, _buffers, num_buffers * sizeof(*_buffers)); 635 for (i = 0; i < num_buffers; i++) 636 unwrapped_buffers[i].buffer = galahad_resource_unwrap(_buffers[i].buffer); 637 buffers = unwrapped_buffers; 638 } 639 640 pipe->set_vertex_buffers(pipe, 641 num_buffers, 642 buffers); 643} 644 645static void 646galahad_context_set_index_buffer(struct pipe_context *_pipe, 647 const struct pipe_index_buffer *_ib) 648{ 649 struct galahad_context *glhd_pipe = galahad_context(_pipe); 650 struct pipe_context *pipe = glhd_pipe->pipe; 651 struct pipe_index_buffer unwrapped_ib, *ib = NULL; 652 653 if (_ib) { 654 if (_ib->buffer || _ib->user_buffer) { 655 switch (_ib->index_size) { 656 case 1: 657 case 2: 658 case 4: 659 break; 660 default: 661 glhd_warn("unrecognized index size %d", _ib->index_size); 662 break; 663 } 664 } 665 else if (_ib->offset || _ib->index_size) { 666 glhd_warn("non-indexed state with index offset %d and index size %d", 667 _ib->offset, _ib->index_size); 668 } 669 670 unwrapped_ib = *_ib; 671 unwrapped_ib.buffer = galahad_resource_unwrap(_ib->buffer); 672 ib = &unwrapped_ib; 673 } 674 675 pipe->set_index_buffer(pipe, ib); 676} 677 678static void 679galahad_context_resource_copy_region(struct pipe_context *_pipe, 680 struct pipe_resource *_dst, 681 unsigned dst_level, 682 unsigned dstx, 683 unsigned dsty, 684 unsigned dstz, 685 struct pipe_resource *_src, 686 unsigned src_level, 687 const struct pipe_box *src_box) 688{ 689 struct galahad_context *glhd_pipe = galahad_context(_pipe); 690 struct galahad_resource *glhd_resource_dst = galahad_resource(_dst); 691 struct galahad_resource *glhd_resource_src = galahad_resource(_src); 692 struct pipe_context *pipe = glhd_pipe->pipe; 693 struct pipe_resource *dst = glhd_resource_dst->resource; 694 struct pipe_resource *src = glhd_resource_src->resource; 695 696 if (_dst->format != _src->format) { 697 const struct util_format_description *src_desc = 698 util_format_description(_src->format); 699 const struct util_format_description *dst_desc = 700 util_format_description(_dst->format); 701 if (!util_is_format_compatible(src_desc, dst_desc)) 702 glhd_warn("Format mismatch: Source is %s, destination is %s", 703 src_desc->short_name, 704 dst_desc->short_name); 705 } 706 707 if ((_src->target == PIPE_BUFFER && _dst->target != PIPE_BUFFER) || 708 (_src->target != PIPE_BUFFER && _dst->target == PIPE_BUFFER)) { 709 glhd_warn("Resource target mismatch: Source is %i, destination is %i", 710 _src->target, _dst->target); 711 } 712 713 pipe->resource_copy_region(pipe, 714 dst, 715 dst_level, 716 dstx, 717 dsty, 718 dstz, 719 src, 720 src_level, 721 src_box); 722} 723 724static void 725galahad_context_clear(struct pipe_context *_pipe, 726 unsigned buffers, 727 const union pipe_color_union *color, 728 double depth, 729 unsigned stencil) 730{ 731 struct galahad_context *glhd_pipe = galahad_context(_pipe); 732 struct pipe_context *pipe = glhd_pipe->pipe; 733 734 pipe->clear(pipe, 735 buffers, 736 color, 737 depth, 738 stencil); 739} 740 741static void 742galahad_context_clear_render_target(struct pipe_context *_pipe, 743 struct pipe_surface *_dst, 744 const union pipe_color_union *color, 745 unsigned dstx, unsigned dsty, 746 unsigned width, unsigned height) 747{ 748 struct galahad_context *glhd_pipe = galahad_context(_pipe); 749 struct galahad_surface *glhd_surface_dst = galahad_surface(_dst); 750 struct pipe_context *pipe = glhd_pipe->pipe; 751 struct pipe_surface *dst = glhd_surface_dst->surface; 752 753 pipe->clear_render_target(pipe, 754 dst, 755 color, 756 dstx, 757 dsty, 758 width, 759 height); 760} 761static void 762galahad_context_clear_depth_stencil(struct pipe_context *_pipe, 763 struct pipe_surface *_dst, 764 unsigned clear_flags, 765 double depth, 766 unsigned stencil, 767 unsigned dstx, unsigned dsty, 768 unsigned width, unsigned height) 769{ 770 struct galahad_context *glhd_pipe = galahad_context(_pipe); 771 struct galahad_surface *glhd_surface_dst = galahad_surface(_dst); 772 struct pipe_context *pipe = glhd_pipe->pipe; 773 struct pipe_surface *dst = glhd_surface_dst->surface; 774 775 pipe->clear_depth_stencil(pipe, 776 dst, 777 clear_flags, 778 depth, 779 stencil, 780 dstx, 781 dsty, 782 width, 783 height); 784 785} 786 787static void 788galahad_context_flush(struct pipe_context *_pipe, 789 struct pipe_fence_handle **fence) 790{ 791 struct galahad_context *glhd_pipe = galahad_context(_pipe); 792 struct pipe_context *pipe = glhd_pipe->pipe; 793 794 pipe->flush(pipe, 795 fence); 796} 797 798static struct pipe_sampler_view * 799galahad_context_create_sampler_view(struct pipe_context *_pipe, 800 struct pipe_resource *_resource, 801 const struct pipe_sampler_view *templ) 802{ 803 struct galahad_context *glhd_context = galahad_context(_pipe); 804 struct galahad_resource *glhd_resource = galahad_resource(_resource); 805 struct pipe_context *pipe = glhd_context->pipe; 806 struct pipe_resource *resource = glhd_resource->resource; 807 struct pipe_sampler_view *result; 808 809 result = pipe->create_sampler_view(pipe, 810 resource, 811 templ); 812 813 if (result) 814 return galahad_sampler_view_create(glhd_context, glhd_resource, result); 815 return NULL; 816} 817 818static void 819galahad_context_sampler_view_destroy(struct pipe_context *_pipe, 820 struct pipe_sampler_view *_view) 821{ 822 galahad_sampler_view_destroy(galahad_context(_pipe), 823 galahad_sampler_view(_view)); 824} 825 826static struct pipe_surface * 827galahad_context_create_surface(struct pipe_context *_pipe, 828 struct pipe_resource *_resource, 829 const struct pipe_surface *templ) 830{ 831 struct galahad_context *glhd_context = galahad_context(_pipe); 832 struct galahad_resource *glhd_resource = galahad_resource(_resource); 833 struct pipe_context *pipe = glhd_context->pipe; 834 struct pipe_resource *resource = glhd_resource->resource; 835 struct pipe_surface *result; 836 837 result = pipe->create_surface(pipe, 838 resource, 839 templ); 840 841 if (result) 842 return galahad_surface_create(glhd_context, glhd_resource, result); 843 return NULL; 844} 845 846static void 847galahad_context_surface_destroy(struct pipe_context *_pipe, 848 struct pipe_surface *_surface) 849{ 850 galahad_surface_destroy(galahad_context(_pipe), 851 galahad_surface(_surface)); 852} 853 854 855 856static struct pipe_transfer * 857galahad_context_get_transfer(struct pipe_context *_context, 858 struct pipe_resource *_resource, 859 unsigned level, 860 unsigned usage, 861 const struct pipe_box *box) 862{ 863 struct galahad_context *glhd_context = galahad_context(_context); 864 struct galahad_resource *glhd_resource = galahad_resource(_resource); 865 struct pipe_context *context = glhd_context->pipe; 866 struct pipe_resource *resource = glhd_resource->resource; 867 struct pipe_transfer *result; 868 869 result = context->get_transfer(context, 870 resource, 871 level, 872 usage, 873 box); 874 875 if (result) 876 return galahad_transfer_create(glhd_context, glhd_resource, result); 877 return NULL; 878} 879 880static void 881galahad_context_transfer_destroy(struct pipe_context *_pipe, 882 struct pipe_transfer *_transfer) 883{ 884 galahad_transfer_destroy(galahad_context(_pipe), 885 galahad_transfer(_transfer)); 886} 887 888static void * 889galahad_context_transfer_map(struct pipe_context *_context, 890 struct pipe_transfer *_transfer) 891{ 892 struct galahad_context *glhd_context = galahad_context(_context); 893 struct galahad_transfer *glhd_transfer = galahad_transfer(_transfer); 894 struct pipe_context *context = glhd_context->pipe; 895 struct pipe_transfer *transfer = glhd_transfer->transfer; 896 897 struct galahad_resource *glhd_resource = galahad_resource(_transfer->resource); 898 899 glhd_resource->map_count++; 900 901 return context->transfer_map(context, 902 transfer); 903} 904 905 906 907static void 908galahad_context_transfer_flush_region(struct pipe_context *_context, 909 struct pipe_transfer *_transfer, 910 const struct pipe_box *box) 911{ 912 struct galahad_context *glhd_context = galahad_context(_context); 913 struct galahad_transfer *glhd_transfer = galahad_transfer(_transfer); 914 struct pipe_context *context = glhd_context->pipe; 915 struct pipe_transfer *transfer = glhd_transfer->transfer; 916 917 context->transfer_flush_region(context, 918 transfer, 919 box); 920} 921 922 923static void 924galahad_context_transfer_unmap(struct pipe_context *_context, 925 struct pipe_transfer *_transfer) 926{ 927 struct galahad_context *glhd_context = galahad_context(_context); 928 struct galahad_transfer *glhd_transfer = galahad_transfer(_transfer); 929 struct pipe_context *context = glhd_context->pipe; 930 struct pipe_transfer *transfer = glhd_transfer->transfer; 931 struct galahad_resource *glhd_resource = galahad_resource(_transfer->resource); 932 933 if (glhd_resource->map_count < 1) { 934 glhd_warn("context::transfer_unmap() called too many times" 935 " (count = %d)\n", glhd_resource->map_count); 936 } 937 938 glhd_resource->map_count--; 939 940 context->transfer_unmap(context, 941 transfer); 942} 943 944 945static void 946galahad_context_transfer_inline_write(struct pipe_context *_context, 947 struct pipe_resource *_resource, 948 unsigned level, 949 unsigned usage, 950 const struct pipe_box *box, 951 const void *data, 952 unsigned stride, 953 unsigned slice_stride) 954{ 955 struct galahad_context *glhd_context = galahad_context(_context); 956 struct galahad_resource *glhd_resource = galahad_resource(_resource); 957 struct pipe_context *context = glhd_context->pipe; 958 struct pipe_resource *resource = glhd_resource->resource; 959 960 context->transfer_inline_write(context, 961 resource, 962 level, 963 usage, 964 box, 965 data, 966 stride, 967 slice_stride); 968} 969 970 971static void 972galahad_context_render_condition(struct pipe_context *_context, 973 struct pipe_query *query, 974 uint mode) 975{ 976 struct galahad_context *glhd_context = galahad_context(_context); 977 struct pipe_context *context = glhd_context->pipe; 978 979 context->render_condition(context, query, mode); 980} 981 982 983struct pipe_context * 984galahad_context_create(struct pipe_screen *_screen, struct pipe_context *pipe) 985{ 986 struct galahad_context *glhd_pipe; 987 (void)galahad_screen(_screen); 988 989 glhd_pipe = CALLOC_STRUCT(galahad_context); 990 if (!glhd_pipe) { 991 return NULL; 992 } 993 994 glhd_pipe->base.screen = _screen; 995 glhd_pipe->base.priv = pipe->priv; /* expose wrapped data */ 996 glhd_pipe->base.draw = NULL; 997 998 glhd_pipe->base.destroy = galahad_context_destroy; 999 1000#define GLHD_PIPE_INIT(_member) \ 1001 glhd_pipe->base . _member = pipe -> _member ? galahad_context_ ## _member : NULL 1002 1003 GLHD_PIPE_INIT(draw_vbo); 1004 GLHD_PIPE_INIT(render_condition); 1005 GLHD_PIPE_INIT(create_query); 1006 GLHD_PIPE_INIT(destroy_query); 1007 GLHD_PIPE_INIT(begin_query); 1008 GLHD_PIPE_INIT(end_query); 1009 GLHD_PIPE_INIT(get_query_result); 1010 GLHD_PIPE_INIT(create_blend_state); 1011 GLHD_PIPE_INIT(bind_blend_state); 1012 GLHD_PIPE_INIT(delete_blend_state); 1013 GLHD_PIPE_INIT(create_sampler_state); 1014 GLHD_PIPE_INIT(bind_fragment_sampler_states); 1015 GLHD_PIPE_INIT(bind_vertex_sampler_states); 1016 //GLHD_PIPE_INIT(bind_geometry_sampler_states); 1017 //GLHD_PIPE_INIT(bind_compute_sampler_states); 1018 GLHD_PIPE_INIT(delete_sampler_state); 1019 GLHD_PIPE_INIT(create_rasterizer_state); 1020 GLHD_PIPE_INIT(bind_rasterizer_state); 1021 GLHD_PIPE_INIT(delete_rasterizer_state); 1022 GLHD_PIPE_INIT(create_depth_stencil_alpha_state); 1023 GLHD_PIPE_INIT(bind_depth_stencil_alpha_state); 1024 GLHD_PIPE_INIT(delete_depth_stencil_alpha_state); 1025 GLHD_PIPE_INIT(create_fs_state); 1026 GLHD_PIPE_INIT(bind_fs_state); 1027 GLHD_PIPE_INIT(delete_fs_state); 1028 GLHD_PIPE_INIT(create_vs_state); 1029 GLHD_PIPE_INIT(bind_vs_state); 1030 GLHD_PIPE_INIT(delete_vs_state); 1031 //GLHD_PIPE_INIT(create_gs_state); 1032 //GLHD_PIPE_INIT(bind_gs_state); 1033 //GLHD_PIPE_INIT(delete_gs_state); 1034 GLHD_PIPE_INIT(create_vertex_elements_state); 1035 GLHD_PIPE_INIT(bind_vertex_elements_state); 1036 GLHD_PIPE_INIT(delete_vertex_elements_state); 1037 GLHD_PIPE_INIT(set_blend_color); 1038 GLHD_PIPE_INIT(set_stencil_ref); 1039 GLHD_PIPE_INIT(set_sample_mask); 1040 GLHD_PIPE_INIT(set_clip_state); 1041 GLHD_PIPE_INIT(set_constant_buffer); 1042 GLHD_PIPE_INIT(set_framebuffer_state); 1043 GLHD_PIPE_INIT(set_polygon_stipple); 1044 GLHD_PIPE_INIT(set_scissor_state); 1045 GLHD_PIPE_INIT(set_viewport_state); 1046 GLHD_PIPE_INIT(set_fragment_sampler_views); 1047 GLHD_PIPE_INIT(set_vertex_sampler_views); 1048 //GLHD_PIPE_INIT(set_geometry_sampler_views); 1049 //GLHD_PIPE_INIT(set_compute_sampler_views); 1050 //GLHD_PIPE_INIT(set_shader_resources); 1051 GLHD_PIPE_INIT(set_vertex_buffers); 1052 GLHD_PIPE_INIT(set_index_buffer); 1053 //GLHD_PIPE_INIT(create_stream_output_target); 1054 //GLHD_PIPE_INIT(stream_output_target_destroy); 1055 //GLHD_PIPE_INIT(set_stream_output_targets); 1056 GLHD_PIPE_INIT(resource_copy_region); 1057 //GLHD_PIPE_INIT(resource_resolve); 1058 GLHD_PIPE_INIT(clear); 1059 GLHD_PIPE_INIT(clear_render_target); 1060 GLHD_PIPE_INIT(clear_depth_stencil); 1061 GLHD_PIPE_INIT(flush); 1062 GLHD_PIPE_INIT(create_sampler_view); 1063 GLHD_PIPE_INIT(sampler_view_destroy); 1064 GLHD_PIPE_INIT(create_surface); 1065 GLHD_PIPE_INIT(surface_destroy); 1066 GLHD_PIPE_INIT(get_transfer); 1067 GLHD_PIPE_INIT(transfer_destroy); 1068 GLHD_PIPE_INIT(transfer_map); 1069 GLHD_PIPE_INIT(transfer_flush_region); 1070 GLHD_PIPE_INIT(transfer_unmap); 1071 GLHD_PIPE_INIT(transfer_inline_write); 1072 //GLHD_PIPE_INIT(texture_barrier); 1073 //GLHD_PIPE_INIT(create_video_decoder); 1074 //GLHD_PIPE_INIT(create_video_buffer); 1075 //GLHD_PIPE_INIT(create_compute_state); 1076 //GLHD_PIPE_INIT(bind_compute_state); 1077 //GLHD_PIPE_INIT(delete_compute_state); 1078 //GLHD_PIPE_INIT(set_compute_resources); 1079 //GLHD_PIPE_INIT(set_global_binding); 1080 //GLHD_PIPE_INIT(launch_grid); 1081 1082#undef GLHD_PIPE_INIT 1083 1084 glhd_pipe->pipe = pipe; 1085 1086 return &glhd_pipe->base; 1087} 1088