/************************************************************************** * * Copyright 2003 VMware, Inc. * All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the * "Software"), to deal in the Software without restriction, including * without limitation the rights to use, copy, modify, merge, publish, * distribute, sub license, and/or sell copies of the Software, and to * permit persons to whom the Software is furnished to do so, subject to * the following conditions: * * The above copyright notice and this permission notice (including the * next paragraph) shall be included in all copies or substantial portions * of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. * **************************************************************************/ #ifndef ST_CONTEXT_H #define ST_CONTEXT_H #include "main/arrayobj.h" #include "main/mtypes.h" #include "state_tracker/st_api.h" #include "main/fbobject.h" #include "state_tracker/st_atom.h" #include "util/u_helpers.h" #include "util/u_inlines.h" #include "util/list.h" #include "vbo/vbo.h" #include "util/list.h" #ifdef __cplusplus extern "C" { #endif struct dd_function_table; struct draw_context; struct draw_stage; struct gen_mipmap_state; struct st_context; struct st_program; struct st_perf_monitor_group; struct u_upload_mgr; struct st_bitmap_cache { /** Window pos to render the cached image */ GLint xpos, ypos; /** Bounds of region used in window coords */ GLint xmin, ymin, xmax, ymax; GLfloat color[4]; /** Bitmap's Z position */ GLfloat zpos; struct pipe_resource *texture; struct pipe_transfer *trans; GLboolean empty; /** An I8 texture image: */ ubyte *buffer; }; struct st_bound_handles { unsigned num_handles; uint64_t *handles; }; #define NUM_DRAWPIX_CACHE_ENTRIES 4 struct drawpix_cache_entry { GLsizei width, height; GLenum format, type; const void *user_pointer; /**< Last user 'pixels' pointer */ void *image; /**< Copy of the glDrawPixels image data */ struct pipe_resource *texture; unsigned age; }; /* * Node for a linked list of dead sampler views. */ struct st_zombie_sampler_view_node { struct pipe_sampler_view *view; struct list_head node; }; /* * Node for a linked list of dead shaders. */ struct st_zombie_shader_node { void *shader; enum pipe_shader_type type; struct list_head node; }; struct st_context { struct st_context_iface iface; struct gl_context *ctx; struct pipe_context *pipe; struct draw_context *draw; /**< For selection/feedback/rastpos only */ struct draw_stage *feedback_stage; /**< For GL_FEEDBACK rendermode */ struct draw_stage *selection_stage; /**< For GL_SELECT rendermode */ struct draw_stage *rastpos_stage; /**< For glRasterPos */ GLboolean clamp_frag_color_in_shader; GLboolean clamp_vert_color_in_shader; boolean clamp_frag_depth_in_shader; boolean has_stencil_export; /**< can do shader stencil export? */ boolean has_time_elapsed; boolean has_etc1; boolean has_etc2; boolean has_astc_2d_ldr; boolean has_astc_5x5_ldr; boolean prefer_blit_based_texture_transfer; boolean force_persample_in_shader; boolean has_shareable_shaders; boolean has_half_float_packing; boolean has_multi_draw_indirect; boolean has_single_pipe_stat; boolean has_indep_blend_func; boolean needs_rgb_dst_alpha_override; boolean can_bind_const_buffer_as_vertex; boolean has_signed_vertex_buffer_offset; boolean lower_flatshade; boolean lower_alpha_test; boolean lower_point_size; boolean lower_two_sided_color; boolean lower_ucp; /* There are consequences for drivers wanting to call st_finalize_nir * twice, once before shader caching and once after lowering for shader * variants. If shader variants use lowering passes that are not ready * for that, things can blow up. * * If this is true, st_finalize_nir and pipe_screen::finalize_nir will be * called before the result is stored in the shader cache. If lowering for * shader variants is invoked, the functions will be called again. */ boolean allow_st_finalize_nir_twice; /** * If a shader can be created when we get its source. * This means it has only 1 variant, not counting glBitmap and * glDrawPixels. */ boolean shader_has_one_variant[MESA_SHADER_STAGES]; boolean needs_texcoord_semantic; boolean apply_texture_swizzle_to_border_color; /* On old libGL's for linux we need to invalidate the drawables * on glViewpport calls, this is set via a option. */ boolean invalidate_on_gl_viewport; boolean draw_needs_minmax_index; boolean has_hw_atomics; /* Some state is contained in constant objects. * Other state is just parameter values. */ struct { struct pipe_blend_state blend; struct pipe_depth_stencil_alpha_state depth_stencil; struct pipe_rasterizer_state rasterizer; struct pipe_sampler_state vert_samplers[PIPE_MAX_SAMPLERS]; struct pipe_sampler_state frag_samplers[PIPE_MAX_SAMPLERS]; GLuint num_vert_samplers; GLuint num_frag_samplers; struct pipe_sampler_view *vert_sampler_views[PIPE_MAX_SAMPLERS]; struct pipe_sampler_view *frag_sampler_views[PIPE_MAX_SAMPLERS]; GLuint num_sampler_views[PIPE_SHADER_TYPES]; struct pipe_clip_state clip; struct { void *ptr; unsigned size; } constants[PIPE_SHADER_TYPES]; unsigned fb_width; unsigned fb_height; unsigned fb_num_samples; unsigned fb_num_layers; unsigned fb_num_cb; unsigned num_viewports; struct pipe_scissor_state scissor[PIPE_MAX_VIEWPORTS]; struct pipe_viewport_state viewport[PIPE_MAX_VIEWPORTS]; struct { unsigned num; boolean include; struct pipe_scissor_state rects[PIPE_MAX_WINDOW_RECTANGLES]; } window_rects; GLuint poly_stipple[32]; /**< In OpenGL's bottom-to-top order */ GLuint fb_orientation; bool enable_sample_locations; unsigned sample_locations_samples; uint8_t sample_locations[ PIPE_MAX_SAMPLE_LOCATION_GRID_SIZE * PIPE_MAX_SAMPLE_LOCATION_GRID_SIZE * 32]; } state; uint64_t dirty; /**< dirty states */ /** This masks out unused shader resources. Only valid in draw calls. */ uint64_t active_states; unsigned pin_thread_counter; /* for L3 thread pinning on AMD Zen */ /* If true, further analysis of states is required to know if something * has changed. Used mainly for shaders. */ bool gfx_shaders_may_be_dirty; bool compute_shader_may_be_dirty; GLboolean vertdata_edgeflags; GLboolean edgeflag_culls_prims; /** * The number of currently active queries (excluding timer queries). * This is used to know if we need to pause any queries for meta ops. */ unsigned active_queries; union { struct { struct st_program *vp; /**< Currently bound vertex program */ struct st_program *tcp; /**< Currently bound tess control program */ struct st_program *tep; /**< Currently bound tess eval program */ struct st_program *gp; /**< Currently bound geometry program */ struct st_program *fp; /**< Currently bound fragment program */ struct st_program *cp; /**< Currently bound compute program */ }; struct gl_program *current_program[MESA_SHADER_STAGES]; }; struct st_common_variant *vp_variant; struct { struct pipe_resource *pixelmap_texture; struct pipe_sampler_view *pixelmap_sampler_view; } pixel_xfer; /** for glBitmap */ struct { struct pipe_rasterizer_state rasterizer; struct pipe_sampler_state sampler; struct pipe_sampler_state atlas_sampler; enum pipe_format tex_format; struct st_bitmap_cache cache; } bitmap; /** for glDraw/CopyPixels */ struct { void *zs_shaders[4]; } drawpix; /** Cache of glDrawPixels images */ struct { struct drawpix_cache_entry entries[NUM_DRAWPIX_CACHE_ENTRIES]; unsigned age; } drawpix_cache; /** for glReadPixels */ struct { struct pipe_resource *src; struct pipe_resource *cache; enum pipe_format dst_format; unsigned level; unsigned layer; unsigned hits; } readpix_cache; /** for glClear */ struct { struct pipe_rasterizer_state raster; struct pipe_viewport_state viewport; void *vs; void *fs; void *vs_layered; void *gs_layered; } clear; /* For gl(Compressed)Tex(Sub)Image */ struct { struct pipe_rasterizer_state raster; struct pipe_blend_state upload_blend; void *vs; void *gs; void *upload_fs[3]; void *download_fs[3][PIPE_MAX_TEXTURE_TYPES]; bool upload_enabled; bool download_enabled; bool rgba_only; bool layers; bool use_gs; } pbo; /** for drawing with st_util_vertex */ struct pipe_vertex_element util_velems[3]; /** passthrough vertex shader matching the util_velem attributes */ void *passthrough_vs; enum pipe_texture_target internal_target; struct cso_context *cso_context; void *winsys_drawable_handle; /* The number of vertex buffers from the last call of validate_arrays. */ unsigned last_num_vbuffers; int32_t draw_stamp; int32_t read_stamp; struct st_config_options options; struct st_perf_monitor_group *perfmon; enum pipe_reset_status reset_status; /* Array of bound texture/image handles which are resident in the context. */ struct st_bound_handles bound_texture_handles[PIPE_SHADER_TYPES]; struct st_bound_handles bound_image_handles[PIPE_SHADER_TYPES]; /* Winsys buffers */ struct list_head winsys_buffers; /* Throttling for texture uploads and similar operations to limit memory * usage by limiting the number of in-flight operations based on * the estimated allocated size needed to execute those operations. */ struct util_throttle throttle; struct { struct st_zombie_sampler_view_node list; simple_mtx_t mutex; } zombie_sampler_views; struct { struct st_zombie_shader_node list; simple_mtx_t mutex; } zombie_shaders; }; /* * Get the state tracker context for the given Mesa context. */ static inline struct st_context * st_context(struct gl_context *ctx) { return ctx->st; } extern struct st_context * st_create_context(gl_api api, struct pipe_context *pipe, const struct gl_config *visual, struct st_context *share, const struct st_config_options *options, bool no_error); extern void st_destroy_context(struct st_context *st); extern void st_invalidate_buffers(struct st_context *st); extern void st_save_zombie_sampler_view(struct st_context *st, struct pipe_sampler_view *view); extern void st_save_zombie_shader(struct st_context *st, enum pipe_shader_type type, struct pipe_shader_state *shader); void st_context_free_zombie_objects(struct st_context *st); /** * Wrapper for struct gl_framebuffer. * This is an opaque type to the outside world. */ struct st_framebuffer { struct gl_framebuffer Base; struct st_framebuffer_iface *iface; enum st_attachment_type statts[ST_ATTACHMENT_COUNT]; unsigned num_statts; int32_t stamp; int32_t iface_stamp; uint32_t iface_ID; /* list of framebuffer objects */ struct list_head head; }; #ifdef __cplusplus } #endif #endif