2 * Mesa 3-D graphics library
4 * Copyright (C) 2012-2014 LunarG, Inc.
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:
13 * The above copyright notice and this permission notice shall be included
14 * in all copies or substantial portions of the Software.
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.
25 * Chia-I Wu <olv@lunarg.com>
28 #include "core/ilo_builder_3d.h"
29 #include "core/ilo_builder_media.h"
31 #include "ilo_common.h"
32 #include "ilo_blitter.h"
33 #include "ilo_shader.h"
34 #include "ilo_state.h"
35 #include "ilo_render_gen.h"
37 #define DIRTY(state) (session->pipe_dirty & ILO_DIRTY_ ## state)
40 gen6_emit_draw_dynamic_viewports(struct ilo_render
*r
,
41 const struct ilo_state_vector
*vec
,
42 struct ilo_render_draw_session
*session
)
44 ILO_DEV_ASSERT(r
->dev
, 6, 6);
46 /* CLIP_VIEWPORT, SF_VIEWPORT, and CC_VIEWPORT */
47 if ((session
->vp_delta
.dirty
& (ILO_STATE_VIEWPORT_SF_CLIP_VIEWPORT
|
48 ILO_STATE_VIEWPORT_CC_VIEWPORT
)) ||
49 r
->state_bo_changed
) {
50 r
->state
.CLIP_VIEWPORT
= gen6_CLIP_VIEWPORT(r
->builder
,
52 r
->state
.SF_VIEWPORT
= gen6_SF_VIEWPORT(r
->builder
, &vec
->viewport
.vp
);
53 r
->state
.CC_VIEWPORT
= gen6_CC_VIEWPORT(r
->builder
, &vec
->viewport
.vp
);
55 session
->viewport_changed
= true;
60 gen7_emit_draw_dynamic_viewports(struct ilo_render
*r
,
61 const struct ilo_state_vector
*vec
,
62 struct ilo_render_draw_session
*session
)
64 ILO_DEV_ASSERT(r
->dev
, 7, 8);
66 /* SF_CLIP_VIEWPORT and CC_VIEWPORT */
67 if ((session
->vp_delta
.dirty
& (ILO_STATE_VIEWPORT_SF_CLIP_VIEWPORT
|
68 ILO_STATE_VIEWPORT_CC_VIEWPORT
)) ||
69 r
->state_bo_changed
) {
70 r
->state
.SF_CLIP_VIEWPORT
= gen7_SF_CLIP_VIEWPORT(r
->builder
,
72 r
->state
.CC_VIEWPORT
= gen6_CC_VIEWPORT(r
->builder
, &vec
->viewport
.vp
);
74 session
->viewport_changed
= true;
79 gen6_emit_draw_dynamic_scissors(struct ilo_render
*r
,
80 const struct ilo_state_vector
*vec
,
81 struct ilo_render_draw_session
*session
)
83 ILO_DEV_ASSERT(r
->dev
, 6, 8);
86 if ((session
->vp_delta
.dirty
& ILO_STATE_VIEWPORT_SCISSOR_RECT
) ||
87 r
->state_bo_changed
) {
88 r
->state
.SCISSOR_RECT
= gen6_SCISSOR_RECT(r
->builder
,
91 session
->scissor_changed
= true;
96 gen6_emit_draw_dynamic_cc(struct ilo_render
*r
,
97 const struct ilo_state_vector
*vec
,
98 struct ilo_render_draw_session
*session
)
100 ILO_DEV_ASSERT(r
->dev
, 6, 8);
103 if ((session
->cc_delta
.dirty
& ILO_STATE_CC_BLEND_STATE
) ||
104 r
->state_bo_changed
) {
105 if (ilo_dev_gen(r
->dev
) >= ILO_GEN(8))
106 r
->state
.BLEND_STATE
= gen8_BLEND_STATE(r
->builder
, &vec
->blend
->cc
);
108 r
->state
.BLEND_STATE
= gen6_BLEND_STATE(r
->builder
, &vec
->blend
->cc
);
110 session
->blend_changed
= true;
113 /* COLOR_CALC_STATE */
114 if ((session
->cc_delta
.dirty
& ILO_STATE_CC_COLOR_CALC_STATE
) ||
115 r
->state_bo_changed
) {
116 r
->state
.COLOR_CALC_STATE
=
117 gen6_COLOR_CALC_STATE(r
->builder
, &vec
->blend
->cc
);
118 session
->cc_changed
= true;
121 /* DEPTH_STENCIL_STATE */
122 if (ilo_dev_gen(r
->dev
) < ILO_GEN(8) &&
123 ((session
->cc_delta
.dirty
& ILO_STATE_CC_DEPTH_STENCIL_STATE
) ||
124 r
->state_bo_changed
)) {
125 r
->state
.DEPTH_STENCIL_STATE
=
126 gen6_DEPTH_STENCIL_STATE(r
->builder
, &vec
->blend
->cc
);
127 session
->dsa_changed
= true;
132 gen6_emit_draw_dynamic_samplers(struct ilo_render
*r
,
133 const struct ilo_state_vector
*vec
,
135 struct ilo_render_draw_session
*session
)
137 const struct ilo_view_cso
* const *views
=
138 (const struct ilo_view_cso
**) vec
->view
[shader_type
].states
;
139 struct ilo_state_sampler samplers
[ILO_MAX_SAMPLERS
];
140 uint32_t *sampler_state
, *border_color_state
;
141 int sampler_count
, i
;
142 bool emit_border_color
= false;
145 ILO_DEV_ASSERT(r
->dev
, 6, 8);
147 /* SAMPLER_BORDER_COLOR_STATE and SAMPLER_STATE */
148 switch (shader_type
) {
149 case PIPE_SHADER_VERTEX
:
150 if (DIRTY(VS
) || DIRTY(SAMPLER_VS
) || DIRTY(VIEW_VS
)) {
151 sampler_state
= &r
->state
.vs
.SAMPLER_STATE
;
152 border_color_state
= r
->state
.vs
.SAMPLER_BORDER_COLOR_STATE
;
154 if (DIRTY(VS
) || DIRTY(SAMPLER_VS
))
155 emit_border_color
= true;
157 sampler_count
= (vec
->vs
) ? ilo_shader_get_kernel_param(vec
->vs
,
158 ILO_KERNEL_SAMPLER_COUNT
) : 0;
160 session
->sampler_vs_changed
= true;
165 case PIPE_SHADER_FRAGMENT
:
166 if (DIRTY(FS
) || DIRTY(SAMPLER_FS
) || DIRTY(VIEW_FS
)) {
167 sampler_state
= &r
->state
.wm
.SAMPLER_STATE
;
168 border_color_state
= r
->state
.wm
.SAMPLER_BORDER_COLOR_STATE
;
170 if (DIRTY(VS
) || DIRTY(SAMPLER_FS
))
171 emit_border_color
= true;
173 sampler_count
= (vec
->fs
) ? ilo_shader_get_kernel_param(vec
->fs
,
174 ILO_KERNEL_SAMPLER_COUNT
) : 0;
176 session
->sampler_fs_changed
= true;
189 assert(sampler_count
<= Elements(vec
->view
[shader_type
].states
) &&
190 sampler_count
<= Elements(vec
->sampler
[shader_type
].cso
));
192 if (emit_border_color
) {
193 for (i
= 0; i
< sampler_count
; i
++) {
194 const struct ilo_sampler_cso
*cso
= vec
->sampler
[shader_type
].cso
[i
];
196 border_color_state
[i
] = (cso
) ?
197 gen6_SAMPLER_BORDER_COLOR_STATE(r
->builder
, &cso
->border
) : 0;
201 for (i
= 0; i
< sampler_count
; i
++) {
202 const struct ilo_sampler_cso
*cso
= vec
->sampler
[shader_type
].cso
[i
];
204 if (cso
&& views
[i
]) {
205 samplers
[i
] = cso
->sampler
;
206 ilo_state_sampler_set_surface(&samplers
[i
],
207 r
->dev
, &views
[i
]->surface
);
209 samplers
[i
] = vec
->disabled_sampler
;
213 *sampler_state
= gen6_SAMPLER_STATE(r
->builder
, samplers
,
214 border_color_state
, sampler_count
);
218 gen6_emit_draw_dynamic_pcb(struct ilo_render
*r
,
219 const struct ilo_state_vector
*vec
,
220 struct ilo_render_draw_session
*session
)
222 ILO_DEV_ASSERT(r
->dev
, 6, 8);
224 /* push constant buffer for VS */
225 if (DIRTY(VS
) || DIRTY(CBUF
) || DIRTY(CLIP
)) {
226 const int cbuf0_size
= (vec
->vs
) ?
227 ilo_shader_get_kernel_param(vec
->vs
,
228 ILO_KERNEL_PCB_CBUF0_SIZE
) : 0;
229 const int clip_state_size
= (vec
->vs
) ?
230 ilo_shader_get_kernel_param(vec
->vs
,
231 ILO_KERNEL_VS_PCB_UCP_SIZE
) : 0;
232 const int total_size
= cbuf0_size
+ clip_state_size
;
237 r
->state
.vs
.PUSH_CONSTANT_BUFFER
=
238 gen6_push_constant_buffer(r
->builder
, total_size
, &pcb
);
239 r
->state
.vs
.PUSH_CONSTANT_BUFFER_size
= total_size
;
242 const struct ilo_cbuf_state
*cbuf
=
243 &vec
->cbuf
[PIPE_SHADER_VERTEX
];
245 if (cbuf0_size
<= cbuf
->cso
[0].info
.size
) {
246 memcpy(pcb
, cbuf
->cso
[0].user_buffer
, cbuf0_size
);
248 memcpy(pcb
, cbuf
->cso
[0].user_buffer
,
249 cbuf
->cso
[0].info
.size
);
250 memset(pcb
+ cbuf
->cso
[0].info
.size
, 0,
251 cbuf0_size
- cbuf
->cso
[0].info
.size
);
258 memcpy(pcb
, &vec
->clip
, clip_state_size
);
260 session
->pcb_vs_changed
= true;
261 } else if (r
->state
.vs
.PUSH_CONSTANT_BUFFER_size
) {
262 r
->state
.vs
.PUSH_CONSTANT_BUFFER
= 0;
263 r
->state
.vs
.PUSH_CONSTANT_BUFFER_size
= 0;
265 session
->pcb_vs_changed
= true;
269 /* push constant buffer for FS */
270 if (DIRTY(FS
) || DIRTY(CBUF
)) {
271 const int cbuf0_size
= (vec
->fs
) ?
272 ilo_shader_get_kernel_param(vec
->fs
, ILO_KERNEL_PCB_CBUF0_SIZE
) : 0;
275 const struct ilo_cbuf_state
*cbuf
= &vec
->cbuf
[PIPE_SHADER_FRAGMENT
];
278 r
->state
.wm
.PUSH_CONSTANT_BUFFER
=
279 gen6_push_constant_buffer(r
->builder
, cbuf0_size
, &pcb
);
280 r
->state
.wm
.PUSH_CONSTANT_BUFFER_size
= cbuf0_size
;
282 if (cbuf0_size
<= cbuf
->cso
[0].info
.size
) {
283 memcpy(pcb
, cbuf
->cso
[0].user_buffer
, cbuf0_size
);
285 memcpy(pcb
, cbuf
->cso
[0].user_buffer
,
286 cbuf
->cso
[0].info
.size
);
287 memset(pcb
+ cbuf
->cso
[0].info
.size
, 0,
288 cbuf0_size
- cbuf
->cso
[0].info
.size
);
291 session
->pcb_fs_changed
= true;
292 } else if (r
->state
.wm
.PUSH_CONSTANT_BUFFER_size
) {
293 r
->state
.wm
.PUSH_CONSTANT_BUFFER
= 0;
294 r
->state
.wm
.PUSH_CONSTANT_BUFFER_size
= 0;
296 session
->pcb_fs_changed
= true;
304 ilo_render_get_draw_dynamic_states_len(const struct ilo_render
*render
,
305 const struct ilo_state_vector
*vec
)
307 static int static_len
;
310 ILO_DEV_ASSERT(render
->dev
, 6, 8);
313 /* 64 bytes, or 16 dwords */
314 const int alignment
= 64 / 4;
320 len
+= align(GEN6_BLEND_STATE__SIZE
, alignment
);
321 len
+= align(GEN6_COLOR_CALC_STATE__SIZE
, alignment
);
322 if (ilo_dev_gen(render
->dev
) < ILO_GEN(8))
323 len
+= align(GEN6_DEPTH_STENCIL_STATE__SIZE
, alignment
);
325 /* viewport arrays */
326 if (ilo_dev_gen(render
->dev
) >= ILO_GEN(7)) {
327 len
+= 15 + /* pad first */
328 align(GEN7_SF_CLIP_VIEWPORT__SIZE
, 16) +
329 align(GEN6_CC_VIEWPORT__SIZE
, 8) +
330 align(GEN6_SCISSOR_RECT__SIZE
, 8);
332 len
+= 7 + /* pad first */
333 align(GEN6_SF_VIEWPORT__SIZE
, 8) +
334 align(GEN6_CLIP_VIEWPORT__SIZE
, 8) +
335 align(GEN6_CC_VIEWPORT__SIZE
, 8) +
336 align(GEN6_SCISSOR_RECT__SIZE
, 8);
344 for (sh_type
= 0; sh_type
< PIPE_SHADER_TYPES
; sh_type
++) {
345 const int alignment
= 32 / 4;
346 int num_samplers
= 0, pcb_len
= 0;
349 case PIPE_SHADER_VERTEX
:
351 num_samplers
= ilo_shader_get_kernel_param(vec
->vs
,
352 ILO_KERNEL_SAMPLER_COUNT
);
353 pcb_len
= ilo_shader_get_kernel_param(vec
->vs
,
354 ILO_KERNEL_PCB_CBUF0_SIZE
);
355 pcb_len
+= ilo_shader_get_kernel_param(vec
->vs
,
356 ILO_KERNEL_VS_PCB_UCP_SIZE
);
359 case PIPE_SHADER_GEOMETRY
:
361 case PIPE_SHADER_FRAGMENT
:
363 num_samplers
= ilo_shader_get_kernel_param(vec
->fs
,
364 ILO_KERNEL_SAMPLER_COUNT
);
365 pcb_len
= ilo_shader_get_kernel_param(vec
->fs
,
366 ILO_KERNEL_PCB_CBUF0_SIZE
);
373 /* SAMPLER_STATE array and SAMPLER_BORDER_COLORs */
375 /* prefetches are done in multiples of 4 */
376 num_samplers
= align(num_samplers
, 4);
378 len
+= align(GEN6_SAMPLER_STATE__SIZE
* num_samplers
, alignment
);
380 if (ilo_dev_gen(render
->dev
) >= ILO_GEN(8)) {
381 len
+= align(GEN6_SAMPLER_BORDER_COLOR_STATE__SIZE
, 64 / 4) *
384 len
+= align(GEN6_SAMPLER_BORDER_COLOR_STATE__SIZE
, alignment
) *
391 len
+= align(pcb_len
, alignment
);
398 ilo_render_emit_draw_dynamic_states(struct ilo_render
*render
,
399 const struct ilo_state_vector
*vec
,
400 struct ilo_render_draw_session
*session
)
402 const unsigned dynamic_used
= ilo_builder_dynamic_used(render
->builder
);
404 ILO_DEV_ASSERT(render
->dev
, 6, 8);
406 if (ilo_dev_gen(render
->dev
) >= ILO_GEN(7))
407 gen7_emit_draw_dynamic_viewports(render
, vec
, session
);
409 gen6_emit_draw_dynamic_viewports(render
, vec
, session
);
411 gen6_emit_draw_dynamic_cc(render
, vec
, session
);
412 gen6_emit_draw_dynamic_scissors(render
, vec
, session
);
413 gen6_emit_draw_dynamic_pcb(render
, vec
, session
);
415 gen6_emit_draw_dynamic_samplers(render
, vec
,
416 PIPE_SHADER_VERTEX
, session
);
417 gen6_emit_draw_dynamic_samplers(render
, vec
,
418 PIPE_SHADER_FRAGMENT
, session
);
420 assert(ilo_builder_dynamic_used(render
->builder
) <= dynamic_used
+
421 ilo_render_get_draw_dynamic_states_len(render
, vec
));
425 ilo_render_get_rectlist_dynamic_states_len(const struct ilo_render
*render
,
426 const struct ilo_blitter
*blitter
)
428 ILO_DEV_ASSERT(render
->dev
, 6, 8);
430 return (ilo_dev_gen(render
->dev
) >= ILO_GEN(8)) ? 0 : 96;
434 ilo_render_emit_rectlist_dynamic_states(struct ilo_render
*render
,
435 const struct ilo_blitter
*blitter
,
436 struct ilo_render_rectlist_session
*session
)
438 const unsigned dynamic_used
= ilo_builder_dynamic_used(render
->builder
);
440 ILO_DEV_ASSERT(render
->dev
, 6, 8);
442 if (ilo_dev_gen(render
->dev
) >= ILO_GEN(8))
445 /* both are inclusive */
446 session
->vb_start
= gen6_user_vertex_buffer(render
->builder
,
447 sizeof(blitter
->vertices
), (const void *) blitter
->vertices
);
448 session
->vb_end
= session
->vb_start
+ sizeof(blitter
->vertices
) - 1;
450 if (blitter
->uses
& ILO_BLITTER_USE_DSA
) {
451 render
->state
.DEPTH_STENCIL_STATE
=
452 gen6_DEPTH_STENCIL_STATE(render
->builder
, &blitter
->cc
);
455 if (blitter
->uses
& ILO_BLITTER_USE_CC
) {
456 render
->state
.COLOR_CALC_STATE
=
457 gen6_COLOR_CALC_STATE(render
->builder
, &blitter
->cc
);
460 if (blitter
->uses
& ILO_BLITTER_USE_VIEWPORT
) {
461 render
->state
.CC_VIEWPORT
=
462 gen6_CC_VIEWPORT(render
->builder
, &blitter
->vp
);
465 assert(ilo_builder_dynamic_used(render
->builder
) <= dynamic_used
+
466 ilo_render_get_rectlist_dynamic_states_len(render
, blitter
));
470 gen6_emit_launch_grid_dynamic_samplers(struct ilo_render
*r
,
471 const struct ilo_state_vector
*vec
,
472 struct ilo_render_launch_grid_session
*session
)
474 const unsigned shader_type
= PIPE_SHADER_COMPUTE
;
475 const struct ilo_shader_state
*cs
= vec
->cs
;
476 const struct ilo_view_cso
* const *views
=
477 (const struct ilo_view_cso
**) vec
->view
[shader_type
].states
;
478 struct ilo_state_sampler samplers
[ILO_MAX_SAMPLERS
];
479 int sampler_count
, i
;
481 ILO_DEV_ASSERT(r
->dev
, 7, 7.5);
483 sampler_count
= ilo_shader_get_kernel_param(cs
, ILO_KERNEL_SAMPLER_COUNT
);
485 assert(sampler_count
<= Elements(vec
->view
[shader_type
].states
) &&
486 sampler_count
<= Elements(vec
->sampler
[shader_type
].cso
));
488 for (i
= 0; i
< sampler_count
; i
++) {
489 const struct ilo_sampler_cso
*cso
= vec
->sampler
[shader_type
].cso
[i
];
491 r
->state
.cs
.SAMPLER_BORDER_COLOR_STATE
[i
] = (cso
) ?
492 gen6_SAMPLER_BORDER_COLOR_STATE(r
->builder
, &cso
->border
) : 0;
495 for (i
= 0; i
< sampler_count
; i
++) {
496 const struct ilo_sampler_cso
*cso
= vec
->sampler
[shader_type
].cso
[i
];
498 if (cso
&& views
[i
]) {
499 samplers
[i
] = cso
->sampler
;
500 ilo_state_sampler_set_surface(&samplers
[i
],
501 r
->dev
, &views
[i
]->surface
);
503 samplers
[i
] = vec
->disabled_sampler
;
507 r
->state
.cs
.SAMPLER_STATE
= gen6_SAMPLER_STATE(r
->builder
, samplers
,
508 r
->state
.cs
.SAMPLER_BORDER_COLOR_STATE
, sampler_count
);
512 gen6_emit_launch_grid_dynamic_pcb(struct ilo_render
*r
,
513 const struct ilo_state_vector
*vec
,
514 struct ilo_render_launch_grid_session
*session
)
516 r
->state
.cs
.PUSH_CONSTANT_BUFFER
= 0;
517 r
->state
.cs
.PUSH_CONSTANT_BUFFER_size
= 0;
521 gen6_emit_launch_grid_dynamic_idrt(struct ilo_render
*r
,
522 const struct ilo_state_vector
*vec
,
523 struct ilo_render_launch_grid_session
*session
)
525 const struct ilo_shader_state
*cs
= vec
->cs
;
526 struct ilo_state_compute_interface_info interface
;
527 struct ilo_state_compute_info info
;
528 uint32_t kernel_offset
;
530 ILO_DEV_ASSERT(r
->dev
, 7, 7.5);
532 memset(&interface
, 0, sizeof(interface
));
534 interface
.sampler_count
=
535 ilo_shader_get_kernel_param(cs
, ILO_KERNEL_SAMPLER_COUNT
);
536 interface
.surface_count
=
537 ilo_shader_get_kernel_param(cs
, ILO_KERNEL_SURFACE_TOTAL_COUNT
);
538 interface
.thread_group_size
= session
->thread_group_size
;
540 ilo_shader_get_kernel_param(cs
, ILO_KERNEL_CS_LOCAL_SIZE
);
541 interface
.curbe_read_length
= r
->state
.cs
.PUSH_CONSTANT_BUFFER_size
;
543 memset(&info
, 0, sizeof(info
));
544 info
.data
= session
->compute_data
;
545 info
.data_size
= sizeof(session
->compute_data
);
546 info
.interfaces
= &interface
;
547 info
.interface_count
= 1;
548 info
.cv_urb_alloc_size
= r
->dev
->urb_size
;
549 info
.curbe_alloc_size
= r
->state
.cs
.PUSH_CONSTANT_BUFFER_size
;
551 ilo_state_compute_init(&session
->compute
, r
->dev
, &info
);
553 kernel_offset
= ilo_shader_get_kernel_offset(cs
);
555 session
->idrt
= gen6_INTERFACE_DESCRIPTOR_DATA(r
->builder
,
556 &session
->compute
, &kernel_offset
,
557 &r
->state
.cs
.SAMPLER_STATE
, &r
->state
.cs
.BINDING_TABLE_STATE
);
559 session
->idrt_size
= 32;
563 ilo_render_get_launch_grid_dynamic_states_len(const struct ilo_render
*render
,
564 const struct ilo_state_vector
*vec
)
566 const int alignment
= 32 / 4;
570 ILO_DEV_ASSERT(render
->dev
, 7, 7.5);
572 num_samplers
= ilo_shader_get_kernel_param(vec
->cs
,
573 ILO_KERNEL_SAMPLER_COUNT
);
575 /* SAMPLER_STATE array and SAMPLER_BORDER_COLORs */
577 /* prefetches are done in multiples of 4 */
578 num_samplers
= align(num_samplers
, 4);
580 len
+= align(GEN6_SAMPLER_STATE__SIZE
* num_samplers
, alignment
) +
581 align(GEN6_SAMPLER_BORDER_COLOR_STATE__SIZE
, alignment
) *
585 len
+= GEN6_INTERFACE_DESCRIPTOR_DATA__SIZE
;
591 ilo_render_emit_launch_grid_dynamic_states(struct ilo_render
*render
,
592 const struct ilo_state_vector
*vec
,
593 struct ilo_render_launch_grid_session
*session
)
595 const unsigned dynamic_used
= ilo_builder_dynamic_used(render
->builder
);
597 ILO_DEV_ASSERT(render
->dev
, 7, 7.5);
599 gen6_emit_launch_grid_dynamic_samplers(render
, vec
, session
);
600 gen6_emit_launch_grid_dynamic_pcb(render
, vec
, session
);
601 gen6_emit_launch_grid_dynamic_idrt(render
, vec
, session
);
603 assert(ilo_builder_dynamic_used(render
->builder
) <= dynamic_used
+
604 ilo_render_get_launch_grid_dynamic_states_len(render
, vec
));