/* * Mesa 3-D graphics library * * Copyright (C) 2012-2013 LunarG, Inc. * * 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, sublicense, * 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 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 NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS 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. * * Authors: * Chia-I Wu */ #ifndef ILO_STATE_H #define ILO_STATE_H #include "core/ilo_builder_3d.h" /* for gen6_3dprimitive_info */ #include "core/ilo_state_cc.h" #include "core/ilo_state_compute.h" #include "core/ilo_state_raster.h" #include "core/ilo_state_sampler.h" #include "core/ilo_state_sbe.h" #include "core/ilo_state_shader.h" #include "core/ilo_state_sol.h" #include "core/ilo_state_surface.h" #include "core/ilo_state_urb.h" #include "core/ilo_state_vf.h" #include "core/ilo_state_viewport.h" #include "core/ilo_state_zs.h" #include "pipe/p_state.h" #include "util/u_dynarray.h" #include "ilo_common.h" /** * \see brw_context.h */ #define ILO_MAX_DRAW_BUFFERS 8 #define ILO_MAX_CONST_BUFFERS (1 + 12) #define ILO_MAX_SAMPLER_VIEWS 16 #define ILO_MAX_SAMPLERS 16 #define ILO_MAX_SO_BINDINGS 64 #define ILO_MAX_SO_BUFFERS 4 #define ILO_MAX_VIEWPORTS 1 #define ILO_MAX_SURFACES 256 /** * States that we track. * * XXX Do we want to count each sampler or vertex buffer as a state? If that * is the case, there are simply not enough bits. * * XXX We want to treat primitive type and depth clear value as states, but * there are not enough bits. */ enum ilo_state { ILO_STATE_VB, ILO_STATE_VE, ILO_STATE_IB, ILO_STATE_VS, ILO_STATE_GS, ILO_STATE_SO, ILO_STATE_CLIP, ILO_STATE_VIEWPORT, ILO_STATE_SCISSOR, ILO_STATE_RASTERIZER, ILO_STATE_POLY_STIPPLE, ILO_STATE_SAMPLE_MASK, ILO_STATE_FS, ILO_STATE_DSA, ILO_STATE_STENCIL_REF, ILO_STATE_BLEND, ILO_STATE_BLEND_COLOR, ILO_STATE_FB, ILO_STATE_SAMPLER_VS, ILO_STATE_SAMPLER_GS, ILO_STATE_SAMPLER_FS, ILO_STATE_SAMPLER_CS, ILO_STATE_VIEW_VS, ILO_STATE_VIEW_GS, ILO_STATE_VIEW_FS, ILO_STATE_VIEW_CS, ILO_STATE_CBUF, ILO_STATE_RESOURCE, ILO_STATE_CS, ILO_STATE_CS_RESOURCE, ILO_STATE_GLOBAL_BINDING, ILO_STATE_COUNT, }; /** * Dirty flags of the states. */ enum ilo_dirty_flags { ILO_DIRTY_VB = 1 << ILO_STATE_VB, ILO_DIRTY_VE = 1 << ILO_STATE_VE, ILO_DIRTY_IB = 1 << ILO_STATE_IB, ILO_DIRTY_VS = 1 << ILO_STATE_VS, ILO_DIRTY_GS = 1 << ILO_STATE_GS, ILO_DIRTY_SO = 1 << ILO_STATE_SO, ILO_DIRTY_CLIP = 1 << ILO_STATE_CLIP, ILO_DIRTY_VIEWPORT = 1 << ILO_STATE_VIEWPORT, ILO_DIRTY_SCISSOR = 1 << ILO_STATE_SCISSOR, ILO_DIRTY_RASTERIZER = 1 << ILO_STATE_RASTERIZER, ILO_DIRTY_POLY_STIPPLE = 1 << ILO_STATE_POLY_STIPPLE, ILO_DIRTY_SAMPLE_MASK = 1 << ILO_STATE_SAMPLE_MASK, ILO_DIRTY_FS = 1 << ILO_STATE_FS, ILO_DIRTY_DSA = 1 << ILO_STATE_DSA, ILO_DIRTY_STENCIL_REF = 1 << ILO_STATE_STENCIL_REF, ILO_DIRTY_BLEND = 1 << ILO_STATE_BLEND, ILO_DIRTY_BLEND_COLOR = 1 << ILO_STATE_BLEND_COLOR, ILO_DIRTY_FB = 1 << ILO_STATE_FB, ILO_DIRTY_SAMPLER_VS = 1 << ILO_STATE_SAMPLER_VS, ILO_DIRTY_SAMPLER_GS = 1 << ILO_STATE_SAMPLER_GS, ILO_DIRTY_SAMPLER_FS = 1 << ILO_STATE_SAMPLER_FS, ILO_DIRTY_SAMPLER_CS = 1 << ILO_STATE_SAMPLER_CS, ILO_DIRTY_VIEW_VS = 1 << ILO_STATE_VIEW_VS, ILO_DIRTY_VIEW_GS = 1 << ILO_STATE_VIEW_GS, ILO_DIRTY_VIEW_FS = 1 << ILO_STATE_VIEW_FS, ILO_DIRTY_VIEW_CS = 1 << ILO_STATE_VIEW_CS, ILO_DIRTY_CBUF = 1 << ILO_STATE_CBUF, ILO_DIRTY_RESOURCE = 1 << ILO_STATE_RESOURCE, ILO_DIRTY_CS = 1 << ILO_STATE_CS, ILO_DIRTY_CS_RESOURCE = 1 << ILO_STATE_CS_RESOURCE, ILO_DIRTY_GLOBAL_BINDING = 1 << ILO_STATE_GLOBAL_BINDING, ILO_DIRTY_ALL = 0xffffffff, }; struct ilo_context; struct ilo_shader_state; struct ilo_ve_state { unsigned vb_mapping[PIPE_MAX_ATTRIBS]; unsigned vb_count; /* these are not valid until the state is finalized */ uint32_t vf_data[PIPE_MAX_ATTRIBS][4]; struct ilo_state_vf_params_info vf_params; struct ilo_state_vf vf; }; struct ilo_vb_state { struct pipe_vertex_buffer states[PIPE_MAX_ATTRIBS]; struct ilo_state_vertex_buffer vb[PIPE_MAX_ATTRIBS]; uint32_t enabled_mask; }; struct ilo_ib_state { struct pipe_index_buffer state; /* these are not valid until the state is finalized */ struct pipe_resource *hw_resource; unsigned hw_index_size; struct ilo_state_index_buffer ib; }; struct ilo_cbuf_cso { struct pipe_resource *resource; struct ilo_state_surface_buffer_info info; struct ilo_state_surface surface; /* * this CSO is not so constant because user buffer needs to be uploaded in * finalize_constant_buffers() */ const void *user_buffer; }; struct ilo_sampler_cso { struct ilo_state_sampler sampler; struct ilo_state_sampler_border border; bool saturate_s; bool saturate_t; bool saturate_r; }; struct ilo_sampler_state { const struct ilo_sampler_cso *cso[ILO_MAX_SAMPLERS]; }; struct ilo_cbuf_state { struct ilo_cbuf_cso cso[ILO_MAX_CONST_BUFFERS]; uint32_t enabled_mask; }; struct ilo_resource_state { struct pipe_surface *states[PIPE_MAX_SHADER_IMAGES]; unsigned count; }; struct ilo_view_cso { struct pipe_sampler_view base; struct ilo_state_surface surface; }; struct ilo_view_state { struct pipe_sampler_view *states[ILO_MAX_SAMPLER_VIEWS]; unsigned count; }; struct ilo_stream_output_target { struct pipe_stream_output_target base; struct ilo_state_sol_buffer sb; }; struct ilo_so_state { struct pipe_stream_output_target *states[ILO_MAX_SO_BUFFERS]; unsigned count; unsigned append_bitmask; struct ilo_state_sol_buffer dummy_sb; bool enabled; }; struct ilo_rasterizer_state { struct pipe_rasterizer_state state; /* these are invalid until finalize_rasterizer() */ struct ilo_state_raster_info info; struct ilo_state_raster rs; }; struct ilo_viewport_state { struct ilo_state_viewport_matrix_info matrices[ILO_MAX_VIEWPORTS]; struct ilo_state_viewport_scissor_info scissors[ILO_MAX_VIEWPORTS]; struct ilo_state_viewport_params_info params; struct pipe_viewport_state viewport0; struct pipe_scissor_state scissor0; struct ilo_state_viewport vp; uint32_t vp_data[20 * ILO_MAX_VIEWPORTS]; }; struct ilo_surface_cso { struct pipe_surface base; bool is_rt; union { struct ilo_state_surface rt; struct ilo_state_zs zs; } u; }; struct ilo_fb_state { struct pipe_framebuffer_state state; struct ilo_state_surface null_rt; struct ilo_state_zs null_zs; struct ilo_fb_blend_caps { bool is_unorm; bool is_integer; bool force_dst_alpha_one; bool can_logicop; bool can_blend; bool can_alpha_test; } blend_caps[PIPE_MAX_COLOR_BUFS]; unsigned num_samples; bool has_integer_rt; bool has_hiz; enum gen_depth_format depth_offset_format; }; struct ilo_dsa_state { struct ilo_state_cc_depth_info depth; struct ilo_state_cc_stencil_info stencil; struct { uint8_t test_mask; uint8_t write_mask; } stencil_front, stencil_back; bool alpha_test; float alpha_ref; enum gen_compare_function alpha_func; }; struct ilo_blend_state { struct ilo_state_cc_blend_rt_info rt[PIPE_MAX_COLOR_BUFS]; struct ilo_state_cc_blend_rt_info dummy_rt; bool dual_blend; /* these are invalid until finalize_blend() */ struct ilo_state_cc_blend_rt_info effective_rt[PIPE_MAX_COLOR_BUFS]; struct ilo_state_cc_info info; struct ilo_state_cc cc; bool alpha_may_kill; }; struct ilo_global_binding_cso { struct pipe_resource *resource; uint32_t *handle; }; /* * In theory, we would like a "virtual" bo that serves as the global memory * region. The virtual bo would reserve a region in the GTT aperture, but the * pages of it would come from those of the global bindings. * * The virtual bo would be created in launch_grid(). The global bindings * would be added to the virtual bo. A SURFACE_STATE for the virtual bo would * be created. The handles returned by set_global_binding() would be offsets * into the virtual bo. * * But for now, we will create a SURFACE_STATE for each of the bindings. The * handle of a global binding consists of the offset and the binding table * index. */ struct ilo_global_binding { struct util_dynarray bindings; unsigned count; }; struct ilo_state_vector { const struct pipe_draw_info *draw; struct gen6_3dprimitive_info draw_info; uint32_t dirty; struct ilo_vb_state vb; struct ilo_ve_state *ve; struct ilo_ib_state ib; struct ilo_shader_state *vs; struct ilo_shader_state *gs; struct ilo_state_hs disabled_hs; struct ilo_state_ds disabled_ds; struct ilo_state_gs disabled_gs; struct ilo_so_state so; struct pipe_clip_state clip; struct ilo_viewport_state viewport; struct ilo_rasterizer_state *rasterizer; struct ilo_state_line_stipple line_stipple; struct ilo_state_poly_stipple poly_stipple; unsigned sample_mask; struct ilo_shader_state *fs; struct ilo_state_cc_params_info cc_params; struct pipe_stencil_ref stencil_ref; const struct ilo_dsa_state *dsa; struct ilo_blend_state *blend; struct ilo_fb_state fb; struct ilo_state_urb urb; /* shader resources */ struct ilo_sampler_state sampler[PIPE_SHADER_TYPES]; struct ilo_view_state view[PIPE_SHADER_TYPES]; struct ilo_cbuf_state cbuf[PIPE_SHADER_TYPES]; struct ilo_resource_state resource; struct ilo_state_sampler disabled_sampler; /* GPGPU */ struct ilo_shader_state *cs; struct ilo_resource_state cs_resource; struct ilo_global_binding global_binding; }; void ilo_init_state_functions(struct ilo_context *ilo); void ilo_finalize_3d_states(struct ilo_context *ilo, const struct pipe_draw_info *draw); void ilo_finalize_compute_states(struct ilo_context *ilo); void ilo_state_vector_init(const struct ilo_dev *dev, struct ilo_state_vector *vec); void ilo_state_vector_cleanup(struct ilo_state_vector *vec); void ilo_state_vector_resource_renamed(struct ilo_state_vector *vec, struct pipe_resource *res); void ilo_state_vector_dump_dirty(const struct ilo_state_vector *vec); #endif /* ILO_STATE_H */