1 /**************************************************************************
3 * Copyright 2007 VMware, Inc.
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26 **************************************************************************/
31 * Wrap the cso cache & hash mechanisms in a simplified
32 * pipe-driver-specific interface.
34 * @author Zack Rusin <zackr@vmware.com>
35 * @author Keith Whitwell <keithw@vmware.com>
38 #include "pipe/p_state.h"
39 #include "util/u_draw.h"
40 #include "util/u_framebuffer.h"
41 #include "util/u_inlines.h"
42 #include "util/u_math.h"
43 #include "util/u_memory.h"
44 #include "util/u_vbuf.h"
45 #include "tgsi/tgsi_parse.h"
47 #include "cso_cache/cso_context.h"
48 #include "cso_cache/cso_cache.h"
49 #include "cso_cache/cso_hash.h"
50 #include "cso_context.h"
54 * Info related to samplers and sampler views.
55 * We have one of these for fragment samplers and another for vertex samplers.
59 void *samplers
[PIPE_MAX_SAMPLERS
];
66 struct pipe_context
*pipe
;
67 struct cso_cache
*cache
;
70 boolean has_geometry_shader
;
71 boolean has_tessellation
;
72 boolean has_compute_shader
;
73 boolean has_streamout
;
75 unsigned saved_state
; /**< bitmask of CSO_BIT_x flags */
77 struct pipe_sampler_view
*fragment_views
[PIPE_MAX_SHADER_SAMPLER_VIEWS
];
78 unsigned nr_fragment_views
;
80 struct pipe_sampler_view
*fragment_views_saved
[PIPE_MAX_SHADER_SAMPLER_VIEWS
];
81 unsigned nr_fragment_views_saved
;
83 void *fragment_samplers_saved
[PIPE_MAX_SAMPLERS
];
84 unsigned nr_fragment_samplers_saved
;
86 struct sampler_info samplers
[PIPE_SHADER_TYPES
];
88 struct pipe_vertex_buffer aux_vertex_buffer_current
;
89 struct pipe_vertex_buffer aux_vertex_buffer_saved
;
90 unsigned aux_vertex_buffer_index
;
92 struct pipe_constant_buffer aux_constbuf_current
[PIPE_SHADER_TYPES
];
93 struct pipe_constant_buffer aux_constbuf_saved
[PIPE_SHADER_TYPES
];
95 unsigned nr_so_targets
;
96 struct pipe_stream_output_target
*so_targets
[PIPE_MAX_SO_BUFFERS
];
98 unsigned nr_so_targets_saved
;
99 struct pipe_stream_output_target
*so_targets_saved
[PIPE_MAX_SO_BUFFERS
];
101 /** Current and saved state.
102 * The saved state is used as a 1-deep stack.
104 void *blend
, *blend_saved
;
105 void *depth_stencil
, *depth_stencil_saved
;
106 void *rasterizer
, *rasterizer_saved
;
107 void *fragment_shader
, *fragment_shader_saved
;
108 void *vertex_shader
, *vertex_shader_saved
;
109 void *geometry_shader
, *geometry_shader_saved
;
110 void *tessctrl_shader
, *tessctrl_shader_saved
;
111 void *tesseval_shader
, *tesseval_shader_saved
;
112 void *compute_shader
;
113 void *velements
, *velements_saved
;
114 struct pipe_query
*render_condition
, *render_condition_saved
;
115 uint render_condition_mode
, render_condition_mode_saved
;
116 boolean render_condition_cond
, render_condition_cond_saved
;
118 struct pipe_framebuffer_state fb
, fb_saved
;
119 struct pipe_viewport_state vp
, vp_saved
;
120 struct pipe_blend_color blend_color
;
121 unsigned sample_mask
, sample_mask_saved
;
122 unsigned min_samples
, min_samples_saved
;
123 struct pipe_stencil_ref stencil_ref
, stencil_ref_saved
;
127 static boolean
delete_blend_state(struct cso_context
*ctx
, void *state
)
129 struct cso_blend
*cso
= (struct cso_blend
*)state
;
131 if (ctx
->blend
== cso
->data
)
134 if (cso
->delete_state
)
135 cso
->delete_state(cso
->context
, cso
->data
);
140 static boolean
delete_depth_stencil_state(struct cso_context
*ctx
, void *state
)
142 struct cso_depth_stencil_alpha
*cso
=
143 (struct cso_depth_stencil_alpha
*)state
;
145 if (ctx
->depth_stencil
== cso
->data
)
148 if (cso
->delete_state
)
149 cso
->delete_state(cso
->context
, cso
->data
);
155 static boolean
delete_sampler_state(struct cso_context
*ctx
, void *state
)
157 struct cso_sampler
*cso
= (struct cso_sampler
*)state
;
158 if (cso
->delete_state
)
159 cso
->delete_state(cso
->context
, cso
->data
);
164 static boolean
delete_rasterizer_state(struct cso_context
*ctx
, void *state
)
166 struct cso_rasterizer
*cso
= (struct cso_rasterizer
*)state
;
168 if (ctx
->rasterizer
== cso
->data
)
170 if (cso
->delete_state
)
171 cso
->delete_state(cso
->context
, cso
->data
);
176 static boolean
delete_vertex_elements(struct cso_context
*ctx
,
179 struct cso_velements
*cso
= (struct cso_velements
*)state
;
181 if (ctx
->velements
== cso
->data
)
184 if (cso
->delete_state
)
185 cso
->delete_state(cso
->context
, cso
->data
);
191 static inline boolean
delete_cso(struct cso_context
*ctx
,
192 void *state
, enum cso_cache_type type
)
196 return delete_blend_state(ctx
, state
);
198 return delete_sampler_state(ctx
, state
);
199 case CSO_DEPTH_STENCIL_ALPHA
:
200 return delete_depth_stencil_state(ctx
, state
);
202 return delete_rasterizer_state(ctx
, state
);
204 return delete_vertex_elements(ctx
, state
);
213 sanitize_hash(struct cso_hash
*hash
, enum cso_cache_type type
,
214 int max_size
, void *user_data
)
216 struct cso_context
*ctx
= (struct cso_context
*)user_data
;
217 /* if we're approach the maximum size, remove fourth of the entries
218 * otherwise every subsequent call will go through the same */
219 int hash_size
= cso_hash_size(hash
);
220 int max_entries
= (max_size
> hash_size
) ? max_size
: hash_size
;
221 int to_remove
= (max_size
< max_entries
) * max_entries
/4;
222 struct cso_hash_iter iter
= cso_hash_first_node(hash
);
223 if (hash_size
> max_size
)
224 to_remove
+= hash_size
- max_size
;
226 /*remove elements until we're good */
227 /*fixme: currently we pick the nodes to remove at random*/
228 void *cso
= cso_hash_iter_data(iter
);
229 if (delete_cso(ctx
, cso
, type
)) {
230 iter
= cso_hash_erase(hash
, iter
);
233 iter
= cso_hash_iter_next(iter
);
237 static void cso_init_vbuf(struct cso_context
*cso
)
239 struct u_vbuf_caps caps
;
241 /* Install u_vbuf if there is anything unsupported. */
242 if (u_vbuf_get_caps(cso
->pipe
->screen
, &caps
)) {
243 cso
->vbuf
= u_vbuf_create(cso
->pipe
, &caps
,
244 cso
->aux_vertex_buffer_index
);
248 struct cso_context
*cso_create_context( struct pipe_context
*pipe
)
250 struct cso_context
*ctx
= CALLOC_STRUCT(cso_context
);
254 ctx
->cache
= cso_cache_create();
255 if (ctx
->cache
== NULL
)
257 cso_cache_set_sanitize_callback(ctx
->cache
,
262 ctx
->sample_mask
= ~0;
264 ctx
->aux_vertex_buffer_index
= 0; /* 0 for now */
268 /* Enable for testing: */
269 if (0) cso_set_maximum_cache_size( ctx
->cache
, 4 );
271 if (pipe
->screen
->get_shader_param(pipe
->screen
, PIPE_SHADER_GEOMETRY
,
272 PIPE_SHADER_CAP_MAX_INSTRUCTIONS
) > 0) {
273 ctx
->has_geometry_shader
= TRUE
;
275 if (pipe
->screen
->get_shader_param(pipe
->screen
, PIPE_SHADER_TESS_CTRL
,
276 PIPE_SHADER_CAP_MAX_INSTRUCTIONS
) > 0) {
277 ctx
->has_tessellation
= TRUE
;
279 if (pipe
->screen
->get_shader_param(pipe
->screen
, PIPE_SHADER_COMPUTE
,
280 PIPE_SHADER_CAP_MAX_INSTRUCTIONS
) > 0) {
282 pipe
->screen
->get_shader_param(pipe
->screen
, PIPE_SHADER_COMPUTE
,
283 PIPE_SHADER_CAP_SUPPORTED_IRS
);
284 if (supported_irs
& (1 << PIPE_SHADER_IR_TGSI
)) {
285 ctx
->has_compute_shader
= TRUE
;
288 if (pipe
->screen
->get_param(pipe
->screen
,
289 PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS
) != 0) {
290 ctx
->has_streamout
= TRUE
;
296 cso_destroy_context( ctx
);
301 * Free the CSO context.
303 void cso_destroy_context( struct cso_context
*ctx
)
308 ctx
->pipe
->set_index_buffer(ctx
->pipe
, NULL
);
310 ctx
->pipe
->bind_blend_state( ctx
->pipe
, NULL
);
311 ctx
->pipe
->bind_rasterizer_state( ctx
->pipe
, NULL
);
314 static struct pipe_sampler_view
*views
[PIPE_MAX_SHADER_SAMPLER_VIEWS
] = { NULL
};
315 static void *zeros
[PIPE_MAX_SAMPLERS
] = { NULL
};
316 struct pipe_screen
*scr
= ctx
->pipe
->screen
;
318 for (sh
= 0; sh
< PIPE_SHADER_TYPES
; sh
++) {
319 int maxsam
= scr
->get_shader_param(scr
, sh
,
320 PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS
);
321 int maxview
= scr
->get_shader_param(scr
, sh
,
322 PIPE_SHADER_CAP_MAX_SAMPLER_VIEWS
);
323 assert(maxsam
<= PIPE_MAX_SAMPLERS
);
324 assert(maxview
<= PIPE_MAX_SHADER_SAMPLER_VIEWS
);
326 ctx
->pipe
->bind_sampler_states(ctx
->pipe
, sh
, 0, maxsam
, zeros
);
329 ctx
->pipe
->set_sampler_views(ctx
->pipe
, sh
, 0, maxview
, views
);
334 ctx
->pipe
->bind_depth_stencil_alpha_state( ctx
->pipe
, NULL
);
335 ctx
->pipe
->bind_fs_state( ctx
->pipe
, NULL
);
336 ctx
->pipe
->set_constant_buffer(ctx
->pipe
, PIPE_SHADER_FRAGMENT
, 0, NULL
);
337 ctx
->pipe
->bind_vs_state( ctx
->pipe
, NULL
);
338 ctx
->pipe
->set_constant_buffer(ctx
->pipe
, PIPE_SHADER_VERTEX
, 0, NULL
);
339 if (ctx
->has_geometry_shader
) {
340 ctx
->pipe
->bind_gs_state(ctx
->pipe
, NULL
);
341 ctx
->pipe
->set_constant_buffer(ctx
->pipe
, PIPE_SHADER_GEOMETRY
, 0, NULL
);
343 if (ctx
->has_tessellation
) {
344 ctx
->pipe
->bind_tcs_state(ctx
->pipe
, NULL
);
345 ctx
->pipe
->set_constant_buffer(ctx
->pipe
, PIPE_SHADER_TESS_CTRL
, 0, NULL
);
346 ctx
->pipe
->bind_tes_state(ctx
->pipe
, NULL
);
347 ctx
->pipe
->set_constant_buffer(ctx
->pipe
, PIPE_SHADER_TESS_EVAL
, 0, NULL
);
349 if (ctx
->has_compute_shader
) {
350 ctx
->pipe
->bind_compute_state(ctx
->pipe
, NULL
);
351 ctx
->pipe
->set_constant_buffer(ctx
->pipe
, PIPE_SHADER_COMPUTE
, 0, NULL
);
353 ctx
->pipe
->bind_vertex_elements_state( ctx
->pipe
, NULL
);
355 if (ctx
->has_streamout
)
356 ctx
->pipe
->set_stream_output_targets(ctx
->pipe
, 0, NULL
, NULL
);
359 for (i
= 0; i
< PIPE_MAX_SHADER_SAMPLER_VIEWS
; i
++) {
360 pipe_sampler_view_reference(&ctx
->fragment_views
[i
], NULL
);
361 pipe_sampler_view_reference(&ctx
->fragment_views_saved
[i
], NULL
);
364 util_unreference_framebuffer_state(&ctx
->fb
);
365 util_unreference_framebuffer_state(&ctx
->fb_saved
);
367 pipe_resource_reference(&ctx
->aux_vertex_buffer_current
.buffer
, NULL
);
368 pipe_resource_reference(&ctx
->aux_vertex_buffer_saved
.buffer
, NULL
);
370 for (i
= 0; i
< PIPE_SHADER_TYPES
; i
++) {
371 pipe_resource_reference(&ctx
->aux_constbuf_current
[i
].buffer
, NULL
);
372 pipe_resource_reference(&ctx
->aux_constbuf_saved
[i
].buffer
, NULL
);
375 for (i
= 0; i
< PIPE_MAX_SO_BUFFERS
; i
++) {
376 pipe_so_target_reference(&ctx
->so_targets
[i
], NULL
);
377 pipe_so_target_reference(&ctx
->so_targets_saved
[i
], NULL
);
381 cso_cache_delete( ctx
->cache
);
386 u_vbuf_destroy(ctx
->vbuf
);
391 /* Those function will either find the state of the given template
392 * in the cache or they will create a new state from the given
393 * template, insert it in the cache and return it.
397 * If the driver returns 0 from the create method then they will assign
398 * the data member of the cso to be the template itself.
401 enum pipe_error
cso_set_blend(struct cso_context
*ctx
,
402 const struct pipe_blend_state
*templ
)
404 unsigned key_size
, hash_key
;
405 struct cso_hash_iter iter
;
408 key_size
= templ
->independent_blend_enable
?
409 sizeof(struct pipe_blend_state
) :
410 (char *)&(templ
->rt
[1]) - (char *)templ
;
411 hash_key
= cso_construct_key((void*)templ
, key_size
);
412 iter
= cso_find_state_template(ctx
->cache
, hash_key
, CSO_BLEND
,
413 (void*)templ
, key_size
);
415 if (cso_hash_iter_is_null(iter
)) {
416 struct cso_blend
*cso
= MALLOC(sizeof(struct cso_blend
));
418 return PIPE_ERROR_OUT_OF_MEMORY
;
420 memset(&cso
->state
, 0, sizeof cso
->state
);
421 memcpy(&cso
->state
, templ
, key_size
);
422 cso
->data
= ctx
->pipe
->create_blend_state(ctx
->pipe
, &cso
->state
);
423 cso
->delete_state
= (cso_state_callback
)ctx
->pipe
->delete_blend_state
;
424 cso
->context
= ctx
->pipe
;
426 iter
= cso_insert_state(ctx
->cache
, hash_key
, CSO_BLEND
, cso
);
427 if (cso_hash_iter_is_null(iter
)) {
429 return PIPE_ERROR_OUT_OF_MEMORY
;
435 handle
= ((struct cso_blend
*)cso_hash_iter_data(iter
))->data
;
438 if (ctx
->blend
!= handle
) {
440 ctx
->pipe
->bind_blend_state(ctx
->pipe
, handle
);
446 cso_save_blend(struct cso_context
*ctx
)
448 assert(!ctx
->blend_saved
);
449 ctx
->blend_saved
= ctx
->blend
;
453 cso_restore_blend(struct cso_context
*ctx
)
455 if (ctx
->blend
!= ctx
->blend_saved
) {
456 ctx
->blend
= ctx
->blend_saved
;
457 ctx
->pipe
->bind_blend_state(ctx
->pipe
, ctx
->blend_saved
);
459 ctx
->blend_saved
= NULL
;
465 cso_set_depth_stencil_alpha(struct cso_context
*ctx
,
466 const struct pipe_depth_stencil_alpha_state
*templ
)
468 unsigned key_size
= sizeof(struct pipe_depth_stencil_alpha_state
);
469 unsigned hash_key
= cso_construct_key((void*)templ
, key_size
);
470 struct cso_hash_iter iter
= cso_find_state_template(ctx
->cache
,
472 CSO_DEPTH_STENCIL_ALPHA
,
473 (void*)templ
, key_size
);
476 if (cso_hash_iter_is_null(iter
)) {
477 struct cso_depth_stencil_alpha
*cso
=
478 MALLOC(sizeof(struct cso_depth_stencil_alpha
));
480 return PIPE_ERROR_OUT_OF_MEMORY
;
482 memcpy(&cso
->state
, templ
, sizeof(*templ
));
483 cso
->data
= ctx
->pipe
->create_depth_stencil_alpha_state(ctx
->pipe
,
486 (cso_state_callback
)ctx
->pipe
->delete_depth_stencil_alpha_state
;
487 cso
->context
= ctx
->pipe
;
489 iter
= cso_insert_state(ctx
->cache
, hash_key
,
490 CSO_DEPTH_STENCIL_ALPHA
, cso
);
491 if (cso_hash_iter_is_null(iter
)) {
493 return PIPE_ERROR_OUT_OF_MEMORY
;
499 handle
= ((struct cso_depth_stencil_alpha
*)
500 cso_hash_iter_data(iter
))->data
;
503 if (ctx
->depth_stencil
!= handle
) {
504 ctx
->depth_stencil
= handle
;
505 ctx
->pipe
->bind_depth_stencil_alpha_state(ctx
->pipe
, handle
);
511 cso_save_depth_stencil_alpha(struct cso_context
*ctx
)
513 assert(!ctx
->depth_stencil_saved
);
514 ctx
->depth_stencil_saved
= ctx
->depth_stencil
;
518 cso_restore_depth_stencil_alpha(struct cso_context
*ctx
)
520 if (ctx
->depth_stencil
!= ctx
->depth_stencil_saved
) {
521 ctx
->depth_stencil
= ctx
->depth_stencil_saved
;
522 ctx
->pipe
->bind_depth_stencil_alpha_state(ctx
->pipe
,
523 ctx
->depth_stencil_saved
);
525 ctx
->depth_stencil_saved
= NULL
;
530 enum pipe_error
cso_set_rasterizer(struct cso_context
*ctx
,
531 const struct pipe_rasterizer_state
*templ
)
533 unsigned key_size
= sizeof(struct pipe_rasterizer_state
);
534 unsigned hash_key
= cso_construct_key((void*)templ
, key_size
);
535 struct cso_hash_iter iter
= cso_find_state_template(ctx
->cache
,
538 (void*)templ
, key_size
);
541 if (cso_hash_iter_is_null(iter
)) {
542 struct cso_rasterizer
*cso
= MALLOC(sizeof(struct cso_rasterizer
));
544 return PIPE_ERROR_OUT_OF_MEMORY
;
546 memcpy(&cso
->state
, templ
, sizeof(*templ
));
547 cso
->data
= ctx
->pipe
->create_rasterizer_state(ctx
->pipe
, &cso
->state
);
549 (cso_state_callback
)ctx
->pipe
->delete_rasterizer_state
;
550 cso
->context
= ctx
->pipe
;
552 iter
= cso_insert_state(ctx
->cache
, hash_key
, CSO_RASTERIZER
, cso
);
553 if (cso_hash_iter_is_null(iter
)) {
555 return PIPE_ERROR_OUT_OF_MEMORY
;
561 handle
= ((struct cso_rasterizer
*)cso_hash_iter_data(iter
))->data
;
564 if (ctx
->rasterizer
!= handle
) {
565 ctx
->rasterizer
= handle
;
566 ctx
->pipe
->bind_rasterizer_state(ctx
->pipe
, handle
);
572 cso_save_rasterizer(struct cso_context
*ctx
)
574 assert(!ctx
->rasterizer_saved
);
575 ctx
->rasterizer_saved
= ctx
->rasterizer
;
579 cso_restore_rasterizer(struct cso_context
*ctx
)
581 if (ctx
->rasterizer
!= ctx
->rasterizer_saved
) {
582 ctx
->rasterizer
= ctx
->rasterizer_saved
;
583 ctx
->pipe
->bind_rasterizer_state(ctx
->pipe
, ctx
->rasterizer_saved
);
585 ctx
->rasterizer_saved
= NULL
;
589 void cso_set_fragment_shader_handle(struct cso_context
*ctx
, void *handle
)
591 if (ctx
->fragment_shader
!= handle
) {
592 ctx
->fragment_shader
= handle
;
593 ctx
->pipe
->bind_fs_state(ctx
->pipe
, handle
);
597 void cso_delete_fragment_shader(struct cso_context
*ctx
, void *handle
)
599 if (handle
== ctx
->fragment_shader
) {
600 /* unbind before deleting */
601 ctx
->pipe
->bind_fs_state(ctx
->pipe
, NULL
);
602 ctx
->fragment_shader
= NULL
;
604 ctx
->pipe
->delete_fs_state(ctx
->pipe
, handle
);
608 cso_save_fragment_shader(struct cso_context
*ctx
)
610 assert(!ctx
->fragment_shader_saved
);
611 ctx
->fragment_shader_saved
= ctx
->fragment_shader
;
615 cso_restore_fragment_shader(struct cso_context
*ctx
)
617 if (ctx
->fragment_shader_saved
!= ctx
->fragment_shader
) {
618 ctx
->pipe
->bind_fs_state(ctx
->pipe
, ctx
->fragment_shader_saved
);
619 ctx
->fragment_shader
= ctx
->fragment_shader_saved
;
621 ctx
->fragment_shader_saved
= NULL
;
625 void cso_set_vertex_shader_handle(struct cso_context
*ctx
, void *handle
)
627 if (ctx
->vertex_shader
!= handle
) {
628 ctx
->vertex_shader
= handle
;
629 ctx
->pipe
->bind_vs_state(ctx
->pipe
, handle
);
633 void cso_delete_vertex_shader(struct cso_context
*ctx
, void *handle
)
635 if (handle
== ctx
->vertex_shader
) {
636 /* unbind before deleting */
637 ctx
->pipe
->bind_vs_state(ctx
->pipe
, NULL
);
638 ctx
->vertex_shader
= NULL
;
640 ctx
->pipe
->delete_vs_state(ctx
->pipe
, handle
);
644 cso_save_vertex_shader(struct cso_context
*ctx
)
646 assert(!ctx
->vertex_shader_saved
);
647 ctx
->vertex_shader_saved
= ctx
->vertex_shader
;
651 cso_restore_vertex_shader(struct cso_context
*ctx
)
653 if (ctx
->vertex_shader_saved
!= ctx
->vertex_shader
) {
654 ctx
->pipe
->bind_vs_state(ctx
->pipe
, ctx
->vertex_shader_saved
);
655 ctx
->vertex_shader
= ctx
->vertex_shader_saved
;
657 ctx
->vertex_shader_saved
= NULL
;
661 void cso_set_framebuffer(struct cso_context
*ctx
,
662 const struct pipe_framebuffer_state
*fb
)
664 if (memcmp(&ctx
->fb
, fb
, sizeof(*fb
)) != 0) {
665 util_copy_framebuffer_state(&ctx
->fb
, fb
);
666 ctx
->pipe
->set_framebuffer_state(ctx
->pipe
, fb
);
671 cso_save_framebuffer(struct cso_context
*ctx
)
673 util_copy_framebuffer_state(&ctx
->fb_saved
, &ctx
->fb
);
677 cso_restore_framebuffer(struct cso_context
*ctx
)
679 if (memcmp(&ctx
->fb
, &ctx
->fb_saved
, sizeof(ctx
->fb
))) {
680 util_copy_framebuffer_state(&ctx
->fb
, &ctx
->fb_saved
);
681 ctx
->pipe
->set_framebuffer_state(ctx
->pipe
, &ctx
->fb
);
682 util_unreference_framebuffer_state(&ctx
->fb_saved
);
687 void cso_set_viewport(struct cso_context
*ctx
,
688 const struct pipe_viewport_state
*vp
)
690 if (memcmp(&ctx
->vp
, vp
, sizeof(*vp
))) {
692 ctx
->pipe
->set_viewport_states(ctx
->pipe
, 0, 1, vp
);
697 * Setup viewport state for given width and height (position is always (0,0)).
698 * Invert the Y axis if 'invert' is true.
701 cso_set_viewport_dims(struct cso_context
*ctx
,
702 float width
, float height
, boolean invert
)
704 struct pipe_viewport_state vp
;
705 vp
.scale
[0] = width
* 0.5f
;
706 vp
.scale
[1] = height
* (invert
? -0.5f
: 0.5f
);
708 vp
.translate
[0] = 0.5f
* width
;
709 vp
.translate
[1] = 0.5f
* height
;
710 vp
.translate
[2] = 0.5f
;
711 cso_set_viewport(ctx
, &vp
);
715 cso_save_viewport(struct cso_context
*ctx
)
717 ctx
->vp_saved
= ctx
->vp
;
722 cso_restore_viewport(struct cso_context
*ctx
)
724 if (memcmp(&ctx
->vp
, &ctx
->vp_saved
, sizeof(ctx
->vp
))) {
725 ctx
->vp
= ctx
->vp_saved
;
726 ctx
->pipe
->set_viewport_states(ctx
->pipe
, 0, 1, &ctx
->vp
);
731 void cso_set_blend_color(struct cso_context
*ctx
,
732 const struct pipe_blend_color
*bc
)
734 if (memcmp(&ctx
->blend_color
, bc
, sizeof(ctx
->blend_color
))) {
735 ctx
->blend_color
= *bc
;
736 ctx
->pipe
->set_blend_color(ctx
->pipe
, bc
);
740 void cso_set_sample_mask(struct cso_context
*ctx
, unsigned sample_mask
)
742 if (ctx
->sample_mask
!= sample_mask
) {
743 ctx
->sample_mask
= sample_mask
;
744 ctx
->pipe
->set_sample_mask(ctx
->pipe
, sample_mask
);
749 cso_save_sample_mask(struct cso_context
*ctx
)
751 ctx
->sample_mask_saved
= ctx
->sample_mask
;
755 cso_restore_sample_mask(struct cso_context
*ctx
)
757 cso_set_sample_mask(ctx
, ctx
->sample_mask_saved
);
760 void cso_set_min_samples(struct cso_context
*ctx
, unsigned min_samples
)
762 if (ctx
->min_samples
!= min_samples
&& ctx
->pipe
->set_min_samples
) {
763 ctx
->min_samples
= min_samples
;
764 ctx
->pipe
->set_min_samples(ctx
->pipe
, min_samples
);
769 cso_save_min_samples(struct cso_context
*ctx
)
771 ctx
->min_samples_saved
= ctx
->min_samples
;
775 cso_restore_min_samples(struct cso_context
*ctx
)
777 cso_set_min_samples(ctx
, ctx
->min_samples_saved
);
780 void cso_set_stencil_ref(struct cso_context
*ctx
,
781 const struct pipe_stencil_ref
*sr
)
783 if (memcmp(&ctx
->stencil_ref
, sr
, sizeof(ctx
->stencil_ref
))) {
784 ctx
->stencil_ref
= *sr
;
785 ctx
->pipe
->set_stencil_ref(ctx
->pipe
, sr
);
790 cso_save_stencil_ref(struct cso_context
*ctx
)
792 ctx
->stencil_ref_saved
= ctx
->stencil_ref
;
797 cso_restore_stencil_ref(struct cso_context
*ctx
)
799 if (memcmp(&ctx
->stencil_ref
, &ctx
->stencil_ref_saved
,
800 sizeof(ctx
->stencil_ref
))) {
801 ctx
->stencil_ref
= ctx
->stencil_ref_saved
;
802 ctx
->pipe
->set_stencil_ref(ctx
->pipe
, &ctx
->stencil_ref
);
806 void cso_set_render_condition(struct cso_context
*ctx
,
807 struct pipe_query
*query
,
808 boolean condition
, uint mode
)
810 struct pipe_context
*pipe
= ctx
->pipe
;
812 if (ctx
->render_condition
!= query
||
813 ctx
->render_condition_mode
!= mode
||
814 ctx
->render_condition_cond
!= condition
) {
815 pipe
->render_condition(pipe
, query
, condition
, mode
);
816 ctx
->render_condition
= query
;
817 ctx
->render_condition_cond
= condition
;
818 ctx
->render_condition_mode
= mode
;
823 cso_save_render_condition(struct cso_context
*ctx
)
825 ctx
->render_condition_saved
= ctx
->render_condition
;
826 ctx
->render_condition_cond_saved
= ctx
->render_condition_cond
;
827 ctx
->render_condition_mode_saved
= ctx
->render_condition_mode
;
831 cso_restore_render_condition(struct cso_context
*ctx
)
833 cso_set_render_condition(ctx
, ctx
->render_condition_saved
,
834 ctx
->render_condition_cond_saved
,
835 ctx
->render_condition_mode_saved
);
838 void cso_set_geometry_shader_handle(struct cso_context
*ctx
, void *handle
)
840 assert(ctx
->has_geometry_shader
|| !handle
);
842 if (ctx
->has_geometry_shader
&& ctx
->geometry_shader
!= handle
) {
843 ctx
->geometry_shader
= handle
;
844 ctx
->pipe
->bind_gs_state(ctx
->pipe
, handle
);
848 void cso_delete_geometry_shader(struct cso_context
*ctx
, void *handle
)
850 if (handle
== ctx
->geometry_shader
) {
851 /* unbind before deleting */
852 ctx
->pipe
->bind_gs_state(ctx
->pipe
, NULL
);
853 ctx
->geometry_shader
= NULL
;
855 ctx
->pipe
->delete_gs_state(ctx
->pipe
, handle
);
859 cso_save_geometry_shader(struct cso_context
*ctx
)
861 if (!ctx
->has_geometry_shader
) {
865 assert(!ctx
->geometry_shader_saved
);
866 ctx
->geometry_shader_saved
= ctx
->geometry_shader
;
870 cso_restore_geometry_shader(struct cso_context
*ctx
)
872 if (!ctx
->has_geometry_shader
) {
876 if (ctx
->geometry_shader_saved
!= ctx
->geometry_shader
) {
877 ctx
->pipe
->bind_gs_state(ctx
->pipe
, ctx
->geometry_shader_saved
);
878 ctx
->geometry_shader
= ctx
->geometry_shader_saved
;
880 ctx
->geometry_shader_saved
= NULL
;
883 void cso_set_tessctrl_shader_handle(struct cso_context
*ctx
, void *handle
)
885 assert(ctx
->has_tessellation
|| !handle
);
887 if (ctx
->has_tessellation
&& ctx
->tessctrl_shader
!= handle
) {
888 ctx
->tessctrl_shader
= handle
;
889 ctx
->pipe
->bind_tcs_state(ctx
->pipe
, handle
);
893 void cso_delete_tessctrl_shader(struct cso_context
*ctx
, void *handle
)
895 if (handle
== ctx
->tessctrl_shader
) {
896 /* unbind before deleting */
897 ctx
->pipe
->bind_tcs_state(ctx
->pipe
, NULL
);
898 ctx
->tessctrl_shader
= NULL
;
900 ctx
->pipe
->delete_tcs_state(ctx
->pipe
, handle
);
904 cso_save_tessctrl_shader(struct cso_context
*ctx
)
906 if (!ctx
->has_tessellation
) {
910 assert(!ctx
->tessctrl_shader_saved
);
911 ctx
->tessctrl_shader_saved
= ctx
->tessctrl_shader
;
915 cso_restore_tessctrl_shader(struct cso_context
*ctx
)
917 if (!ctx
->has_tessellation
) {
921 if (ctx
->tessctrl_shader_saved
!= ctx
->tessctrl_shader
) {
922 ctx
->pipe
->bind_tcs_state(ctx
->pipe
, ctx
->tessctrl_shader_saved
);
923 ctx
->tessctrl_shader
= ctx
->tessctrl_shader_saved
;
925 ctx
->tessctrl_shader_saved
= NULL
;
928 void cso_set_tesseval_shader_handle(struct cso_context
*ctx
, void *handle
)
930 assert(ctx
->has_tessellation
|| !handle
);
932 if (ctx
->has_tessellation
&& ctx
->tesseval_shader
!= handle
) {
933 ctx
->tesseval_shader
= handle
;
934 ctx
->pipe
->bind_tes_state(ctx
->pipe
, handle
);
938 void cso_delete_tesseval_shader(struct cso_context
*ctx
, void *handle
)
940 if (handle
== ctx
->tesseval_shader
) {
941 /* unbind before deleting */
942 ctx
->pipe
->bind_tes_state(ctx
->pipe
, NULL
);
943 ctx
->tesseval_shader
= NULL
;
945 ctx
->pipe
->delete_tes_state(ctx
->pipe
, handle
);
949 cso_save_tesseval_shader(struct cso_context
*ctx
)
951 if (!ctx
->has_tessellation
) {
955 assert(!ctx
->tesseval_shader_saved
);
956 ctx
->tesseval_shader_saved
= ctx
->tesseval_shader
;
960 cso_restore_tesseval_shader(struct cso_context
*ctx
)
962 if (!ctx
->has_tessellation
) {
966 if (ctx
->tesseval_shader_saved
!= ctx
->tesseval_shader
) {
967 ctx
->pipe
->bind_tes_state(ctx
->pipe
, ctx
->tesseval_shader_saved
);
968 ctx
->tesseval_shader
= ctx
->tesseval_shader_saved
;
970 ctx
->tesseval_shader_saved
= NULL
;
973 void cso_set_compute_shader_handle(struct cso_context
*ctx
, void *handle
)
975 assert(ctx
->has_compute_shader
|| !handle
);
977 if (ctx
->has_compute_shader
&& ctx
->compute_shader
!= handle
) {
978 ctx
->compute_shader
= handle
;
979 ctx
->pipe
->bind_compute_state(ctx
->pipe
, handle
);
983 void cso_delete_compute_shader(struct cso_context
*ctx
, void *handle
)
985 if (handle
== ctx
->compute_shader
) {
986 /* unbind before deleting */
987 ctx
->pipe
->bind_compute_state(ctx
->pipe
, NULL
);
988 ctx
->compute_shader
= NULL
;
990 ctx
->pipe
->delete_compute_state(ctx
->pipe
, handle
);
994 cso_set_vertex_elements(struct cso_context
*ctx
,
996 const struct pipe_vertex_element
*states
)
998 struct u_vbuf
*vbuf
= ctx
->vbuf
;
999 unsigned key_size
, hash_key
;
1000 struct cso_hash_iter iter
;
1002 struct cso_velems_state velems_state
;
1005 u_vbuf_set_vertex_elements(vbuf
, count
, states
);
1009 /* Need to include the count into the stored state data too.
1010 * Otherwise first few count pipe_vertex_elements could be identical
1011 * even if count is different, and there's no guarantee the hash would
1012 * be different in that case neither.
1014 key_size
= sizeof(struct pipe_vertex_element
) * count
+ sizeof(unsigned);
1015 velems_state
.count
= count
;
1016 memcpy(velems_state
.velems
, states
,
1017 sizeof(struct pipe_vertex_element
) * count
);
1018 hash_key
= cso_construct_key((void*)&velems_state
, key_size
);
1019 iter
= cso_find_state_template(ctx
->cache
, hash_key
, CSO_VELEMENTS
,
1020 (void*)&velems_state
, key_size
);
1022 if (cso_hash_iter_is_null(iter
)) {
1023 struct cso_velements
*cso
= MALLOC(sizeof(struct cso_velements
));
1025 return PIPE_ERROR_OUT_OF_MEMORY
;
1027 memcpy(&cso
->state
, &velems_state
, key_size
);
1028 cso
->data
= ctx
->pipe
->create_vertex_elements_state(ctx
->pipe
, count
,
1029 &cso
->state
.velems
[0]);
1031 (cso_state_callback
) ctx
->pipe
->delete_vertex_elements_state
;
1032 cso
->context
= ctx
->pipe
;
1034 iter
= cso_insert_state(ctx
->cache
, hash_key
, CSO_VELEMENTS
, cso
);
1035 if (cso_hash_iter_is_null(iter
)) {
1037 return PIPE_ERROR_OUT_OF_MEMORY
;
1043 handle
= ((struct cso_velements
*)cso_hash_iter_data(iter
))->data
;
1046 if (ctx
->velements
!= handle
) {
1047 ctx
->velements
= handle
;
1048 ctx
->pipe
->bind_vertex_elements_state(ctx
->pipe
, handle
);
1054 cso_save_vertex_elements(struct cso_context
*ctx
)
1056 struct u_vbuf
*vbuf
= ctx
->vbuf
;
1059 u_vbuf_save_vertex_elements(vbuf
);
1063 assert(!ctx
->velements_saved
);
1064 ctx
->velements_saved
= ctx
->velements
;
1068 cso_restore_vertex_elements(struct cso_context
*ctx
)
1070 struct u_vbuf
*vbuf
= ctx
->vbuf
;
1073 u_vbuf_restore_vertex_elements(vbuf
);
1077 if (ctx
->velements
!= ctx
->velements_saved
) {
1078 ctx
->velements
= ctx
->velements_saved
;
1079 ctx
->pipe
->bind_vertex_elements_state(ctx
->pipe
, ctx
->velements_saved
);
1081 ctx
->velements_saved
= NULL
;
1084 /* vertex buffers */
1086 void cso_set_vertex_buffers(struct cso_context
*ctx
,
1087 unsigned start_slot
, unsigned count
,
1088 const struct pipe_vertex_buffer
*buffers
)
1090 struct u_vbuf
*vbuf
= ctx
->vbuf
;
1093 u_vbuf_set_vertex_buffers(vbuf
, start_slot
, count
, buffers
);
1097 /* Save what's in the auxiliary slot, so that we can save and restore it
1099 if (start_slot
<= ctx
->aux_vertex_buffer_index
&&
1100 start_slot
+count
> ctx
->aux_vertex_buffer_index
) {
1102 const struct pipe_vertex_buffer
*vb
=
1103 buffers
+ (ctx
->aux_vertex_buffer_index
- start_slot
);
1105 pipe_resource_reference(&ctx
->aux_vertex_buffer_current
.buffer
,
1107 memcpy(&ctx
->aux_vertex_buffer_current
, vb
,
1108 sizeof(struct pipe_vertex_buffer
));
1111 pipe_resource_reference(&ctx
->aux_vertex_buffer_current
.buffer
,
1113 ctx
->aux_vertex_buffer_current
.user_buffer
= NULL
;
1117 ctx
->pipe
->set_vertex_buffers(ctx
->pipe
, start_slot
, count
, buffers
);
1121 cso_save_aux_vertex_buffer_slot(struct cso_context
*ctx
)
1123 struct u_vbuf
*vbuf
= ctx
->vbuf
;
1126 u_vbuf_save_aux_vertex_buffer_slot(vbuf
);
1130 pipe_resource_reference(&ctx
->aux_vertex_buffer_saved
.buffer
,
1131 ctx
->aux_vertex_buffer_current
.buffer
);
1132 memcpy(&ctx
->aux_vertex_buffer_saved
, &ctx
->aux_vertex_buffer_current
,
1133 sizeof(struct pipe_vertex_buffer
));
1137 cso_restore_aux_vertex_buffer_slot(struct cso_context
*ctx
)
1139 struct u_vbuf
*vbuf
= ctx
->vbuf
;
1142 u_vbuf_restore_aux_vertex_buffer_slot(vbuf
);
1146 cso_set_vertex_buffers(ctx
, ctx
->aux_vertex_buffer_index
, 1,
1147 &ctx
->aux_vertex_buffer_saved
);
1148 pipe_resource_reference(&ctx
->aux_vertex_buffer_saved
.buffer
, NULL
);
1151 unsigned cso_get_aux_vertex_buffer_slot(struct cso_context
*ctx
)
1153 return ctx
->aux_vertex_buffer_index
;
1157 /**************** fragment/vertex sampler view state *************************/
1160 cso_single_sampler(struct cso_context
*ctx
, unsigned shader_stage
,
1161 unsigned idx
, const struct pipe_sampler_state
*templ
)
1163 void *handle
= NULL
;
1166 unsigned key_size
= sizeof(struct pipe_sampler_state
);
1167 unsigned hash_key
= cso_construct_key((void*)templ
, key_size
);
1168 struct cso_hash_iter iter
=
1169 cso_find_state_template(ctx
->cache
,
1170 hash_key
, CSO_SAMPLER
,
1171 (void *) templ
, key_size
);
1173 if (cso_hash_iter_is_null(iter
)) {
1174 struct cso_sampler
*cso
= MALLOC(sizeof(struct cso_sampler
));
1176 return PIPE_ERROR_OUT_OF_MEMORY
;
1178 memcpy(&cso
->state
, templ
, sizeof(*templ
));
1179 cso
->data
= ctx
->pipe
->create_sampler_state(ctx
->pipe
, &cso
->state
);
1181 (cso_state_callback
) ctx
->pipe
->delete_sampler_state
;
1182 cso
->context
= ctx
->pipe
;
1184 iter
= cso_insert_state(ctx
->cache
, hash_key
, CSO_SAMPLER
, cso
);
1185 if (cso_hash_iter_is_null(iter
)) {
1187 return PIPE_ERROR_OUT_OF_MEMORY
;
1193 handle
= ((struct cso_sampler
*)cso_hash_iter_data(iter
))->data
;
1197 ctx
->samplers
[shader_stage
].samplers
[idx
] = handle
;
1203 cso_single_sampler_done(struct cso_context
*ctx
, unsigned shader_stage
)
1205 struct sampler_info
*info
= &ctx
->samplers
[shader_stage
];
1206 const unsigned old_nr_samplers
= info
->nr_samplers
;
1209 /* find highest non-null sampler */
1210 for (i
= PIPE_MAX_SAMPLERS
; i
> 0; i
--) {
1211 if (info
->samplers
[i
- 1] != NULL
)
1215 info
->nr_samplers
= i
;
1216 ctx
->pipe
->bind_sampler_states(ctx
->pipe
, shader_stage
, 0,
1217 MAX2(old_nr_samplers
, info
->nr_samplers
),
1223 * If the function encouters any errors it will return the
1224 * last one. Done to always try to set as many samplers
1228 cso_set_samplers(struct cso_context
*ctx
,
1229 unsigned shader_stage
,
1231 const struct pipe_sampler_state
**templates
)
1233 struct sampler_info
*info
= &ctx
->samplers
[shader_stage
];
1235 enum pipe_error temp
, error
= PIPE_OK
;
1240 for (i
= 0; i
< nr
; i
++) {
1241 temp
= cso_single_sampler(ctx
, shader_stage
, i
, templates
[i
]);
1242 if (temp
!= PIPE_OK
)
1246 for ( ; i
< info
->nr_samplers
; i
++) {
1247 temp
= cso_single_sampler(ctx
, shader_stage
, i
, NULL
);
1248 if (temp
!= PIPE_OK
)
1252 cso_single_sampler_done(ctx
, shader_stage
);
1258 cso_save_fragment_samplers(struct cso_context
*ctx
)
1260 struct sampler_info
*info
= &ctx
->samplers
[PIPE_SHADER_FRAGMENT
];
1262 ctx
->nr_fragment_samplers_saved
= info
->nr_samplers
;
1263 memcpy(ctx
->fragment_samplers_saved
, info
->samplers
,
1264 sizeof(info
->samplers
));
1269 cso_restore_fragment_samplers(struct cso_context
*ctx
)
1271 struct sampler_info
*info
= &ctx
->samplers
[PIPE_SHADER_FRAGMENT
];
1273 info
->nr_samplers
= ctx
->nr_fragment_samplers_saved
;
1274 memcpy(info
->samplers
, ctx
->fragment_samplers_saved
,
1275 sizeof(info
->samplers
));
1276 cso_single_sampler_done(ctx
, PIPE_SHADER_FRAGMENT
);
1281 cso_set_sampler_views(struct cso_context
*ctx
,
1282 unsigned shader_stage
,
1284 struct pipe_sampler_view
**views
)
1286 if (shader_stage
== PIPE_SHADER_FRAGMENT
) {
1288 boolean any_change
= FALSE
;
1290 /* reference new views */
1291 for (i
= 0; i
< count
; i
++) {
1292 any_change
|= ctx
->fragment_views
[i
] != views
[i
];
1293 pipe_sampler_view_reference(&ctx
->fragment_views
[i
], views
[i
]);
1295 /* unref extra old views, if any */
1296 for (; i
< ctx
->nr_fragment_views
; i
++) {
1297 any_change
|= ctx
->fragment_views
[i
] != NULL
;
1298 pipe_sampler_view_reference(&ctx
->fragment_views
[i
], NULL
);
1301 /* bind the new sampler views */
1303 ctx
->pipe
->set_sampler_views(ctx
->pipe
, shader_stage
, 0,
1304 MAX2(ctx
->nr_fragment_views
, count
),
1305 ctx
->fragment_views
);
1308 ctx
->nr_fragment_views
= count
;
1311 ctx
->pipe
->set_sampler_views(ctx
->pipe
, shader_stage
, 0, count
, views
);
1316 cso_save_fragment_sampler_views(struct cso_context
*ctx
)
1320 ctx
->nr_fragment_views_saved
= ctx
->nr_fragment_views
;
1322 for (i
= 0; i
< ctx
->nr_fragment_views
; i
++) {
1323 assert(!ctx
->fragment_views_saved
[i
]);
1324 pipe_sampler_view_reference(&ctx
->fragment_views_saved
[i
],
1325 ctx
->fragment_views
[i
]);
1331 cso_restore_fragment_sampler_views(struct cso_context
*ctx
)
1333 unsigned i
, nr_saved
= ctx
->nr_fragment_views_saved
;
1336 for (i
= 0; i
< nr_saved
; i
++) {
1337 pipe_sampler_view_reference(&ctx
->fragment_views
[i
], NULL
);
1338 /* move the reference from one pointer to another */
1339 ctx
->fragment_views
[i
] = ctx
->fragment_views_saved
[i
];
1340 ctx
->fragment_views_saved
[i
] = NULL
;
1342 for (; i
< ctx
->nr_fragment_views
; i
++) {
1343 pipe_sampler_view_reference(&ctx
->fragment_views
[i
], NULL
);
1346 num
= MAX2(ctx
->nr_fragment_views
, nr_saved
);
1348 /* bind the old/saved sampler views */
1349 ctx
->pipe
->set_sampler_views(ctx
->pipe
, PIPE_SHADER_FRAGMENT
, 0, num
,
1350 ctx
->fragment_views
);
1352 ctx
->nr_fragment_views
= nr_saved
;
1353 ctx
->nr_fragment_views_saved
= 0;
1358 cso_set_stream_outputs(struct cso_context
*ctx
,
1359 unsigned num_targets
,
1360 struct pipe_stream_output_target
**targets
,
1361 const unsigned *offsets
)
1363 struct pipe_context
*pipe
= ctx
->pipe
;
1366 if (!ctx
->has_streamout
) {
1367 assert(num_targets
== 0);
1371 if (ctx
->nr_so_targets
== 0 && num_targets
== 0) {
1372 /* Nothing to do. */
1376 /* reference new targets */
1377 for (i
= 0; i
< num_targets
; i
++) {
1378 pipe_so_target_reference(&ctx
->so_targets
[i
], targets
[i
]);
1380 /* unref extra old targets, if any */
1381 for (; i
< ctx
->nr_so_targets
; i
++) {
1382 pipe_so_target_reference(&ctx
->so_targets
[i
], NULL
);
1385 pipe
->set_stream_output_targets(pipe
, num_targets
, targets
,
1387 ctx
->nr_so_targets
= num_targets
;
1391 cso_save_stream_outputs(struct cso_context
*ctx
)
1395 if (!ctx
->has_streamout
) {
1399 ctx
->nr_so_targets_saved
= ctx
->nr_so_targets
;
1401 for (i
= 0; i
< ctx
->nr_so_targets
; i
++) {
1402 assert(!ctx
->so_targets_saved
[i
]);
1403 pipe_so_target_reference(&ctx
->so_targets_saved
[i
], ctx
->so_targets
[i
]);
1408 cso_restore_stream_outputs(struct cso_context
*ctx
)
1410 struct pipe_context
*pipe
= ctx
->pipe
;
1412 unsigned offset
[PIPE_MAX_SO_BUFFERS
];
1414 if (!ctx
->has_streamout
) {
1418 if (ctx
->nr_so_targets
== 0 && ctx
->nr_so_targets_saved
== 0) {
1419 /* Nothing to do. */
1423 assert(ctx
->nr_so_targets_saved
<= PIPE_MAX_SO_BUFFERS
);
1424 for (i
= 0; i
< ctx
->nr_so_targets_saved
; i
++) {
1425 pipe_so_target_reference(&ctx
->so_targets
[i
], NULL
);
1426 /* move the reference from one pointer to another */
1427 ctx
->so_targets
[i
] = ctx
->so_targets_saved
[i
];
1428 ctx
->so_targets_saved
[i
] = NULL
;
1429 /* -1 means append */
1430 offset
[i
] = (unsigned)-1;
1432 for (; i
< ctx
->nr_so_targets
; i
++) {
1433 pipe_so_target_reference(&ctx
->so_targets
[i
], NULL
);
1436 pipe
->set_stream_output_targets(pipe
, ctx
->nr_so_targets_saved
,
1437 ctx
->so_targets
, offset
);
1439 ctx
->nr_so_targets
= ctx
->nr_so_targets_saved
;
1440 ctx
->nr_so_targets_saved
= 0;
1443 /* constant buffers */
1446 cso_set_constant_buffer(struct cso_context
*cso
, unsigned shader_stage
,
1447 unsigned index
, struct pipe_constant_buffer
*cb
)
1449 struct pipe_context
*pipe
= cso
->pipe
;
1451 pipe
->set_constant_buffer(pipe
, shader_stage
, index
, cb
);
1454 util_copy_constant_buffer(&cso
->aux_constbuf_current
[shader_stage
], cb
);
1459 cso_set_constant_buffer_resource(struct cso_context
*cso
,
1460 unsigned shader_stage
,
1462 struct pipe_resource
*buffer
)
1465 struct pipe_constant_buffer cb
;
1467 cb
.buffer_offset
= 0;
1468 cb
.buffer_size
= buffer
->width0
;
1469 cb
.user_buffer
= NULL
;
1470 cso_set_constant_buffer(cso
, shader_stage
, index
, &cb
);
1472 cso_set_constant_buffer(cso
, shader_stage
, index
, NULL
);
1477 cso_save_constant_buffer_slot0(struct cso_context
*cso
,
1478 unsigned shader_stage
)
1480 util_copy_constant_buffer(&cso
->aux_constbuf_saved
[shader_stage
],
1481 &cso
->aux_constbuf_current
[shader_stage
]);
1485 cso_restore_constant_buffer_slot0(struct cso_context
*cso
,
1486 unsigned shader_stage
)
1488 cso_set_constant_buffer(cso
, shader_stage
, 0,
1489 &cso
->aux_constbuf_saved
[shader_stage
]);
1490 pipe_resource_reference(&cso
->aux_constbuf_saved
[shader_stage
].buffer
,
1496 * Save all the CSO state items specified by the state_mask bitmask
1497 * of CSO_BIT_x flags.
1500 cso_save_state(struct cso_context
*cso
, unsigned state_mask
)
1502 assert(cso
->saved_state
== 0);
1504 cso
->saved_state
= state_mask
;
1506 if (state_mask
& CSO_BIT_AUX_VERTEX_BUFFER_SLOT
)
1507 cso_save_aux_vertex_buffer_slot(cso
);
1508 if (state_mask
& CSO_BIT_BLEND
)
1509 cso_save_blend(cso
);
1510 if (state_mask
& CSO_BIT_DEPTH_STENCIL_ALPHA
)
1511 cso_save_depth_stencil_alpha(cso
);
1512 if (state_mask
& CSO_BIT_FRAGMENT_SAMPLERS
)
1513 cso_save_fragment_samplers(cso
);
1514 if (state_mask
& CSO_BIT_FRAGMENT_SAMPLER_VIEWS
)
1515 cso_save_fragment_sampler_views(cso
);
1516 if (state_mask
& CSO_BIT_FRAGMENT_SHADER
)
1517 cso_save_fragment_shader(cso
);
1518 if (state_mask
& CSO_BIT_FRAMEBUFFER
)
1519 cso_save_framebuffer(cso
);
1520 if (state_mask
& CSO_BIT_GEOMETRY_SHADER
)
1521 cso_save_geometry_shader(cso
);
1522 if (state_mask
& CSO_BIT_MIN_SAMPLES
)
1523 cso_save_min_samples(cso
);
1524 if (state_mask
& CSO_BIT_RASTERIZER
)
1525 cso_save_rasterizer(cso
);
1526 if (state_mask
& CSO_BIT_RENDER_CONDITION
)
1527 cso_save_render_condition(cso
);
1528 if (state_mask
& CSO_BIT_SAMPLE_MASK
)
1529 cso_save_sample_mask(cso
);
1530 if (state_mask
& CSO_BIT_STENCIL_REF
)
1531 cso_save_stencil_ref(cso
);
1532 if (state_mask
& CSO_BIT_STREAM_OUTPUTS
)
1533 cso_save_stream_outputs(cso
);
1534 if (state_mask
& CSO_BIT_TESSCTRL_SHADER
)
1535 cso_save_tessctrl_shader(cso
);
1536 if (state_mask
& CSO_BIT_TESSEVAL_SHADER
)
1537 cso_save_tesseval_shader(cso
);
1538 if (state_mask
& CSO_BIT_VERTEX_ELEMENTS
)
1539 cso_save_vertex_elements(cso
);
1540 if (state_mask
& CSO_BIT_VERTEX_SHADER
)
1541 cso_save_vertex_shader(cso
);
1542 if (state_mask
& CSO_BIT_VIEWPORT
)
1543 cso_save_viewport(cso
);
1544 if (state_mask
& CSO_BIT_PAUSE_QUERIES
)
1545 cso
->pipe
->set_active_query_state(cso
->pipe
, false);
1550 * Restore the state which was saved by cso_save_state().
1553 cso_restore_state(struct cso_context
*cso
)
1555 unsigned state_mask
= cso
->saved_state
;
1559 if (state_mask
& CSO_BIT_AUX_VERTEX_BUFFER_SLOT
)
1560 cso_restore_aux_vertex_buffer_slot(cso
);
1561 if (state_mask
& CSO_BIT_BLEND
)
1562 cso_restore_blend(cso
);
1563 if (state_mask
& CSO_BIT_DEPTH_STENCIL_ALPHA
)
1564 cso_restore_depth_stencil_alpha(cso
);
1565 if (state_mask
& CSO_BIT_FRAGMENT_SAMPLERS
)
1566 cso_restore_fragment_samplers(cso
);
1567 if (state_mask
& CSO_BIT_FRAGMENT_SAMPLER_VIEWS
)
1568 cso_restore_fragment_sampler_views(cso
);
1569 if (state_mask
& CSO_BIT_FRAGMENT_SHADER
)
1570 cso_restore_fragment_shader(cso
);
1571 if (state_mask
& CSO_BIT_FRAMEBUFFER
)
1572 cso_restore_framebuffer(cso
);
1573 if (state_mask
& CSO_BIT_GEOMETRY_SHADER
)
1574 cso_restore_geometry_shader(cso
);
1575 if (state_mask
& CSO_BIT_MIN_SAMPLES
)
1576 cso_restore_min_samples(cso
);
1577 if (state_mask
& CSO_BIT_RASTERIZER
)
1578 cso_restore_rasterizer(cso
);
1579 if (state_mask
& CSO_BIT_RENDER_CONDITION
)
1580 cso_restore_render_condition(cso
);
1581 if (state_mask
& CSO_BIT_SAMPLE_MASK
)
1582 cso_restore_sample_mask(cso
);
1583 if (state_mask
& CSO_BIT_STENCIL_REF
)
1584 cso_restore_stencil_ref(cso
);
1585 if (state_mask
& CSO_BIT_STREAM_OUTPUTS
)
1586 cso_restore_stream_outputs(cso
);
1587 if (state_mask
& CSO_BIT_TESSCTRL_SHADER
)
1588 cso_restore_tessctrl_shader(cso
);
1589 if (state_mask
& CSO_BIT_TESSEVAL_SHADER
)
1590 cso_restore_tesseval_shader(cso
);
1591 if (state_mask
& CSO_BIT_VERTEX_ELEMENTS
)
1592 cso_restore_vertex_elements(cso
);
1593 if (state_mask
& CSO_BIT_VERTEX_SHADER
)
1594 cso_restore_vertex_shader(cso
);
1595 if (state_mask
& CSO_BIT_VIEWPORT
)
1596 cso_restore_viewport(cso
);
1597 if (state_mask
& CSO_BIT_PAUSE_QUERIES
)
1598 cso
->pipe
->set_active_query_state(cso
->pipe
, true);
1600 cso
->saved_state
= 0;
1608 cso_set_index_buffer(struct cso_context
*cso
,
1609 const struct pipe_index_buffer
*ib
)
1611 struct u_vbuf
*vbuf
= cso
->vbuf
;
1614 u_vbuf_set_index_buffer(vbuf
, ib
);
1616 struct pipe_context
*pipe
= cso
->pipe
;
1617 pipe
->set_index_buffer(pipe
, ib
);
1622 cso_draw_vbo(struct cso_context
*cso
,
1623 const struct pipe_draw_info
*info
)
1625 struct u_vbuf
*vbuf
= cso
->vbuf
;
1628 u_vbuf_draw_vbo(vbuf
, info
);
1630 struct pipe_context
*pipe
= cso
->pipe
;
1631 pipe
->draw_vbo(pipe
, info
);
1636 cso_draw_arrays(struct cso_context
*cso
, uint mode
, uint start
, uint count
)
1638 struct pipe_draw_info info
;
1640 util_draw_init_info(&info
);
1645 info
.min_index
= start
;
1646 info
.max_index
= start
+ count
- 1;
1648 cso_draw_vbo(cso
, &info
);
1652 cso_draw_arrays_instanced(struct cso_context
*cso
, uint mode
,
1653 uint start
, uint count
,
1654 uint start_instance
, uint instance_count
)
1656 struct pipe_draw_info info
;
1658 util_draw_init_info(&info
);
1663 info
.min_index
= start
;
1664 info
.max_index
= start
+ count
- 1;
1665 info
.start_instance
= start_instance
;
1666 info
.instance_count
= instance_count
;
1668 cso_draw_vbo(cso
, &info
);