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