/**
- * Info related to samplers and sampler views.
- * We have one of these for fragment samplers and another for vertex samplers.
+ * Per-shader sampler information.
*/
struct sampler_info
{
boolean has_geometry_shader;
boolean has_tessellation;
+ boolean has_compute_shader;
boolean has_streamout;
+ unsigned saved_state; /**< bitmask of CSO_BIT_x flags */
+
struct pipe_sampler_view *fragment_views[PIPE_MAX_SHADER_SAMPLER_VIEWS];
unsigned nr_fragment_views;
struct pipe_constant_buffer aux_constbuf_current[PIPE_SHADER_TYPES];
struct pipe_constant_buffer aux_constbuf_saved[PIPE_SHADER_TYPES];
+ struct pipe_image_view fragment_image0_current;
+ struct pipe_image_view fragment_image0_saved;
+
unsigned nr_so_targets;
struct pipe_stream_output_target *so_targets[PIPE_MAX_SO_BUFFERS];
void *geometry_shader, *geometry_shader_saved;
void *tessctrl_shader, *tessctrl_shader_saved;
void *tesseval_shader, *tesseval_shader_saved;
+ void *compute_shader;
void *velements, *velements_saved;
struct pipe_query *render_condition, *render_condition_saved;
uint render_condition_mode, render_condition_mode_saved;
struct cso_context *cso_create_context( struct pipe_context *pipe )
{
struct cso_context *ctx = CALLOC_STRUCT(cso_context);
- if (ctx == NULL)
- goto out;
+ if (!ctx)
+ return NULL;
ctx->cache = cso_cache_create();
if (ctx->cache == NULL)
PIPE_SHADER_CAP_MAX_INSTRUCTIONS) > 0) {
ctx->has_tessellation = TRUE;
}
+ if (pipe->screen->get_shader_param(pipe->screen, PIPE_SHADER_COMPUTE,
+ PIPE_SHADER_CAP_MAX_INSTRUCTIONS) > 0) {
+ int supported_irs =
+ pipe->screen->get_shader_param(pipe->screen, PIPE_SHADER_COMPUTE,
+ PIPE_SHADER_CAP_SUPPORTED_IRS);
+ if (supported_irs & (1 << PIPE_SHADER_IR_TGSI)) {
+ ctx->has_compute_shader = TRUE;
+ }
+ }
if (pipe->screen->get_param(pipe->screen,
PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS) != 0) {
ctx->has_streamout = TRUE;
static struct pipe_sampler_view *views[PIPE_MAX_SHADER_SAMPLER_VIEWS] = { NULL };
static void *zeros[PIPE_MAX_SAMPLERS] = { NULL };
struct pipe_screen *scr = ctx->pipe->screen;
- unsigned sh;
+ enum pipe_shader_type sh;
for (sh = 0; sh < PIPE_SHADER_TYPES; sh++) {
int maxsam = scr->get_shader_param(scr, sh,
PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS);
ctx->pipe->bind_tes_state(ctx->pipe, NULL);
ctx->pipe->set_constant_buffer(ctx->pipe, PIPE_SHADER_TESS_EVAL, 0, NULL);
}
+ if (ctx->has_compute_shader) {
+ ctx->pipe->bind_compute_state(ctx->pipe, NULL);
+ ctx->pipe->set_constant_buffer(ctx->pipe, PIPE_SHADER_COMPUTE, 0, NULL);
+ }
ctx->pipe->bind_vertex_elements_state( ctx->pipe, NULL );
if (ctx->has_streamout)
pipe_resource_reference(&ctx->aux_constbuf_saved[i].buffer, NULL);
}
+ pipe_resource_reference(&ctx->fragment_image0_current.resource, NULL);
+ pipe_resource_reference(&ctx->fragment_image0_saved.resource, NULL);
+
for (i = 0; i < PIPE_MAX_SO_BUFFERS; i++) {
pipe_so_target_reference(&ctx->so_targets[i], NULL);
pipe_so_target_reference(&ctx->so_targets_saved[i], NULL);
return PIPE_OK;
}
-void cso_save_blend(struct cso_context *ctx)
+static void
+cso_save_blend(struct cso_context *ctx)
{
assert(!ctx->blend_saved);
ctx->blend_saved = ctx->blend;
}
-void cso_restore_blend(struct cso_context *ctx)
+static void
+cso_restore_blend(struct cso_context *ctx)
{
if (ctx->blend != ctx->blend_saved) {
ctx->blend = ctx->blend_saved;
return PIPE_OK;
}
-void cso_save_depth_stencil_alpha(struct cso_context *ctx)
+static void
+cso_save_depth_stencil_alpha(struct cso_context *ctx)
{
assert(!ctx->depth_stencil_saved);
ctx->depth_stencil_saved = ctx->depth_stencil;
}
-void cso_restore_depth_stencil_alpha(struct cso_context *ctx)
+static void
+cso_restore_depth_stencil_alpha(struct cso_context *ctx)
{
if (ctx->depth_stencil != ctx->depth_stencil_saved) {
ctx->depth_stencil = ctx->depth_stencil_saved;
return PIPE_OK;
}
-void cso_save_rasterizer(struct cso_context *ctx)
+static void
+cso_save_rasterizer(struct cso_context *ctx)
{
assert(!ctx->rasterizer_saved);
ctx->rasterizer_saved = ctx->rasterizer;
}
-void cso_restore_rasterizer(struct cso_context *ctx)
+static void
+cso_restore_rasterizer(struct cso_context *ctx)
{
if (ctx->rasterizer != ctx->rasterizer_saved) {
ctx->rasterizer = ctx->rasterizer_saved;
ctx->pipe->delete_fs_state(ctx->pipe, handle);
}
-void cso_save_fragment_shader(struct cso_context *ctx)
+static void
+cso_save_fragment_shader(struct cso_context *ctx)
{
assert(!ctx->fragment_shader_saved);
ctx->fragment_shader_saved = ctx->fragment_shader;
}
-void cso_restore_fragment_shader(struct cso_context *ctx)
+static void
+cso_restore_fragment_shader(struct cso_context *ctx)
{
if (ctx->fragment_shader_saved != ctx->fragment_shader) {
ctx->pipe->bind_fs_state(ctx->pipe, ctx->fragment_shader_saved);
ctx->pipe->delete_vs_state(ctx->pipe, handle);
}
-void cso_save_vertex_shader(struct cso_context *ctx)
+static void
+cso_save_vertex_shader(struct cso_context *ctx)
{
assert(!ctx->vertex_shader_saved);
ctx->vertex_shader_saved = ctx->vertex_shader;
}
-void cso_restore_vertex_shader(struct cso_context *ctx)
+static void
+cso_restore_vertex_shader(struct cso_context *ctx)
{
if (ctx->vertex_shader_saved != ctx->vertex_shader) {
ctx->pipe->bind_vs_state(ctx->pipe, ctx->vertex_shader_saved);
}
}
-void cso_save_framebuffer(struct cso_context *ctx)
+static void
+cso_save_framebuffer(struct cso_context *ctx)
{
util_copy_framebuffer_state(&ctx->fb_saved, &ctx->fb);
}
-void cso_restore_framebuffer(struct cso_context *ctx)
+static void
+cso_restore_framebuffer(struct cso_context *ctx)
{
if (memcmp(&ctx->fb, &ctx->fb_saved, sizeof(ctx->fb))) {
util_copy_framebuffer_state(&ctx->fb, &ctx->fb_saved);
}
}
-void cso_save_viewport(struct cso_context *ctx)
+/**
+ * Setup viewport state for given width and height (position is always (0,0)).
+ * Invert the Y axis if 'invert' is true.
+ */
+void
+cso_set_viewport_dims(struct cso_context *ctx,
+ float width, float height, boolean invert)
+{
+ struct pipe_viewport_state vp;
+ vp.scale[0] = width * 0.5f;
+ vp.scale[1] = height * (invert ? -0.5f : 0.5f);
+ vp.scale[2] = 0.5f;
+ vp.translate[0] = 0.5f * width;
+ vp.translate[1] = 0.5f * height;
+ vp.translate[2] = 0.5f;
+ cso_set_viewport(ctx, &vp);
+}
+
+static void
+cso_save_viewport(struct cso_context *ctx)
{
ctx->vp_saved = ctx->vp;
}
-void cso_restore_viewport(struct cso_context *ctx)
+static void
+cso_restore_viewport(struct cso_context *ctx)
{
if (memcmp(&ctx->vp, &ctx->vp_saved, sizeof(ctx->vp))) {
ctx->vp = ctx->vp_saved;
}
}
-void cso_save_sample_mask(struct cso_context *ctx)
+static void
+cso_save_sample_mask(struct cso_context *ctx)
{
ctx->sample_mask_saved = ctx->sample_mask;
}
-void cso_restore_sample_mask(struct cso_context *ctx)
+static void
+cso_restore_sample_mask(struct cso_context *ctx)
{
cso_set_sample_mask(ctx, ctx->sample_mask_saved);
}
}
}
-void cso_save_min_samples(struct cso_context *ctx)
+static void
+cso_save_min_samples(struct cso_context *ctx)
{
ctx->min_samples_saved = ctx->min_samples;
}
-void cso_restore_min_samples(struct cso_context *ctx)
+static void
+cso_restore_min_samples(struct cso_context *ctx)
{
cso_set_min_samples(ctx, ctx->min_samples_saved);
}
}
}
-void cso_save_stencil_ref(struct cso_context *ctx)
+static void
+cso_save_stencil_ref(struct cso_context *ctx)
{
ctx->stencil_ref_saved = ctx->stencil_ref;
}
-void cso_restore_stencil_ref(struct cso_context *ctx)
+static void
+cso_restore_stencil_ref(struct cso_context *ctx)
{
if (memcmp(&ctx->stencil_ref, &ctx->stencil_ref_saved,
sizeof(ctx->stencil_ref))) {
}
}
-void cso_save_render_condition(struct cso_context *ctx)
+static void
+cso_save_render_condition(struct cso_context *ctx)
{
ctx->render_condition_saved = ctx->render_condition;
ctx->render_condition_cond_saved = ctx->render_condition_cond;
ctx->render_condition_mode_saved = ctx->render_condition_mode;
}
-void cso_restore_render_condition(struct cso_context *ctx)
+static void
+cso_restore_render_condition(struct cso_context *ctx)
{
cso_set_render_condition(ctx, ctx->render_condition_saved,
ctx->render_condition_cond_saved,
void cso_delete_geometry_shader(struct cso_context *ctx, void *handle)
{
- if (handle == ctx->geometry_shader) {
+ if (handle == ctx->geometry_shader) {
/* unbind before deleting */
ctx->pipe->bind_gs_state(ctx->pipe, NULL);
ctx->geometry_shader = NULL;
ctx->pipe->delete_gs_state(ctx->pipe, handle);
}
-void cso_save_geometry_shader(struct cso_context *ctx)
+static void
+cso_save_geometry_shader(struct cso_context *ctx)
{
if (!ctx->has_geometry_shader) {
return;
ctx->geometry_shader_saved = ctx->geometry_shader;
}
-void cso_restore_geometry_shader(struct cso_context *ctx)
+static void
+cso_restore_geometry_shader(struct cso_context *ctx)
{
if (!ctx->has_geometry_shader) {
return;
void cso_delete_tessctrl_shader(struct cso_context *ctx, void *handle)
{
- if (handle == ctx->tessctrl_shader) {
+ if (handle == ctx->tessctrl_shader) {
/* unbind before deleting */
ctx->pipe->bind_tcs_state(ctx->pipe, NULL);
ctx->tessctrl_shader = NULL;
ctx->pipe->delete_tcs_state(ctx->pipe, handle);
}
-void cso_save_tessctrl_shader(struct cso_context *ctx)
+static void
+cso_save_tessctrl_shader(struct cso_context *ctx)
{
if (!ctx->has_tessellation) {
return;
ctx->tessctrl_shader_saved = ctx->tessctrl_shader;
}
-void cso_restore_tessctrl_shader(struct cso_context *ctx)
+static void
+cso_restore_tessctrl_shader(struct cso_context *ctx)
{
if (!ctx->has_tessellation) {
return;
void cso_delete_tesseval_shader(struct cso_context *ctx, void *handle)
{
- if (handle == ctx->tesseval_shader) {
+ if (handle == ctx->tesseval_shader) {
/* unbind before deleting */
ctx->pipe->bind_tes_state(ctx->pipe, NULL);
ctx->tesseval_shader = NULL;
ctx->pipe->delete_tes_state(ctx->pipe, handle);
}
-void cso_save_tesseval_shader(struct cso_context *ctx)
+static void
+cso_save_tesseval_shader(struct cso_context *ctx)
{
if (!ctx->has_tessellation) {
return;
ctx->tesseval_shader_saved = ctx->tesseval_shader;
}
-void cso_restore_tesseval_shader(struct cso_context *ctx)
+static void
+cso_restore_tesseval_shader(struct cso_context *ctx)
{
if (!ctx->has_tessellation) {
return;
ctx->tesseval_shader_saved = NULL;
}
+void cso_set_compute_shader_handle(struct cso_context *ctx, void *handle)
+{
+ assert(ctx->has_compute_shader || !handle);
+
+ if (ctx->has_compute_shader && ctx->compute_shader != handle) {
+ ctx->compute_shader = handle;
+ ctx->pipe->bind_compute_state(ctx->pipe, handle);
+ }
+}
+
+void cso_delete_compute_shader(struct cso_context *ctx, void *handle)
+{
+ if (handle == ctx->compute_shader) {
+ /* unbind before deleting */
+ ctx->pipe->bind_compute_state(ctx->pipe, NULL);
+ ctx->compute_shader = NULL;
+ }
+ ctx->pipe->delete_compute_state(ctx->pipe, handle);
+}
+
enum pipe_error
cso_set_vertex_elements(struct cso_context *ctx,
unsigned count,
return PIPE_OK;
}
-void cso_save_vertex_elements(struct cso_context *ctx)
+static void
+cso_save_vertex_elements(struct cso_context *ctx)
{
struct u_vbuf *vbuf = ctx->vbuf;
ctx->velements_saved = ctx->velements;
}
-void cso_restore_vertex_elements(struct cso_context *ctx)
+static void
+cso_restore_vertex_elements(struct cso_context *ctx)
{
struct u_vbuf *vbuf = ctx->vbuf;
ctx->pipe->set_vertex_buffers(ctx->pipe, start_slot, count, buffers);
}
-void cso_save_aux_vertex_buffer_slot(struct cso_context *ctx)
+static void
+cso_save_aux_vertex_buffer_slot(struct cso_context *ctx)
{
struct u_vbuf *vbuf = ctx->vbuf;
sizeof(struct pipe_vertex_buffer));
}
-void cso_restore_aux_vertex_buffer_slot(struct cso_context *ctx)
+static void
+cso_restore_aux_vertex_buffer_slot(struct cso_context *ctx)
{
struct u_vbuf *vbuf = ctx->vbuf;
}
-/**************** fragment/vertex sampler view state *************************/
-static enum pipe_error
-single_sampler(struct cso_context *ctx,
- struct sampler_info *info,
- unsigned idx,
- const struct pipe_sampler_state *templ)
+enum pipe_error
+cso_single_sampler(struct cso_context *ctx, unsigned shader_stage,
+ unsigned idx, const struct pipe_sampler_state *templ)
{
void *handle = NULL;
- if (templ != NULL) {
+ if (templ) {
unsigned key_size = sizeof(struct pipe_sampler_state);
unsigned hash_key = cso_construct_key((void*)templ, key_size);
struct cso_hash_iter iter =
}
}
- info->samplers[idx] = handle;
-
+ ctx->samplers[shader_stage].samplers[idx] = handle;
return PIPE_OK;
}
-enum pipe_error
-cso_single_sampler(struct cso_context *ctx,
- unsigned shader_stage,
- unsigned idx,
- const struct pipe_sampler_state *templ)
-{
- return single_sampler(ctx, &ctx->samplers[shader_stage], idx, templ);
-}
-
-
-static void
-single_sampler_done(struct cso_context *ctx, unsigned shader_stage)
+/**
+ * Send staged sampler state to the driver.
+ */
+void
+cso_single_sampler_done(struct cso_context *ctx,
+ enum pipe_shader_type shader_stage)
{
struct sampler_info *info = &ctx->samplers[shader_stage];
+ const unsigned old_nr_samplers = info->nr_samplers;
unsigned i;
/* find highest non-null sampler */
}
info->nr_samplers = i;
- ctx->pipe->bind_sampler_states(ctx->pipe, shader_stage, 0, i,
+ ctx->pipe->bind_sampler_states(ctx->pipe, shader_stage, 0,
+ MAX2(old_nr_samplers, info->nr_samplers),
info->samplers);
}
-void
-cso_single_sampler_done(struct cso_context *ctx, unsigned shader_stage)
-{
- single_sampler_done(ctx, shader_stage);
-}
-
/*
* If the function encouters any errors it will return the
*/
enum pipe_error
cso_set_samplers(struct cso_context *ctx,
- unsigned shader_stage,
+ enum pipe_shader_type shader_stage,
unsigned nr,
const struct pipe_sampler_state **templates)
{
unsigned i;
enum pipe_error temp, error = PIPE_OK;
- /* TODO: fastpath
- */
-
for (i = 0; i < nr; i++) {
- temp = single_sampler(ctx, info, i, templates[i]);
+ temp = cso_single_sampler(ctx, shader_stage, i, templates[i]);
if (temp != PIPE_OK)
error = temp;
}
for ( ; i < info->nr_samplers; i++) {
- temp = single_sampler(ctx, info, i, NULL);
+ temp = cso_single_sampler(ctx, shader_stage, i, NULL);
if (temp != PIPE_OK)
error = temp;
}
- single_sampler_done(ctx, shader_stage);
+ cso_single_sampler_done(ctx, shader_stage);
return error;
}
-void
+static void
cso_save_fragment_samplers(struct cso_context *ctx)
{
struct sampler_info *info = &ctx->samplers[PIPE_SHADER_FRAGMENT];
}
-void
+static void
cso_restore_fragment_samplers(struct cso_context *ctx)
{
struct sampler_info *info = &ctx->samplers[PIPE_SHADER_FRAGMENT];
info->nr_samplers = ctx->nr_fragment_samplers_saved;
memcpy(info->samplers, ctx->fragment_samplers_saved,
sizeof(info->samplers));
- single_sampler_done(ctx, PIPE_SHADER_FRAGMENT);
+ cso_single_sampler_done(ctx, PIPE_SHADER_FRAGMENT);
}
void
cso_set_sampler_views(struct cso_context *ctx,
- unsigned shader_stage,
+ enum pipe_shader_type shader_stage,
unsigned count,
struct pipe_sampler_view **views)
{
}
-void
+static void
cso_save_fragment_sampler_views(struct cso_context *ctx)
{
unsigned i;
}
-void
+static void
cso_restore_fragment_sampler_views(struct cso_context *ctx)
{
unsigned i, nr_saved = ctx->nr_fragment_views_saved;
}
+void
+cso_set_shader_images(struct cso_context *ctx, unsigned shader_stage,
+ unsigned start, unsigned count,
+ struct pipe_image_view *images)
+{
+ if (shader_stage == PIPE_SHADER_FRAGMENT && start == 0 && count >= 1) {
+ util_copy_image_view(&ctx->fragment_image0_current, &images[0]);
+ }
+
+ ctx->pipe->set_shader_images(ctx->pipe, shader_stage, start, count, images);
+}
+
+
+static void
+cso_save_fragment_image0(struct cso_context *ctx)
+{
+ util_copy_image_view(&ctx->fragment_image0_saved,
+ &ctx->fragment_image0_current);
+}
+
+
+static void
+cso_restore_fragment_image0(struct cso_context *ctx)
+{
+ cso_set_shader_images(ctx, PIPE_SHADER_FRAGMENT, 0, 1,
+ &ctx->fragment_image0_saved);
+}
+
+
void
cso_set_stream_outputs(struct cso_context *ctx,
unsigned num_targets,
ctx->nr_so_targets = num_targets;
}
-void
+static void
cso_save_stream_outputs(struct cso_context *ctx)
{
uint i;
}
}
-void
+static void
cso_restore_stream_outputs(struct cso_context *ctx)
{
struct pipe_context *pipe = ctx->pipe;
NULL);
}
+
+/**
+ * Save all the CSO state items specified by the state_mask bitmask
+ * of CSO_BIT_x flags.
+ */
+void
+cso_save_state(struct cso_context *cso, unsigned state_mask)
+{
+ assert(cso->saved_state == 0);
+
+ cso->saved_state = state_mask;
+
+ if (state_mask & CSO_BIT_AUX_VERTEX_BUFFER_SLOT)
+ cso_save_aux_vertex_buffer_slot(cso);
+ if (state_mask & CSO_BIT_BLEND)
+ cso_save_blend(cso);
+ if (state_mask & CSO_BIT_DEPTH_STENCIL_ALPHA)
+ cso_save_depth_stencil_alpha(cso);
+ if (state_mask & CSO_BIT_FRAGMENT_SAMPLERS)
+ cso_save_fragment_samplers(cso);
+ if (state_mask & CSO_BIT_FRAGMENT_SAMPLER_VIEWS)
+ cso_save_fragment_sampler_views(cso);
+ if (state_mask & CSO_BIT_FRAGMENT_SHADER)
+ cso_save_fragment_shader(cso);
+ if (state_mask & CSO_BIT_FRAMEBUFFER)
+ cso_save_framebuffer(cso);
+ if (state_mask & CSO_BIT_GEOMETRY_SHADER)
+ cso_save_geometry_shader(cso);
+ if (state_mask & CSO_BIT_MIN_SAMPLES)
+ cso_save_min_samples(cso);
+ if (state_mask & CSO_BIT_RASTERIZER)
+ cso_save_rasterizer(cso);
+ if (state_mask & CSO_BIT_RENDER_CONDITION)
+ cso_save_render_condition(cso);
+ if (state_mask & CSO_BIT_SAMPLE_MASK)
+ cso_save_sample_mask(cso);
+ if (state_mask & CSO_BIT_STENCIL_REF)
+ cso_save_stencil_ref(cso);
+ if (state_mask & CSO_BIT_STREAM_OUTPUTS)
+ cso_save_stream_outputs(cso);
+ if (state_mask & CSO_BIT_TESSCTRL_SHADER)
+ cso_save_tessctrl_shader(cso);
+ if (state_mask & CSO_BIT_TESSEVAL_SHADER)
+ cso_save_tesseval_shader(cso);
+ if (state_mask & CSO_BIT_VERTEX_ELEMENTS)
+ cso_save_vertex_elements(cso);
+ if (state_mask & CSO_BIT_VERTEX_SHADER)
+ cso_save_vertex_shader(cso);
+ if (state_mask & CSO_BIT_VIEWPORT)
+ cso_save_viewport(cso);
+ if (state_mask & CSO_BIT_PAUSE_QUERIES)
+ cso->pipe->set_active_query_state(cso->pipe, false);
+ if (state_mask & CSO_BIT_FRAGMENT_IMAGE0)
+ cso_save_fragment_image0(cso);
+}
+
+
+/**
+ * Restore the state which was saved by cso_save_state().
+ */
+void
+cso_restore_state(struct cso_context *cso)
+{
+ unsigned state_mask = cso->saved_state;
+
+ assert(state_mask);
+
+ if (state_mask & CSO_BIT_AUX_VERTEX_BUFFER_SLOT)
+ cso_restore_aux_vertex_buffer_slot(cso);
+ if (state_mask & CSO_BIT_BLEND)
+ cso_restore_blend(cso);
+ if (state_mask & CSO_BIT_DEPTH_STENCIL_ALPHA)
+ cso_restore_depth_stencil_alpha(cso);
+ if (state_mask & CSO_BIT_FRAGMENT_SAMPLERS)
+ cso_restore_fragment_samplers(cso);
+ if (state_mask & CSO_BIT_FRAGMENT_SAMPLER_VIEWS)
+ cso_restore_fragment_sampler_views(cso);
+ if (state_mask & CSO_BIT_FRAGMENT_SHADER)
+ cso_restore_fragment_shader(cso);
+ if (state_mask & CSO_BIT_FRAMEBUFFER)
+ cso_restore_framebuffer(cso);
+ if (state_mask & CSO_BIT_GEOMETRY_SHADER)
+ cso_restore_geometry_shader(cso);
+ if (state_mask & CSO_BIT_MIN_SAMPLES)
+ cso_restore_min_samples(cso);
+ if (state_mask & CSO_BIT_RASTERIZER)
+ cso_restore_rasterizer(cso);
+ if (state_mask & CSO_BIT_RENDER_CONDITION)
+ cso_restore_render_condition(cso);
+ if (state_mask & CSO_BIT_SAMPLE_MASK)
+ cso_restore_sample_mask(cso);
+ if (state_mask & CSO_BIT_STENCIL_REF)
+ cso_restore_stencil_ref(cso);
+ if (state_mask & CSO_BIT_STREAM_OUTPUTS)
+ cso_restore_stream_outputs(cso);
+ if (state_mask & CSO_BIT_TESSCTRL_SHADER)
+ cso_restore_tessctrl_shader(cso);
+ if (state_mask & CSO_BIT_TESSEVAL_SHADER)
+ cso_restore_tesseval_shader(cso);
+ if (state_mask & CSO_BIT_VERTEX_ELEMENTS)
+ cso_restore_vertex_elements(cso);
+ if (state_mask & CSO_BIT_VERTEX_SHADER)
+ cso_restore_vertex_shader(cso);
+ if (state_mask & CSO_BIT_VIEWPORT)
+ cso_restore_viewport(cso);
+ if (state_mask & CSO_BIT_PAUSE_QUERIES)
+ cso->pipe->set_active_query_state(cso->pipe, true);
+ if (state_mask & CSO_BIT_FRAGMENT_IMAGE0)
+ cso_restore_fragment_image0(cso);
+
+ cso->saved_state = 0;
+}
+
+
+
/* drawing */
void
projects / mesa.git / blobdiff