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#ifndef PIPE_CONTEXT_H 29#define PIPE_CONTEXT_H 30 31#include "p_compiler.h" 32#include "p_format.h" 33#include "p_video_enums.h" 34#include "p_defines.h" 35#include <stdio.h> 36 37#ifdef __cplusplus 38extern "C" { 39#endif 40 41 42struct pipe_blend_color; 43struct pipe_blend_state; 44struct pipe_blit_info; 45struct pipe_box; 46struct pipe_clip_state; 47struct pipe_constant_buffer; 48struct pipe_debug_callback; 49struct pipe_depth_stencil_alpha_state; 50struct pipe_device_reset_callback; 51struct pipe_draw_info; 52struct pipe_grid_info; 53struct pipe_fence_handle; 54struct pipe_framebuffer_state; 55struct pipe_image_view; 56struct pipe_query; 57struct pipe_poly_stipple; 58struct pipe_rasterizer_state; 59struct pipe_resolve_info; 60struct pipe_resource; 61struct pipe_sampler_state; 62struct pipe_sampler_view; 63struct pipe_scissor_state; 64struct pipe_shader_buffer; 65struct pipe_shader_state; 66struct pipe_stencil_ref; 67struct pipe_stream_output_target; 68struct pipe_surface; 69struct pipe_transfer; 70struct pipe_vertex_buffer; 71struct pipe_vertex_element; 72struct pipe_video_buffer; 73struct pipe_video_codec; 74struct pipe_viewport_state; 75struct pipe_compute_state; 76union pipe_color_union; 77union pipe_query_result; 78struct u_log_context; 79struct u_upload_mgr; 80 81/** 82 * Gallium rendering context. Basically: 83 * - state setting functions 84 * - VBO drawing functions 85 * - surface functions 86 */ 87struct pipe_context { 88 struct pipe_screen *screen; 89 90 void *priv; /**< context private data (for DRI for example) */ 91 void *draw; /**< private, for draw module (temporary?) */ 92 93 /** 94 * Stream uploaders created by the driver. All drivers, state trackers, and 95 * modules should use them. 96 * 97 * Use u_upload_alloc or u_upload_data as many times as you want. 98 * Once you are done, use u_upload_unmap. 99 */ 100 struct u_upload_mgr *stream_uploader; /* everything but shader constants */ 101 struct u_upload_mgr *const_uploader; /* shader constants only */ 102 103 void (*destroy)( struct pipe_context * ); 104 105 /** 106 * VBO drawing 107 */ 108 /*@{*/ 109 void (*draw_vbo)( struct pipe_context *pipe, 110 const struct pipe_draw_info *info ); 111 /*@}*/ 112 113 /** 114 * Predicate subsequent rendering on occlusion query result 115 * \param query the query predicate, or NULL if no predicate 116 * \param condition whether to skip on FALSE or TRUE query results 117 * \param mode one of PIPE_RENDER_COND_x 118 */ 119 void (*render_condition)( struct pipe_context *pipe, 120 struct pipe_query *query, 121 boolean condition, 122 enum pipe_render_cond_flag mode ); 123 124 /** 125 * Query objects 126 */ 127 /*@{*/ 128 struct pipe_query *(*create_query)( struct pipe_context *pipe, 129 unsigned query_type, 130 unsigned index ); 131 132 /** 133 * Create a query object that queries all given query types simultaneously. 134 * 135 * This can only be used for those query types for which 136 * get_driver_query_info indicates that it must be used. Only one batch 137 * query object may be active at a time. 138 * 139 * There may be additional constraints on which query types can be used 140 * together, in particular those that are implied by 141 * get_driver_query_group_info. 142 * 143 * \param num_queries the number of query types 144 * \param query_types array of \p num_queries query types 145 * \return a query object, or NULL on error. 146 */ 147 struct pipe_query *(*create_batch_query)( struct pipe_context *pipe, 148 unsigned num_queries, 149 unsigned *query_types ); 150 151 void (*destroy_query)(struct pipe_context *pipe, 152 struct pipe_query *q); 153 154 boolean (*begin_query)(struct pipe_context *pipe, struct pipe_query *q); 155 bool (*end_query)(struct pipe_context *pipe, struct pipe_query *q); 156 157 /** 158 * Get results of a query. 159 * \param wait if true, this query will block until the result is ready 160 * \return TRUE if results are ready, FALSE otherwise 161 */ 162 boolean (*get_query_result)(struct pipe_context *pipe, 163 struct pipe_query *q, 164 boolean wait, 165 union pipe_query_result *result); 166 167 /** 168 * Get results of a query, storing into resource. Note that this may not 169 * be used with batch queries. 170 * 171 * \param wait if true, this query will block until the result is ready 172 * \param result_type the type of the value being stored: 173 * \param index for queries that return multiple pieces of data, which 174 * item of that data to store (e.g. for 175 * PIPE_QUERY_PIPELINE_STATISTICS). 176 * When the index is -1, instead of the value of the query 177 * the driver should instead write a 1 or 0 to the appropriate 178 * location with 1 meaning that the query result is available. 179 */ 180 void (*get_query_result_resource)(struct pipe_context *pipe, 181 struct pipe_query *q, 182 boolean wait, 183 enum pipe_query_value_type result_type, 184 int index, 185 struct pipe_resource *resource, 186 unsigned offset); 187 188 /** 189 * Set whether all current non-driver queries except TIME_ELAPSED are 190 * active or paused. 191 */ 192 void (*set_active_query_state)(struct pipe_context *pipe, boolean enable); 193 194 /*@}*/ 195 196 /** 197 * State functions (create/bind/destroy state objects) 198 */ 199 /*@{*/ 200 void * (*create_blend_state)(struct pipe_context *, 201 const struct pipe_blend_state *); 202 void (*bind_blend_state)(struct pipe_context *, void *); 203 void (*delete_blend_state)(struct pipe_context *, void *); 204 205 void * (*create_sampler_state)(struct pipe_context *, 206 const struct pipe_sampler_state *); 207 void (*bind_sampler_states)(struct pipe_context *, 208 enum pipe_shader_type shader, 209 unsigned start_slot, unsigned num_samplers, 210 void **samplers); 211 void (*delete_sampler_state)(struct pipe_context *, void *); 212 213 void * (*create_rasterizer_state)(struct pipe_context *, 214 const struct pipe_rasterizer_state *); 215 void (*bind_rasterizer_state)(struct pipe_context *, void *); 216 void (*delete_rasterizer_state)(struct pipe_context *, void *); 217 218 void * (*create_depth_stencil_alpha_state)(struct pipe_context *, 219 const struct pipe_depth_stencil_alpha_state *); 220 void (*bind_depth_stencil_alpha_state)(struct pipe_context *, void *); 221 void (*delete_depth_stencil_alpha_state)(struct pipe_context *, void *); 222 223 void * (*create_fs_state)(struct pipe_context *, 224 const struct pipe_shader_state *); 225 void (*bind_fs_state)(struct pipe_context *, void *); 226 void (*delete_fs_state)(struct pipe_context *, void *); 227 228 void * (*create_vs_state)(struct pipe_context *, 229 const struct pipe_shader_state *); 230 void (*bind_vs_state)(struct pipe_context *, void *); 231 void (*delete_vs_state)(struct pipe_context *, void *); 232 233 void * (*create_gs_state)(struct pipe_context *, 234 const struct pipe_shader_state *); 235 void (*bind_gs_state)(struct pipe_context *, void *); 236 void (*delete_gs_state)(struct pipe_context *, void *); 237 238 void * (*create_tcs_state)(struct pipe_context *, 239 const struct pipe_shader_state *); 240 void (*bind_tcs_state)(struct pipe_context *, void *); 241 void (*delete_tcs_state)(struct pipe_context *, void *); 242 243 void * (*create_tes_state)(struct pipe_context *, 244 const struct pipe_shader_state *); 245 void (*bind_tes_state)(struct pipe_context *, void *); 246 void (*delete_tes_state)(struct pipe_context *, void *); 247 248 void * (*create_vertex_elements_state)(struct pipe_context *, 249 unsigned num_elements, 250 const struct pipe_vertex_element *); 251 void (*bind_vertex_elements_state)(struct pipe_context *, void *); 252 void (*delete_vertex_elements_state)(struct pipe_context *, void *); 253 254 /*@}*/ 255 256 /** 257 * Parameter-like state (or properties) 258 */ 259 /*@{*/ 260 void (*set_blend_color)( struct pipe_context *, 261 const struct pipe_blend_color * ); 262 263 void (*set_stencil_ref)( struct pipe_context *, 264 const struct pipe_stencil_ref * ); 265 266 void (*set_sample_mask)( struct pipe_context *, 267 unsigned sample_mask ); 268 269 void (*set_min_samples)( struct pipe_context *, 270 unsigned min_samples ); 271 272 void (*set_clip_state)( struct pipe_context *, 273 const struct pipe_clip_state * ); 274 275 void (*set_constant_buffer)( struct pipe_context *, 276 enum pipe_shader_type shader, uint index, 277 const struct pipe_constant_buffer *buf ); 278 279 void (*set_framebuffer_state)( struct pipe_context *, 280 const struct pipe_framebuffer_state * ); 281 282 /** 283 * Set the sample locations used during rasterization. When NULL or sized 284 * zero, the default locations are used. 285 * 286 * Note that get_sample_position() still returns the default locations. 287 * 288 * The samples are accessed with 289 * locations[(pixel_y*grid_w+pixel_x)*ms+i], 290 * where: 291 * ms = the sample count 292 * grid_w = the pixel grid width for the sample count 293 * grid_w = the pixel grid height for the sample count 294 * pixel_x = the window x coordinate modulo grid_w 295 * pixel_y = the window y coordinate modulo grid_w 296 * i = the sample index 297 * This gives a result with the x coordinate as the low 4 bits and the y 298 * coordinate as the high 4 bits. For each coordinate 0 is the left or top 299 * edge of the pixel's rectangle and 16 (not 15) is the right or bottom edge. 300 * 301 * Out of bounds accesses are return undefined values. 302 * 303 * The pixel grid is used to vary sample locations across pixels and its 304 * size can be queried with get_sample_pixel_grid(). 305 */ 306 void (*set_sample_locations)( struct pipe_context *, 307 size_t size, const uint8_t *locations ); 308 309 void (*set_polygon_stipple)( struct pipe_context *, 310 const struct pipe_poly_stipple * ); 311 312 void (*set_scissor_states)( struct pipe_context *, 313 unsigned start_slot, 314 unsigned num_scissors, 315 const struct pipe_scissor_state * ); 316 317 void (*set_window_rectangles)( struct pipe_context *, 318 boolean include, 319 unsigned num_rectangles, 320 const struct pipe_scissor_state * ); 321 322 void (*set_viewport_states)( struct pipe_context *, 323 unsigned start_slot, 324 unsigned num_viewports, 325 const struct pipe_viewport_state *); 326 327 void (*set_sampler_views)(struct pipe_context *, 328 enum pipe_shader_type shader, 329 unsigned start_slot, unsigned num_views, 330 struct pipe_sampler_view **views); 331 332 void (*set_tess_state)(struct pipe_context *, 333 const float default_outer_level[4], 334 const float default_inner_level[2]); 335 336 /** 337 * Sets the debug callback. If the pointer is null, then no callback is 338 * set, otherwise a copy of the data should be made. 339 */ 340 void (*set_debug_callback)(struct pipe_context *, 341 const struct pipe_debug_callback *); 342 343 /** 344 * Bind an array of shader buffers that will be used by a shader. 345 * Any buffers that were previously bound to the specified range 346 * will be unbound. 347 * 348 * \param shader selects shader stage 349 * \param start_slot first buffer slot to bind. 350 * \param count number of consecutive buffers to bind. 351 * \param buffers array of pointers to the buffers to bind, it 352 * should contain at least \a count elements 353 * unless it's NULL, in which case no buffers will 354 * be bound. 355 * \param writable_bitmask If bit i is not set, buffers[i] will only be 356 * used with loads. If unsure, set to ~0. 357 */ 358 void (*set_shader_buffers)(struct pipe_context *, 359 enum pipe_shader_type shader, 360 unsigned start_slot, unsigned count, 361 const struct pipe_shader_buffer *buffers, 362 unsigned writable_bitmask); 363 364 /** 365 * Bind an array of hw atomic buffers for use by all shaders. 366 * And buffers that were previously bound to the specified range 367 * will be unbound. 368 * 369 * \param start_slot first buffer slot to bind. 370 * \param count number of consecutive buffers to bind. 371 * \param buffers array of pointers to the buffers to bind, it 372 * should contain at least \a count elements 373 * unless it's NULL, in which case no buffers will 374 * be bound. 375 */ 376 void (*set_hw_atomic_buffers)(struct pipe_context *, 377 unsigned start_slot, unsigned count, 378 const struct pipe_shader_buffer *buffers); 379 380 /** 381 * Bind an array of images that will be used by a shader. 382 * Any images that were previously bound to the specified range 383 * will be unbound. 384 * 385 * \param shader selects shader stage 386 * \param start_slot first image slot to bind. 387 * \param count number of consecutive images to bind. 388 * \param buffers array of the images to bind, it 389 * should contain at least \a count elements 390 * unless it's NULL, in which case no images will 391 * be bound. 392 */ 393 void (*set_shader_images)(struct pipe_context *, 394 enum pipe_shader_type shader, 395 unsigned start_slot, unsigned count, 396 const struct pipe_image_view *images); 397 398 void (*set_vertex_buffers)( struct pipe_context *, 399 unsigned start_slot, 400 unsigned num_buffers, 401 const struct pipe_vertex_buffer * ); 402 403 /*@}*/ 404 405 /** 406 * Stream output functions. 407 */ 408 /*@{*/ 409 410 struct pipe_stream_output_target *(*create_stream_output_target)( 411 struct pipe_context *, 412 struct pipe_resource *, 413 unsigned buffer_offset, 414 unsigned buffer_size); 415 416 void (*stream_output_target_destroy)(struct pipe_context *, 417 struct pipe_stream_output_target *); 418 419 void (*set_stream_output_targets)(struct pipe_context *, 420 unsigned num_targets, 421 struct pipe_stream_output_target **targets, 422 const unsigned *offsets); 423 424 /*@}*/ 425 426 427 /** 428 * Resource functions for blit-like functionality 429 * 430 * If a driver supports multisampling, blit must implement color resolve. 431 */ 432 /*@{*/ 433 434 /** 435 * Copy a block of pixels from one resource to another. 436 * The resource must be of the same format. 437 * Resources with nr_samples > 1 are not allowed. 438 */ 439 void (*resource_copy_region)(struct pipe_context *pipe, 440 struct pipe_resource *dst, 441 unsigned dst_level, 442 unsigned dstx, unsigned dsty, unsigned dstz, 443 struct pipe_resource *src, 444 unsigned src_level, 445 const struct pipe_box *src_box); 446 447 /* Optimal hardware path for blitting pixels. 448 * Scaling, format conversion, up- and downsampling (resolve) are allowed. 449 */ 450 void (*blit)(struct pipe_context *pipe, 451 const struct pipe_blit_info *info); 452 453 /*@}*/ 454 455 /** 456 * Clear the specified set of currently bound buffers to specified values. 457 * The entire buffers are cleared (no scissor, no colormask, etc). 458 * 459 * \param buffers bitfield of PIPE_CLEAR_* values. 460 * \param color pointer to a union of fiu array for each of r, g, b, a. 461 * \param depth depth clear value in [0,1]. 462 * \param stencil stencil clear value 463 */ 464 void (*clear)(struct pipe_context *pipe, 465 unsigned buffers, 466 const union pipe_color_union *color, 467 double depth, 468 unsigned stencil); 469 470 /** 471 * Clear a color rendertarget surface. 472 * \param color pointer to an union of fiu array for each of r, g, b, a. 473 */ 474 void (*clear_render_target)(struct pipe_context *pipe, 475 struct pipe_surface *dst, 476 const union pipe_color_union *color, 477 unsigned dstx, unsigned dsty, 478 unsigned width, unsigned height, 479 bool render_condition_enabled); 480 481 /** 482 * Clear a depth-stencil surface. 483 * \param clear_flags bitfield of PIPE_CLEAR_DEPTH/STENCIL values. 484 * \param depth depth clear value in [0,1]. 485 * \param stencil stencil clear value 486 */ 487 void (*clear_depth_stencil)(struct pipe_context *pipe, 488 struct pipe_surface *dst, 489 unsigned clear_flags, 490 double depth, 491 unsigned stencil, 492 unsigned dstx, unsigned dsty, 493 unsigned width, unsigned height, 494 bool render_condition_enabled); 495 496 /** 497 * Clear the texture with the specified texel. Not guaranteed to be a 498 * renderable format. Data provided in the resource's format. 499 */ 500 void (*clear_texture)(struct pipe_context *pipe, 501 struct pipe_resource *res, 502 unsigned level, 503 const struct pipe_box *box, 504 const void *data); 505 506 /** 507 * Clear a buffer. Runs a memset over the specified region with the element 508 * value passed in through clear_value of size clear_value_size. 509 */ 510 void (*clear_buffer)(struct pipe_context *pipe, 511 struct pipe_resource *res, 512 unsigned offset, 513 unsigned size, 514 const void *clear_value, 515 int clear_value_size); 516 517 /** 518 * If a depth buffer is rendered with different sample location state than 519 * what is current at the time of reading, the values may differ because 520 * depth buffer compression can depend the sample locations. 521 * 522 * This function is a hint to decompress the current depth buffer to avoid 523 * such problems. 524 */ 525 void (*evaluate_depth_buffer)(struct pipe_context *pipe); 526 527 /** 528 * Flush draw commands. 529 * 530 * This guarantees that the new fence (if any) will finish in finite time, 531 * unless PIPE_FLUSH_DEFERRED is used. 532 * 533 * Subsequent operations on other contexts of the same screen are guaranteed 534 * to execute after the flushed commands, unless PIPE_FLUSH_ASYNC is used. 535 * 536 * NOTE: use screen->fence_reference() (or equivalent) to transfer 537 * new fence ref to **fence, to ensure that previous fence is unref'd 538 * 539 * \param fence if not NULL, an old fence to unref and transfer a 540 * new fence reference to 541 * \param flags bitfield of enum pipe_flush_flags values. 542 */ 543 void (*flush)(struct pipe_context *pipe, 544 struct pipe_fence_handle **fence, 545 unsigned flags); 546 547 /** 548 * Create a fence from a fd. 549 * 550 * This is used for importing a foreign/external fence fd. 551 * 552 * \param fence if not NULL, an old fence to unref and transfer a 553 * new fence reference to 554 * \param fd fd representing the fence object 555 * \param type indicates which fence types backs fd 556 */ 557 void (*create_fence_fd)(struct pipe_context *pipe, 558 struct pipe_fence_handle **fence, 559 int fd, 560 enum pipe_fd_type type); 561 562 /** 563 * Insert commands to have GPU wait for fence to be signaled. 564 */ 565 void (*fence_server_sync)(struct pipe_context *pipe, 566 struct pipe_fence_handle *fence); 567 568 /** 569 * Insert commands to have the GPU signal a fence. 570 */ 571 void (*fence_server_signal)(struct pipe_context *pipe, 572 struct pipe_fence_handle *fence); 573 574 /** 575 * Create a view on a texture to be used by a shader stage. 576 */ 577 struct pipe_sampler_view * (*create_sampler_view)(struct pipe_context *ctx, 578 struct pipe_resource *texture, 579 const struct pipe_sampler_view *templat); 580 581 /** 582 * Destroy a view on a texture. 583 * 584 * \param ctx the current context 585 * \param view the view to be destroyed 586 * 587 * \note The current context may not be the context in which the view was 588 * created (view->context). However, the caller must guarantee that 589 * the context which created the view is still alive. 590 */ 591 void (*sampler_view_destroy)(struct pipe_context *ctx, 592 struct pipe_sampler_view *view); 593 594 595 /** 596 * Get a surface which is a "view" into a resource, used by 597 * render target / depth stencil stages. 598 */ 599 struct pipe_surface *(*create_surface)(struct pipe_context *ctx, 600 struct pipe_resource *resource, 601 const struct pipe_surface *templat); 602 603 void (*surface_destroy)(struct pipe_context *ctx, 604 struct pipe_surface *); 605 606 607 /** 608 * Map a resource. 609 * 610 * Transfers are (by default) context-private and allow uploads to be 611 * interleaved with rendering. 612 * 613 * out_transfer will contain the transfer object that must be passed 614 * to all the other transfer functions. It also contains useful 615 * information (like texture strides). 616 */ 617 void *(*transfer_map)(struct pipe_context *, 618 struct pipe_resource *resource, 619 unsigned level, 620 unsigned usage, /* a combination of PIPE_TRANSFER_x */ 621 const struct pipe_box *, 622 struct pipe_transfer **out_transfer); 623 624 /* If transfer was created with WRITE|FLUSH_EXPLICIT, only the 625 * regions specified with this call are guaranteed to be written to 626 * the resource. 627 */ 628 void (*transfer_flush_region)( struct pipe_context *, 629 struct pipe_transfer *transfer, 630 const struct pipe_box *); 631 632 void (*transfer_unmap)(struct pipe_context *, 633 struct pipe_transfer *transfer); 634 635 /* One-shot transfer operation with data supplied in a user 636 * pointer. 637 */ 638 void (*buffer_subdata)(struct pipe_context *, 639 struct pipe_resource *, 640 unsigned usage, /* a combination of PIPE_TRANSFER_x */ 641 unsigned offset, 642 unsigned size, 643 const void *data); 644 645 void (*texture_subdata)(struct pipe_context *, 646 struct pipe_resource *, 647 unsigned level, 648 unsigned usage, /* a combination of PIPE_TRANSFER_x */ 649 const struct pipe_box *, 650 const void *data, 651 unsigned stride, 652 unsigned layer_stride); 653 654 /** 655 * Flush any pending framebuffer writes and invalidate texture caches. 656 */ 657 void (*texture_barrier)(struct pipe_context *, unsigned flags); 658 659 /** 660 * Flush caches according to flags. 661 */ 662 void (*memory_barrier)(struct pipe_context *, unsigned flags); 663 664 /** 665 * Change the commitment status of a part of the given resource, which must 666 * have been created with the PIPE_RESOURCE_FLAG_SPARSE bit. 667 * 668 * \param level The texture level whose commitment should be changed. 669 * \param box The region of the resource whose commitment should be changed. 670 * \param commit Whether memory should be committed or un-committed. 671 * 672 * \return false if out of memory, true on success. 673 */ 674 bool (*resource_commit)(struct pipe_context *, struct pipe_resource *, 675 unsigned level, struct pipe_box *box, bool commit); 676 677 /** 678 * Creates a video codec for a specific video format/profile 679 */ 680 struct pipe_video_codec *(*create_video_codec)( struct pipe_context *context, 681 const struct pipe_video_codec *templat ); 682 683 /** 684 * Creates a video buffer as decoding target 685 */ 686 struct pipe_video_buffer *(*create_video_buffer)( struct pipe_context *context, 687 const struct pipe_video_buffer *templat ); 688 689 /** 690 * Compute kernel execution 691 */ 692 /*@{*/ 693 /** 694 * Define the compute program and parameters to be used by 695 * pipe_context::launch_grid. 696 */ 697 void *(*create_compute_state)(struct pipe_context *context, 698 const struct pipe_compute_state *); 699 void (*bind_compute_state)(struct pipe_context *, void *); 700 void (*delete_compute_state)(struct pipe_context *, void *); 701 702 /** 703 * Bind an array of shader resources that will be used by the 704 * compute program. Any resources that were previously bound to 705 * the specified range will be unbound after this call. 706 * 707 * \param start first resource to bind. 708 * \param count number of consecutive resources to bind. 709 * \param resources array of pointers to the resources to bind, it 710 * should contain at least \a count elements 711 * unless it's NULL, in which case no new 712 * resources will be bound. 713 */ 714 void (*set_compute_resources)(struct pipe_context *, 715 unsigned start, unsigned count, 716 struct pipe_surface **resources); 717 718 /** 719 * Bind an array of buffers to be mapped into the address space of 720 * the GLOBAL resource. Any buffers that were previously bound 721 * between [first, first + count - 1] are unbound after this call. 722 * 723 * \param first first buffer to map. 724 * \param count number of consecutive buffers to map. 725 * \param resources array of pointers to the buffers to map, it 726 * should contain at least \a count elements 727 * unless it's NULL, in which case no new 728 * resources will be bound. 729 * \param handles array of pointers to the memory locations that 730 * will be updated with the address each buffer 731 * will be mapped to. The base memory address of 732 * each of the buffers will be added to the value 733 * pointed to by its corresponding handle to form 734 * the final address argument. It should contain 735 * at least \a count elements, unless \a 736 * resources is NULL in which case \a handles 737 * should be NULL as well. 738 * 739 * Note that the driver isn't required to make any guarantees about 740 * the contents of the \a handles array being valid anytime except 741 * during the subsequent calls to pipe_context::launch_grid. This 742 * means that the only sensible location handles[i] may point to is 743 * somewhere within the INPUT buffer itself. This is so to 744 * accommodate implementations that lack virtual memory but 745 * nevertheless migrate buffers on the fly, leading to resource 746 * base addresses that change on each kernel invocation or are 747 * unknown to the pipe driver. 748 */ 749 void (*set_global_binding)(struct pipe_context *context, 750 unsigned first, unsigned count, 751 struct pipe_resource **resources, 752 uint32_t **handles); 753 754 /** 755 * Launch the compute kernel starting from instruction \a pc of the 756 * currently bound compute program. 757 */ 758 void (*launch_grid)(struct pipe_context *context, 759 const struct pipe_grid_info *info); 760 /*@}*/ 761 762 /** 763 * Get the default sample position for an individual sample point. 764 * 765 * \param sample_count - total number of samples 766 * \param sample_index - sample to get the position values for 767 * \param out_value - return value of 2 floats for x and y position for 768 * requested sample. 769 */ 770 void (*get_sample_position)(struct pipe_context *context, 771 unsigned sample_count, 772 unsigned sample_index, 773 float *out_value); 774 775 /** 776 * Query a timestamp in nanoseconds. This is completely equivalent to 777 * pipe_screen::get_timestamp() but takes a context handle for drivers 778 * that require a context. 779 */ 780 uint64_t (*get_timestamp)(struct pipe_context *); 781 782 /** 783 * Flush the resource cache, so that the resource can be used 784 * by an external client. Possible usage: 785 * - flushing a resource before presenting it on the screen 786 * - flushing a resource if some other process or device wants to use it 787 * This shouldn't be used to flush caches if the resource is only managed 788 * by a single pipe_screen and is not shared with another process. 789 * (i.e. you shouldn't use it to flush caches explicitly if you want to e.g. 790 * use the resource for texturing) 791 */ 792 void (*flush_resource)(struct pipe_context *ctx, 793 struct pipe_resource *resource); 794 795 /** 796 * Invalidate the contents of the resource. This is used to 797 * 798 * (1) implement EGL's semantic of undefined depth/stencil 799 * contents after a swapbuffers. This allows a tiled renderer (for 800 * example) to not store the depth buffer. 801 * 802 * (2) implement GL's InvalidateBufferData. For backwards compatibility, 803 * you must only rely on the usability for this purpose when 804 * PIPE_CAP_INVALIDATE_BUFFER is enabled. 805 */ 806 void (*invalidate_resource)(struct pipe_context *ctx, 807 struct pipe_resource *resource); 808 809 /** 810 * Return information about unexpected device resets. 811 */ 812 enum pipe_reset_status (*get_device_reset_status)(struct pipe_context *ctx); 813 814 /** 815 * Sets the reset status callback. If the pointer is null, then no callback 816 * is set, otherwise a copy of the data should be made. 817 */ 818 void (*set_device_reset_callback)(struct pipe_context *ctx, 819 const struct pipe_device_reset_callback *cb); 820 821 /** 822 * Dump driver-specific debug information into a stream. This is 823 * used by debugging tools. 824 * 825 * \param ctx pipe context 826 * \param stream where the output should be written to 827 * \param flags a mask of PIPE_DUMP_* flags 828 */ 829 void (*dump_debug_state)(struct pipe_context *ctx, FILE *stream, 830 unsigned flags); 831 832 /** 833 * Set the log context to which the driver should write internal debug logs 834 * (internal states, command streams). 835 * 836 * The caller must ensure that the log context is destroyed and reset to 837 * NULL before the pipe context is destroyed, and that log context functions 838 * are only called from the driver thread. 839 * 840 * \param ctx pipe context 841 * \param log logging context 842 */ 843 void (*set_log_context)(struct pipe_context *ctx, struct u_log_context *log); 844 845 /** 846 * Emit string marker in cmdstream 847 */ 848 void (*emit_string_marker)(struct pipe_context *ctx, 849 const char *string, 850 int len); 851 852 /** 853 * Generate mipmap. 854 * \return TRUE if mipmap generation succeeds, FALSE otherwise 855 */ 856 boolean (*generate_mipmap)(struct pipe_context *ctx, 857 struct pipe_resource *resource, 858 enum pipe_format format, 859 unsigned base_level, 860 unsigned last_level, 861 unsigned first_layer, 862 unsigned last_layer); 863 864 /** 865 * Create a 64-bit texture handle. 866 * 867 * \param ctx pipe context 868 * \param view pipe sampler view object 869 * \param state pipe sampler state template 870 * \return a 64-bit texture handle if success, 0 otherwise 871 */ 872 uint64_t (*create_texture_handle)(struct pipe_context *ctx, 873 struct pipe_sampler_view *view, 874 const struct pipe_sampler_state *state); 875 876 /** 877 * Delete a texture handle. 878 * 879 * \param ctx pipe context 880 * \param handle 64-bit texture handle 881 */ 882 void (*delete_texture_handle)(struct pipe_context *ctx, uint64_t handle); 883 884 /** 885 * Make a texture handle resident. 886 * 887 * \param ctx pipe context 888 * \param handle 64-bit texture handle 889 * \param resident TRUE for resident, FALSE otherwise 890 */ 891 void (*make_texture_handle_resident)(struct pipe_context *ctx, 892 uint64_t handle, bool resident); 893 894 /** 895 * Create a 64-bit image handle. 896 * 897 * \param ctx pipe context 898 * \param image pipe image view template 899 * \return a 64-bit image handle if success, 0 otherwise 900 */ 901 uint64_t (*create_image_handle)(struct pipe_context *ctx, 902 const struct pipe_image_view *image); 903 904 /** 905 * Delete an image handle. 906 * 907 * \param ctx pipe context 908 * \param handle 64-bit image handle 909 */ 910 void (*delete_image_handle)(struct pipe_context *ctx, uint64_t handle); 911 912 /** 913 * Make an image handle resident. 914 * 915 * \param ctx pipe context 916 * \param handle 64-bit image handle 917 * \param access GL_READ_ONLY, GL_WRITE_ONLY or GL_READ_WRITE 918 * \param resident TRUE for resident, FALSE otherwise 919 */ 920 void (*make_image_handle_resident)(struct pipe_context *ctx, uint64_t handle, 921 unsigned access, bool resident); 922 923 /** 924 * Call the given function from the driver thread. 925 * 926 * This is set by threaded contexts for use by debugging wrappers. 927 * 928 * \param asap if true, run the callback immediately if there are no pending 929 * commands to be processed by the driver thread 930 */ 931 void (*callback)(struct pipe_context *ctx, void (*fn)(void *), void *data, 932 bool asap); 933 934 /** 935 * Set a context parameter See enum pipe_context_param for more details. 936 */ 937 void (*set_context_param)(struct pipe_context *ctx, 938 enum pipe_context_param param, 939 unsigned value); 940}; 941 942 943#ifdef __cplusplus 944} 945#endif 946 947#endif /* PIPE_CONTEXT_H */ 948