src/gallium/drivers/ilo/ilo_state.h

   1 /*
   2  * Mesa 3-D graphics library
   3  *
   4  * Copyright (C) 2012-2013 LunarG, Inc.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included
  14  * in all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  21  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  22  * DEALINGS IN THE SOFTWARE.
  23  *
  24  * Authors:
  25  *    Chia-I Wu <olv@lunarg.com>
  26  */
  27
  28 #ifndef ILO_STATE_H
  29 #define ILO_STATE_H
  30
  31 #include "core/ilo_builder_3d.h" /* for gen6_3dprimitive_info */
  32 #include "core/ilo_state_cc.h"
  33 #include "core/ilo_state_compute.h"
  34 #include "core/ilo_state_raster.h"
  35 #include "core/ilo_state_sampler.h"
  36 #include "core/ilo_state_sbe.h"
  37 #include "core/ilo_state_shader.h"
  38 #include "core/ilo_state_sol.h"
  39 #include "core/ilo_state_surface.h"
  40 #include "core/ilo_state_urb.h"
  41 #include "core/ilo_state_vf.h"
  42 #include "core/ilo_state_viewport.h"
  43 #include "core/ilo_state_zs.h"
  44 #include "pipe/p_state.h"
  45 #include "util/u_dynarray.h"
  46
  47 #include "ilo_common.h"
  48
  49 /**
  50  * \see brw_context.h
  51  */
  52 #define ILO_MAX_DRAW_BUFFERS    8
  53 #define ILO_MAX_CONST_BUFFERS   (1 + 12)
  54 #define ILO_MAX_SAMPLER_VIEWS   16
  55 #define ILO_MAX_SAMPLERS        16
  56 #define ILO_MAX_SO_BINDINGS     64
  57 #define ILO_MAX_SO_BUFFERS      4
  58 #define ILO_MAX_VIEWPORTS       1
  59
  60 #define ILO_MAX_SURFACES        256
  61
  62 /**
  63  * States that we track.
  64  *
  65  * XXX Do we want to count each sampler or vertex buffer as a state?  If that
  66  * is the case, there are simply not enough bits.
  67  *
  68  * XXX We want to treat primitive type and depth clear value as states, but
  69  * there are not enough bits.
  70  */
  71 enum ilo_state {
  72    ILO_STATE_VB,
  73    ILO_STATE_VE,
  74    ILO_STATE_IB,
  75    ILO_STATE_VS,
  76    ILO_STATE_GS,
  77    ILO_STATE_SO,
  78    ILO_STATE_CLIP,
  79    ILO_STATE_VIEWPORT,
  80    ILO_STATE_SCISSOR,
  81    ILO_STATE_RASTERIZER,
  82    ILO_STATE_POLY_STIPPLE,
  83    ILO_STATE_SAMPLE_MASK,
  84    ILO_STATE_FS,
  85    ILO_STATE_DSA,
  86    ILO_STATE_STENCIL_REF,
  87    ILO_STATE_BLEND,
  88    ILO_STATE_BLEND_COLOR,
  89    ILO_STATE_FB,
  90
  91    ILO_STATE_SAMPLER_VS,
  92    ILO_STATE_SAMPLER_GS,
  93    ILO_STATE_SAMPLER_FS,
  94    ILO_STATE_SAMPLER_CS,
  95    ILO_STATE_VIEW_VS,
  96    ILO_STATE_VIEW_GS,
  97    ILO_STATE_VIEW_FS,
  98    ILO_STATE_VIEW_CS,
  99    ILO_STATE_CBUF,
 100    ILO_STATE_RESOURCE,
 101
 102    ILO_STATE_CS,
 103    ILO_STATE_CS_RESOURCE,
 104    ILO_STATE_GLOBAL_BINDING,
 105
 106    ILO_STATE_COUNT,
 107 };
 108
 109 /**
 110  * Dirty flags of the states.
 111  */
 112 enum ilo_dirty_flags {
 113    ILO_DIRTY_VB               = 1 << ILO_STATE_VB,
 114    ILO_DIRTY_VE               = 1 << ILO_STATE_VE,
 115    ILO_DIRTY_IB               = 1 << ILO_STATE_IB,
 116    ILO_DIRTY_VS               = 1 << ILO_STATE_VS,
 117    ILO_DIRTY_GS               = 1 << ILO_STATE_GS,
 118    ILO_DIRTY_SO               = 1 << ILO_STATE_SO,
 119    ILO_DIRTY_CLIP             = 1 << ILO_STATE_CLIP,
 120    ILO_DIRTY_VIEWPORT         = 1 << ILO_STATE_VIEWPORT,
 121    ILO_DIRTY_SCISSOR          = 1 << ILO_STATE_SCISSOR,
 122    ILO_DIRTY_RASTERIZER       = 1 << ILO_STATE_RASTERIZER,
 123    ILO_DIRTY_POLY_STIPPLE     = 1 << ILO_STATE_POLY_STIPPLE,
 124    ILO_DIRTY_SAMPLE_MASK      = 1 << ILO_STATE_SAMPLE_MASK,
 125    ILO_DIRTY_FS               = 1 << ILO_STATE_FS,
 126    ILO_DIRTY_DSA              = 1 << ILO_STATE_DSA,
 127    ILO_DIRTY_STENCIL_REF      = 1 << ILO_STATE_STENCIL_REF,
 128    ILO_DIRTY_BLEND            = 1 << ILO_STATE_BLEND,
 129    ILO_DIRTY_BLEND_COLOR      = 1 << ILO_STATE_BLEND_COLOR,
 130    ILO_DIRTY_FB               = 1 << ILO_STATE_FB,
 131    ILO_DIRTY_SAMPLER_VS       = 1 << ILO_STATE_SAMPLER_VS,
 132    ILO_DIRTY_SAMPLER_GS       = 1 << ILO_STATE_SAMPLER_GS,
 133    ILO_DIRTY_SAMPLER_FS       = 1 << ILO_STATE_SAMPLER_FS,
 134    ILO_DIRTY_SAMPLER_CS       = 1 << ILO_STATE_SAMPLER_CS,
 135    ILO_DIRTY_VIEW_VS          = 1 << ILO_STATE_VIEW_VS,
 136    ILO_DIRTY_VIEW_GS          = 1 << ILO_STATE_VIEW_GS,
 137    ILO_DIRTY_VIEW_FS          = 1 << ILO_STATE_VIEW_FS,
 138    ILO_DIRTY_VIEW_CS          = 1 << ILO_STATE_VIEW_CS,
 139    ILO_DIRTY_CBUF             = 1 << ILO_STATE_CBUF,
 140    ILO_DIRTY_RESOURCE         = 1 << ILO_STATE_RESOURCE,
 141    ILO_DIRTY_CS               = 1 << ILO_STATE_CS,
 142    ILO_DIRTY_CS_RESOURCE      = 1 << ILO_STATE_CS_RESOURCE,
 143    ILO_DIRTY_GLOBAL_BINDING   = 1 << ILO_STATE_GLOBAL_BINDING,
 144    ILO_DIRTY_ALL              = 0xffffffff,
 145 };
 146
 147 struct ilo_context;
 148 struct ilo_shader_state;
 149
 150 struct ilo_ve_state {
 151    unsigned vb_mapping[PIPE_MAX_ATTRIBS];
 152    unsigned vb_count;
 153
 154    /* these are not valid until the state is finalized */
 155    uint32_t vf_data[PIPE_MAX_ATTRIBS][4];
 156    struct ilo_state_vf_params_info vf_params;
 157    struct ilo_state_vf vf;
 158 };
 159
 160 struct ilo_vb_state {
 161    struct pipe_vertex_buffer states[PIPE_MAX_ATTRIBS];
 162    struct ilo_state_vertex_buffer vb[PIPE_MAX_ATTRIBS];
 163    uint32_t enabled_mask;
 164 };
 165
 166 struct ilo_ib_state {
 167    struct pipe_index_buffer state;
 168
 169    /* these are not valid until the state is finalized */
 170    struct pipe_resource *hw_resource;
 171    unsigned hw_index_size;
 172    struct ilo_state_index_buffer ib;
 173 };
 174
 175 struct ilo_cbuf_cso {
 176    struct pipe_resource *resource;
 177    struct ilo_state_surface_buffer_info info;
 178    struct ilo_state_surface surface;
 179
 180    /*
 181     * this CSO is not so constant because user buffer needs to be uploaded in
 182     * finalize_constant_buffers()
 183     */
 184    const void *user_buffer;
 185 };
 186
 187 struct ilo_sampler_cso {
 188    struct ilo_state_sampler sampler;
 189    struct ilo_state_sampler_border border;
 190    bool saturate_s;
 191    bool saturate_t;
 192    bool saturate_r;
 193 };
 194
 195 struct ilo_sampler_state {
 196    const struct ilo_sampler_cso *cso[ILO_MAX_SAMPLERS];
 197 };
 198
 199 struct ilo_cbuf_state {
 200    struct ilo_cbuf_cso cso[ILO_MAX_CONST_BUFFERS];
 201    uint32_t enabled_mask;
 202 };
 203
 204 struct ilo_resource_state {
 205    struct pipe_surface *states[PIPE_MAX_SHADER_IMAGES];
 206    unsigned count;
 207 };
 208
 209 struct ilo_view_cso {
 210    struct pipe_sampler_view base;
 211
 212    struct ilo_state_surface surface;
 213 };
 214
 215 struct ilo_view_state {
 216    struct pipe_sampler_view *states[ILO_MAX_SAMPLER_VIEWS];
 217    unsigned count;
 218 };
 219
 220 struct ilo_stream_output_target {
 221    struct pipe_stream_output_target base;
 222
 223    struct ilo_state_sol_buffer sb;
 224 };
 225
 226 struct ilo_so_state {
 227    struct pipe_stream_output_target *states[ILO_MAX_SO_BUFFERS];
 228    unsigned count;
 229    unsigned append_bitmask;
 230
 231    struct ilo_state_sol_buffer dummy_sb;
 232
 233    bool enabled;
 234 };
 235
 236 struct ilo_rasterizer_state {
 237    struct pipe_rasterizer_state state;
 238
 239    /* these are invalid until finalize_rasterizer() */
 240    struct ilo_state_raster_info info;
 241    struct ilo_state_raster rs;
 242 };
 243
 244 struct ilo_viewport_state {
 245    struct ilo_state_viewport_matrix_info matrices[ILO_MAX_VIEWPORTS];
 246    struct ilo_state_viewport_scissor_info scissors[ILO_MAX_VIEWPORTS];
 247    struct ilo_state_viewport_params_info params;
 248
 249    struct pipe_viewport_state viewport0;
 250    struct pipe_scissor_state scissor0;
 251
 252    struct ilo_state_viewport vp;
 253    uint32_t vp_data[20 * ILO_MAX_VIEWPORTS];
 254 };
 255
 256 struct ilo_surface_cso {
 257    struct pipe_surface base;
 258
 259    bool is_rt;
 260    union {
 261       struct ilo_state_surface rt;
 262       struct ilo_state_zs zs;
 263    } u;
 264 };
 265
 266 struct ilo_fb_state {
 267    struct pipe_framebuffer_state state;
 268
 269    struct ilo_state_surface null_rt;
 270    struct ilo_state_zs null_zs;
 271
 272    struct ilo_fb_blend_caps {
 273       bool is_unorm;
 274       bool is_integer;
 275       bool force_dst_alpha_one;
 276
 277       bool can_logicop;
 278       bool can_blend;
 279       bool can_alpha_test;
 280    } blend_caps[PIPE_MAX_COLOR_BUFS];
 281
 282    unsigned num_samples;
 283
 284    bool has_integer_rt;
 285    bool has_hiz;
 286    enum gen_depth_format depth_offset_format;
 287 };
 288
 289 struct ilo_dsa_state {
 290    struct ilo_state_cc_depth_info depth;
 291
 292    struct ilo_state_cc_stencil_info stencil;
 293    struct {
 294       uint8_t test_mask;
 295       uint8_t write_mask;
 296    } stencil_front, stencil_back;
 297
 298    bool alpha_test;
 299    float alpha_ref;
 300    enum gen_compare_function alpha_func;
 301 };
 302
 303 struct ilo_blend_state {
 304    struct ilo_state_cc_blend_rt_info rt[PIPE_MAX_COLOR_BUFS];
 305    struct ilo_state_cc_blend_rt_info dummy_rt;
 306    bool dual_blend;
 307
 308    /* these are invalid until finalize_blend() */
 309    struct ilo_state_cc_blend_rt_info effective_rt[PIPE_MAX_COLOR_BUFS];
 310    struct ilo_state_cc_info info;
 311    struct ilo_state_cc cc;
 312    bool alpha_may_kill;
 313 };
 314
 315 struct ilo_global_binding_cso {
 316    struct pipe_resource *resource;
 317    uint32_t *handle;
 318 };
 319
 320 /*
 321  * In theory, we would like a "virtual" bo that serves as the global memory
 322  * region.  The virtual bo would reserve a region in the GTT aperture, but the
 323  * pages of it would come from those of the global bindings.
 324  *
 325  * The virtual bo would be created in launch_grid().  The global bindings
 326  * would be added to the virtual bo.  A SURFACE_STATE for the virtual bo would
 327  * be created.  The handles returned by set_global_binding() would be offsets
 328  * into the virtual bo.
 329  *
 330  * But for now, we will create a SURFACE_STATE for each of the bindings.  The
 331  * handle of a global binding consists of the offset and the binding table
 332  * index.
 333  */
 334 struct ilo_global_binding {
 335    struct util_dynarray bindings;
 336    unsigned count;
 337 };
 338
 339 struct ilo_state_vector {
 340    const struct pipe_draw_info *draw;
 341    struct gen6_3dprimitive_info draw_info;
 342
 343    uint32_t dirty;
 344
 345    struct ilo_vb_state vb;
 346    struct ilo_ve_state *ve;
 347    struct ilo_ib_state ib;
 348
 349    struct ilo_shader_state *vs;
 350    struct ilo_shader_state *gs;
 351
 352    struct ilo_state_hs disabled_hs;
 353    struct ilo_state_ds disabled_ds;
 354    struct ilo_state_gs disabled_gs;
 355
 356    struct ilo_so_state so;
 357
 358    struct pipe_clip_state clip;
 359
 360    struct ilo_viewport_state viewport;
 361
 362    struct ilo_rasterizer_state *rasterizer;
 363
 364    struct ilo_state_line_stipple line_stipple;
 365    struct ilo_state_poly_stipple poly_stipple;
 366    unsigned sample_mask;
 367
 368    struct ilo_shader_state *fs;
 369
 370    struct ilo_state_cc_params_info cc_params;
 371    struct pipe_stencil_ref stencil_ref;
 372    const struct ilo_dsa_state *dsa;
 373    struct ilo_blend_state *blend;
 374
 375    struct ilo_fb_state fb;
 376
 377    struct ilo_state_urb urb;
 378
 379    /* shader resources */
 380    struct ilo_sampler_state sampler[PIPE_SHADER_TYPES];
 381    struct ilo_view_state view[PIPE_SHADER_TYPES];
 382    struct ilo_cbuf_state cbuf[PIPE_SHADER_TYPES];
 383    struct ilo_resource_state resource;
 384
 385    struct ilo_state_sampler disabled_sampler;
 386
 387    /* GPGPU */
 388    struct ilo_shader_state *cs;
 389    struct ilo_resource_state cs_resource;
 390    struct ilo_global_binding global_binding;
 391 };
 392
 393 void
 394 ilo_init_state_functions(struct ilo_context *ilo);
 395
 396 void
 397 ilo_finalize_3d_states(struct ilo_context *ilo,
 398                        const struct pipe_draw_info *draw);
 399
 400 void
 401 ilo_finalize_compute_states(struct ilo_context *ilo);
 402
 403 void
 404 ilo_state_vector_init(const struct ilo_dev *dev,
 405                       struct ilo_state_vector *vec);
 406
 407 void
 408 ilo_state_vector_cleanup(struct ilo_state_vector *vec);
 409
 410 void
 411 ilo_state_vector_resource_renamed(struct ilo_state_vector *vec,
 412                                   struct pipe_resource *res);
 413
 414 void
 415 ilo_state_vector_dump_dirty(const struct ilo_state_vector *vec);
 416
 417 #endif /* ILO_STATE_H */