[Mesa-dev] [PATCH] gallium: consolidate CSO sampler and sampler_view functions
Marek Olšák
maraeo at gmail.com
Thu Aug 2 18:17:53 PDT 2012
I just skimmed through it and couldn't find anything wrong.
Reviewed-by: Marek Olšák <maraeo at gmail.com>
Someday we should definitely do something like this in pipe_context too.
Marek
On Thu, Aug 2, 2012 at 9:16 PM, Brian Paul <brianp at vmware.com> wrote:
> Merge the vertex/fragment versions of the cso_set/save/restore_samplers()
> functions. Now we pass the shader stage (PIPE_SHADER_x) to the function
> to indicate vertex/fragment/geometry samplers. For example:
>
> cso_single_sampler(cso, PIPE_SHADER_FRAGMENT, unit, sampler);
>
> This results in quite a bit of code reduction, fewer CSO functions and
> support for geometry shaders.
> ---
> src/gallium/auxiliary/cso_cache/cso_context.c | 241 ++++++++-----------------
> src/gallium/auxiliary/cso_cache/cso_context.h | 79 +++-----
> src/gallium/auxiliary/postprocess/pp_colors.c | 6 +-
> src/gallium/auxiliary/postprocess/pp_init.c | 2 +-
> src/gallium/auxiliary/postprocess/pp_mlaa.c | 24 ++--
> src/gallium/auxiliary/util/u_blit.c | 38 ++--
> src/gallium/auxiliary/util/u_gen_mipmap.c | 14 +-
> src/mesa/state_tracker/st_atom_sampler.c | 12 +-
> src/mesa/state_tracker/st_atom_texture.c | 14 +-
> src/mesa/state_tracker/st_cb_bitmap.c | 13 +-
> src/mesa/state_tracker/st_cb_drawpixels.c | 16 +-
> 11 files changed, 179 insertions(+), 280 deletions(-)
>
> diff --git a/src/gallium/auxiliary/cso_cache/cso_context.c b/src/gallium/auxiliary/cso_cache/cso_context.c
> index 7f2dc43..c9a9fef 100644
> --- a/src/gallium/auxiliary/cso_cache/cso_context.c
> +++ b/src/gallium/auxiliary/cso_cache/cso_context.c
> @@ -84,8 +84,7 @@ struct cso_context {
> boolean has_geometry_shader;
> boolean has_streamout;
>
> - struct sampler_info fragment_samplers;
> - struct sampler_info vertex_samplers;
> + struct sampler_info samplers[PIPE_SHADER_TYPES];
>
> uint nr_vertex_buffers;
> struct pipe_vertex_buffer vertex_buffers[PIPE_MAX_ATTRIBS];
> @@ -296,8 +295,7 @@ out:
> */
> void cso_release_all( struct cso_context *ctx )
> {
> - unsigned i;
> - struct sampler_info *info;
> + unsigned i, shader;
>
> if (ctx->pipe) {
> ctx->pipe->bind_blend_state( ctx->pipe, NULL );
> @@ -317,17 +315,12 @@ void cso_release_all( struct cso_context *ctx )
> }
>
> /* free fragment samplers, views */
> - info = &ctx->fragment_samplers;
> - for (i = 0; i < PIPE_MAX_SAMPLERS; i++) {
> - pipe_sampler_view_reference(&info->views[i], NULL);
> - pipe_sampler_view_reference(&info->views_saved[i], NULL);
> - }
> -
> - /* free vertex samplers, views */
> - info = &ctx->vertex_samplers;
> - for (i = 0; i < PIPE_MAX_SAMPLERS; i++) {
> - pipe_sampler_view_reference(&info->views[i], NULL);
> - pipe_sampler_view_reference(&info->views_saved[i], NULL);
> + for (shader = 0; shader < Elements(ctx->samplers); shader++) {
> + struct sampler_info *info = &ctx->samplers[shader];
> + for (i = 0; i < PIPE_MAX_SAMPLERS; i++) {
> + pipe_sampler_view_reference(&info->views[i], NULL);
> + pipe_sampler_view_reference(&info->views_saved[i], NULL);
> + }
> }
>
> util_unreference_framebuffer_state(&ctx->fb);
> @@ -993,26 +986,19 @@ single_sampler(struct cso_context *ctx,
>
> 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->fragment_samplers, idx, templ);
> -}
> -
> -enum pipe_error
> -cso_single_vertex_sampler(struct cso_context *ctx,
> - unsigned idx,
> - const struct pipe_sampler_state *templ)
> -{
> - return single_sampler(ctx, &ctx->vertex_samplers, idx, templ);
> + return single_sampler(ctx, &ctx->samplers[shader_stage], idx, templ);
> }
>
>
>
> static void
> -single_sampler_done(struct cso_context *ctx,
> - struct sampler_info *info)
> +single_sampler_done(struct cso_context *ctx, unsigned shader_stage)
> {
> + struct sampler_info *info = &ctx->samplers[shader_stage];
> unsigned i;
>
> /* find highest non-null sampler */
> @@ -1033,32 +1019,32 @@ single_sampler_done(struct cso_context *ctx,
> info->nr_samplers * sizeof(void *));
> info->hw.nr_samplers = info->nr_samplers;
>
> - if (info == &ctx->fragment_samplers) {
> + switch (shader_stage) {
> + case PIPE_SHADER_FRAGMENT:
> ctx->pipe->bind_fragment_sampler_states(ctx->pipe,
> info->nr_samplers,
> info->samplers);
> - }
> - else if (info == &ctx->vertex_samplers) {
> + break;
> + case PIPE_SHADER_VERTEX:
> ctx->pipe->bind_vertex_sampler_states(ctx->pipe,
> info->nr_samplers,
> info->samplers);
> - }
> - else {
> - assert(0);
> + break;
> + case PIPE_SHADER_GEOMETRY:
> + ctx->pipe->bind_geometry_sampler_states(ctx->pipe,
> + info->nr_samplers,
> + info->samplers);
> + break;
> + default:
> + assert(!"bad shader type in single_sampler_done()");
> }
> }
> }
>
> void
> -cso_single_sampler_done( struct cso_context *ctx )
> -{
> - single_sampler_done(ctx, &ctx->fragment_samplers);
> -}
> -
> -void
> -cso_single_vertex_sampler_done(struct cso_context *ctx)
> +cso_single_sampler_done(struct cso_context *ctx, unsigned shader_stage)
> {
> - single_sampler_done(ctx, &ctx->vertex_samplers);
> + single_sampler_done(ctx, shader_stage);
> }
>
>
> @@ -1067,12 +1053,13 @@ cso_single_vertex_sampler_done(struct cso_context *ctx)
> * last one. Done to always try to set as many samplers
> * as possible.
> */
> -static enum pipe_error
> -set_samplers(struct cso_context *ctx,
> - struct sampler_info *info,
> - unsigned nr,
> - const struct pipe_sampler_state **templates)
> +enum pipe_error
> +cso_set_samplers(struct cso_context *ctx,
> + unsigned shader_stage,
> + unsigned nr,
> + const struct pipe_sampler_state **templates)
> {
> + struct sampler_info *info = &ctx->samplers[shader_stage];
> unsigned i;
> enum pipe_error temp, error = PIPE_OK;
>
> @@ -1091,82 +1078,38 @@ set_samplers(struct cso_context *ctx,
> error = temp;
> }
>
> - single_sampler_done(ctx, info);
> + single_sampler_done(ctx, shader_stage);
>
> return error;
> }
>
> -enum pipe_error
> -cso_set_samplers(struct cso_context *ctx,
> - unsigned nr,
> - const struct pipe_sampler_state **templates)
> -{
> - return set_samplers(ctx, &ctx->fragment_samplers, nr, templates);
> -}
> -
> -enum pipe_error
> -cso_set_vertex_samplers(struct cso_context *ctx,
> - unsigned nr,
> - const struct pipe_sampler_state **templates)
> -{
> - return set_samplers(ctx, &ctx->vertex_samplers, nr, templates);
> -}
> -
> -
> -
> -static void
> -save_samplers(struct cso_context *ctx, struct sampler_info *info)
> +void
> +cso_save_samplers(struct cso_context *ctx, unsigned shader_stage)
> {
> + struct sampler_info *info = &ctx->samplers[shader_stage];
> info->nr_samplers_saved = info->nr_samplers;
> memcpy(info->samplers_saved, info->samplers, sizeof(info->samplers));
> }
>
> -void
> -cso_save_samplers(struct cso_context *ctx)
> -{
> - save_samplers(ctx, &ctx->fragment_samplers);
> -}
>
> void
> -cso_save_vertex_samplers(struct cso_context *ctx)
> -{
> - save_samplers(ctx, &ctx->vertex_samplers);
> -}
> -
> -
> -
> -static void
> -restore_samplers(struct cso_context *ctx, struct sampler_info *info)
> +cso_restore_samplers(struct cso_context *ctx, unsigned shader_stage)
> {
> + struct sampler_info *info = &ctx->samplers[shader_stage];
> info->nr_samplers = info->nr_samplers_saved;
> memcpy(info->samplers, info->samplers_saved, sizeof(info->samplers));
> - single_sampler_done(ctx, info);
> + single_sampler_done(ctx, shader_stage);
> }
>
> -void
> -cso_restore_samplers(struct cso_context *ctx)
> -{
> - restore_samplers(ctx, &ctx->fragment_samplers);
> -}
>
> void
> -cso_restore_vertex_samplers(struct cso_context *ctx)
> +cso_set_sampler_views(struct cso_context *ctx,
> + unsigned shader_stage,
> + unsigned count,
> + struct pipe_sampler_view **views)
> {
> - restore_samplers(ctx, &ctx->vertex_samplers);
> -}
> -
> -
> -
> -static void
> -set_sampler_views(struct cso_context *ctx,
> - struct sampler_info *info,
> - void (*set_views)(struct pipe_context *,
> - unsigned num_views,
> - struct pipe_sampler_view **),
> - uint count,
> - struct pipe_sampler_view **views)
> -{
> - uint i;
> + struct sampler_info *info = &ctx->samplers[shader_stage];
> + unsigned i;
>
> /* reference new views */
> for (i = 0; i < count; i++) {
> @@ -1180,36 +1123,27 @@ set_sampler_views(struct cso_context *ctx,
> info->nr_views = count;
>
> /* bind the new sampler views */
> - set_views(ctx->pipe, count, info->views);
> + switch (shader_stage) {
> + case PIPE_SHADER_FRAGMENT:
> + ctx->pipe->set_fragment_sampler_views(ctx->pipe, count, info->views);
> + break;
> + case PIPE_SHADER_VERTEX:
> + ctx->pipe->set_vertex_sampler_views(ctx->pipe, count, info->views);
> + break;
> + case PIPE_SHADER_GEOMETRY:
> + ctx->pipe->set_geometry_sampler_views(ctx->pipe, count, info->views);
> + break;
> + default:
> + assert(!"bad shader type in cso_set_sampler_views()");
> + }
> }
>
> -void
> -cso_set_fragment_sampler_views(struct cso_context *ctx,
> - uint count,
> - struct pipe_sampler_view **views)
> -{
> - set_sampler_views(ctx, &ctx->fragment_samplers,
> - ctx->pipe->set_fragment_sampler_views,
> - count, views);
> -}
>
> void
> -cso_set_vertex_sampler_views(struct cso_context *ctx,
> - uint count,
> - struct pipe_sampler_view **views)
> -{
> - set_sampler_views(ctx, &ctx->vertex_samplers,
> - ctx->pipe->set_vertex_sampler_views,
> - count, views);
> -}
> -
> -
> -
> -static void
> -save_sampler_views(struct cso_context *ctx,
> - struct sampler_info *info)
> +cso_save_sampler_views(struct cso_context *ctx, unsigned shader_stage)
> {
> - uint i;
> + struct sampler_info *info = &ctx->samplers[shader_stage];
> + unsigned i;
>
> info->nr_views_saved = info->nr_views;
>
> @@ -1219,29 +1153,14 @@ save_sampler_views(struct cso_context *ctx,
> }
> }
>
> -void
> -cso_save_fragment_sampler_views(struct cso_context *ctx)
> -{
> - save_sampler_views(ctx, &ctx->fragment_samplers);
> -}
>
> void
> -cso_save_vertex_sampler_views(struct cso_context *ctx)
> +cso_restore_sampler_views(struct cso_context *ctx, unsigned shader_stage)
> {
> - save_sampler_views(ctx, &ctx->vertex_samplers);
> -}
> + struct sampler_info *info = &ctx->samplers[shader_stage];
> + unsigned i, nr_saved = info->nr_views_saved;
>
> -
> -static void
> -restore_sampler_views(struct cso_context *ctx,
> - struct sampler_info *info,
> - void (*set_views)(struct pipe_context *,
> - unsigned num_views,
> - struct pipe_sampler_view **))
> -{
> - uint i;
> -
> - for (i = 0; i < info->nr_views_saved; i++) {
> + for (i = 0; i < nr_saved; i++) {
> pipe_sampler_view_reference(&info->views[i], NULL);
> /* move the reference from one pointer to another */
> info->views[i] = info->views_saved[i];
> @@ -1252,26 +1171,24 @@ restore_sampler_views(struct cso_context *ctx,
> }
>
> /* bind the old/saved sampler views */
> - set_views(ctx->pipe, info->nr_views_saved, info->views);
> + switch (shader_stage) {
> + case PIPE_SHADER_FRAGMENT:
> + ctx->pipe->set_fragment_sampler_views(ctx->pipe, nr_saved, info->views);
> + break;
> + case PIPE_SHADER_VERTEX:
> + ctx->pipe->set_vertex_sampler_views(ctx->pipe, nr_saved, info->views);
> + break;
> + case PIPE_SHADER_GEOMETRY:
> + ctx->pipe->set_geometry_sampler_views(ctx->pipe, nr_saved, info->views);
> + break;
> + default:
> + assert(!"bad shader type in cso_restore_sampler_views()");
> + }
>
> - info->nr_views = info->nr_views_saved;
> + info->nr_views = nr_saved;
> info->nr_views_saved = 0;
> }
>
> -void
> -cso_restore_fragment_sampler_views(struct cso_context *ctx)
> -{
> - restore_sampler_views(ctx, &ctx->fragment_samplers,
> - ctx->pipe->set_fragment_sampler_views);
> -}
> -
> -void
> -cso_restore_vertex_sampler_views(struct cso_context *ctx)
> -{
> - restore_sampler_views(ctx, &ctx->vertex_samplers,
> - ctx->pipe->set_vertex_sampler_views);
> -}
> -
>
> void
> cso_set_stream_outputs(struct cso_context *ctx,
> diff --git a/src/gallium/auxiliary/cso_cache/cso_context.h b/src/gallium/auxiliary/cso_cache/cso_context.h
> index 4de08a8..f01a0f2 100644
> --- a/src/gallium/auxiliary/cso_cache/cso_context.h
> +++ b/src/gallium/auxiliary/cso_cache/cso_context.h
> @@ -69,39 +69,29 @@ void cso_save_rasterizer(struct cso_context *cso);
> void cso_restore_rasterizer(struct cso_context *cso);
>
>
> -
> -enum pipe_error cso_set_samplers( struct cso_context *cso,
> - unsigned count,
> - const struct pipe_sampler_state **states );
> -void cso_save_samplers(struct cso_context *cso);
> -void cso_restore_samplers(struct cso_context *cso);
> -
> -/* Alternate interface to support state trackers that like to modify
> - * samplers one at a time:
> - */
> -enum pipe_error cso_single_sampler( struct cso_context *cso,
> - unsigned nr,
> - const struct pipe_sampler_state *states );
> -
> -void cso_single_sampler_done( struct cso_context *cso );
> -
> -enum pipe_error cso_set_vertex_samplers(struct cso_context *cso,
> - unsigned count,
> - const struct pipe_sampler_state **states);
> +enum pipe_error
> +cso_set_samplers(struct cso_context *cso,
> + unsigned shader_stage,
> + unsigned count,
> + const struct pipe_sampler_state **states);
>
> void
> -cso_save_vertex_samplers(struct cso_context *cso);
> +cso_save_samplers(struct cso_context *cso, unsigned shader_stage);
>
> void
> -cso_restore_vertex_samplers(struct cso_context *cso);
> +cso_restore_samplers(struct cso_context *cso, unsigned shader_stage);
>
> +/* Alternate interface to support state trackers that like to modify
> + * samplers one at a time:
> + */
> enum pipe_error
> -cso_single_vertex_sampler(struct cso_context *cso,
> - unsigned nr,
> - const struct pipe_sampler_state *states);
> +cso_single_sampler(struct cso_context *cso,
> + unsigned shader_stage,
> + unsigned count,
> + const struct pipe_sampler_state *states);
>
> void
> -cso_single_vertex_sampler_done(struct cso_context *cso);
> +cso_single_sampler_done(struct cso_context *cso, unsigned shader_stage);
>
>
> enum pipe_error cso_set_vertex_elements(struct cso_context *ctx,
> @@ -126,6 +116,13 @@ void cso_save_stream_outputs(struct cso_context *ctx);
> void cso_restore_stream_outputs(struct cso_context *ctx);
>
>
> +/*
> + * We don't provide shader caching in CSO. Most of the time the api provides
> + * object semantics for shaders anyway, and the cases where it doesn't
> + * (eg mesa's internally-generated texenv programs), it will be up to
> + * the state tracker to implement their own specialized caching.
> + */
> +
> enum pipe_error cso_set_fragment_shader_handle(struct cso_context *ctx,
> void *handle );
> void cso_delete_fragment_shader(struct cso_context *ctx, void *handle );
> @@ -184,39 +181,21 @@ void
> cso_restore_clip(struct cso_context *cso);
>
>
> -/* fragment sampler view state */
> -
> -/*
> - * We don't provide shader caching in CSO. Most of the time the api provides
> - * object semantics for shaders anyway, and the cases where it doesn't
> - * (eg mesa's internally-generated texenv programs), it will be up to
> - * the state tracker to implement their own specialized caching.
> - */
> -
> -void
> -cso_set_fragment_sampler_views(struct cso_context *cso,
> - uint count,
> - struct pipe_sampler_view **views);
> +/* sampler view state */
>
> void
> -cso_save_fragment_sampler_views(struct cso_context *cso);
> +cso_set_sampler_views(struct cso_context *cso,
> + unsigned shader_stage,
> + unsigned count,
> + struct pipe_sampler_view **views);
>
> void
> -cso_restore_fragment_sampler_views(struct cso_context *cso);
> -
> -
> -/* vertex sampler view state */
> +cso_save_sampler_views(struct cso_context *cso, unsigned shader_stage);
>
> void
> -cso_set_vertex_sampler_views(struct cso_context *cso,
> - uint count,
> - struct pipe_sampler_view **views);
> +cso_restore_sampler_views(struct cso_context *cso, unsigned shader_stage);
>
> -void
> -cso_save_vertex_sampler_views(struct cso_context *cso);
>
> -void
> -cso_restore_vertex_sampler_views(struct cso_context *cso);
>
> /* drawing */
>
> diff --git a/src/gallium/auxiliary/postprocess/pp_colors.c b/src/gallium/auxiliary/postprocess/pp_colors.c
> index 36bb1f5..1773e53 100644
> --- a/src/gallium/auxiliary/postprocess/pp_colors.c
> +++ b/src/gallium/auxiliary/postprocess/pp_colors.c
> @@ -43,9 +43,9 @@ pp_nocolor(struct pp_queue_t *ppq, struct pipe_resource *in,
> pp_filter_set_fb(p);
> pp_filter_misc_state(p);
>
> - cso_single_sampler(p->cso, 0, &p->sampler_point);
> - cso_single_sampler_done(p->cso);
> - cso_set_fragment_sampler_views(p->cso, 1, &p->view);
> + cso_single_sampler(p->cso, PIPE_SHADER_FRAGMENT, 0, &p->sampler_point);
> + cso_single_sampler_done(p->cso, PIPE_SHADER_FRAGMENT);
> + cso_set_sampler_views(p->cso, PIPE_SHADER_FRAGMENT, 1, &p->view);
>
> cso_set_vertex_shader_handle(p->cso, ppq->shaders[n][0]);
> cso_set_fragment_shader_handle(p->cso, ppq->shaders[n][1]);
> diff --git a/src/gallium/auxiliary/postprocess/pp_init.c b/src/gallium/auxiliary/postprocess/pp_init.c
> index e2068c2..2dc29ac 100644
> --- a/src/gallium/auxiliary/postprocess/pp_init.c
> +++ b/src/gallium/auxiliary/postprocess/pp_init.c
> @@ -152,7 +152,7 @@ pp_free(struct pp_queue_t *ppq)
>
> util_destroy_blit(ppq->p->blitctx);
>
> - cso_set_fragment_sampler_views(ppq->p->cso, 0, NULL);
> + cso_set_sampler_views(ppq->p->cso, PIPE_SHADER_FRAGMENT, 0, NULL);
> cso_release_all(ppq->p->cso);
>
> for (i = 0; i < ppq->n_filters; i++) {
> diff --git a/src/gallium/auxiliary/postprocess/pp_mlaa.c b/src/gallium/auxiliary/postprocess/pp_mlaa.c
> index 951b76f..297f3e4 100644
> --- a/src/gallium/auxiliary/postprocess/pp_mlaa.c
> +++ b/src/gallium/auxiliary/postprocess/pp_mlaa.c
> @@ -125,9 +125,9 @@ pp_jimenezmlaa_run(struct pp_queue_t *ppq, struct pipe_resource *in,
> p->pipe->clear(p->pipe, PIPE_CLEAR_STENCIL | PIPE_CLEAR_COLOR,
> &p->clear_color, 0, 0);
>
> - cso_single_sampler(p->cso, 0, &p->sampler_point);
> - cso_single_sampler_done(p->cso);
> - cso_set_fragment_sampler_views(p->cso, 1, &p->view);
> + cso_single_sampler(p->cso, PIPE_SHADER_FRAGMENT, 0, &p->sampler_point);
> + cso_single_sampler_done(p->cso, PIPE_SHADER_FRAGMENT);
> + cso_set_sampler_views(p->cso, PIPE_SHADER_FRAGMENT, 1, &p->view);
>
> cso_set_vertex_shader_handle(p->cso, ppq->shaders[n][1]); /* offsetvs */
> cso_set_fragment_shader_handle(p->cso, ppq->shaders[n][2]);
> @@ -152,13 +152,13 @@ pp_jimenezmlaa_run(struct pp_queue_t *ppq, struct pipe_resource *in,
>
> pp_filter_set_clear_fb(p);
>
> - cso_single_sampler(p->cso, 0, &p->sampler_point);
> - cso_single_sampler(p->cso, 1, &p->sampler_point);
> - cso_single_sampler(p->cso, 2, &p->sampler);
> - cso_single_sampler_done(p->cso);
> + cso_single_sampler(p->cso, PIPE_SHADER_FRAGMENT, 0, &p->sampler_point);
> + cso_single_sampler(p->cso, PIPE_SHADER_FRAGMENT, 1, &p->sampler_point);
> + cso_single_sampler(p->cso, PIPE_SHADER_FRAGMENT, 2, &p->sampler);
> + cso_single_sampler_done(p->cso, PIPE_SHADER_FRAGMENT);
>
> arr[0] = p->view;
> - cso_set_fragment_sampler_views(p->cso, 3, arr);
> + cso_set_sampler_views(p->cso, PIPE_SHADER_FRAGMENT, 3, arr);
>
> cso_set_vertex_shader_handle(p->cso, ppq->shaders[n][0]); /* passvs */
> cso_set_fragment_shader_handle(p->cso, ppq->shaders[n][3]);
> @@ -184,12 +184,12 @@ pp_jimenezmlaa_run(struct pp_queue_t *ppq, struct pipe_resource *in,
> u_sampler_view_default_template(&v_tmp, in, in->format);
> arr[0] = p->pipe->create_sampler_view(p->pipe, in, &v_tmp);
>
> - cso_single_sampler(p->cso, 0, &p->sampler_point);
> - cso_single_sampler(p->cso, 1, &p->sampler_point);
> - cso_single_sampler_done(p->cso);
> + cso_single_sampler(p->cso, PIPE_SHADER_FRAGMENT, 0, &p->sampler_point);
> + cso_single_sampler(p->cso, PIPE_SHADER_FRAGMENT, 1, &p->sampler_point);
> + cso_single_sampler_done(p->cso, PIPE_SHADER_FRAGMENT);
>
> arr[1] = p->view;
> - cso_set_fragment_sampler_views(p->cso, 2, arr);
> + cso_set_sampler_views(p->cso, PIPE_SHADER_FRAGMENT, 2, arr);
>
> cso_set_vertex_shader_handle(p->cso, ppq->shaders[n][1]); /* offsetvs */
> cso_set_fragment_shader_handle(p->cso, ppq->shaders[n][4]);
> diff --git a/src/gallium/auxiliary/util/u_blit.c b/src/gallium/auxiliary/util/u_blit.c
> index b52f4c0..d2477d2 100644
> --- a/src/gallium/auxiliary/util/u_blit.c
> +++ b/src/gallium/auxiliary/util/u_blit.c
> @@ -648,8 +648,8 @@ util_blit_pixels(struct blit_state *ctx,
> cso_save_blend(ctx->cso);
> cso_save_depth_stencil_alpha(ctx->cso);
> cso_save_rasterizer(ctx->cso);
> - cso_save_samplers(ctx->cso);
> - cso_save_fragment_sampler_views(ctx->cso);
> + cso_save_samplers(ctx->cso, PIPE_SHADER_FRAGMENT);
> + cso_save_sampler_views(ctx->cso, PIPE_SHADER_FRAGMENT);
> cso_save_stream_outputs(ctx->cso);
> cso_save_viewport(ctx->cso);
> cso_save_framebuffer(ctx->cso);
> @@ -680,17 +680,17 @@ util_blit_pixels(struct blit_state *ctx,
> * we blit.
> */
> if (blit_depth && blit_stencil) {
> - cso_single_sampler(ctx->cso, 0, &ctx->sampler);
> + cso_single_sampler(ctx->cso, PIPE_SHADER_FRAGMENT, 0, &ctx->sampler);
> /* don't filter stencil */
> ctx->sampler.min_img_filter = PIPE_TEX_FILTER_NEAREST;
> ctx->sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST;
> - cso_single_sampler(ctx->cso, 1, &ctx->sampler);
> + cso_single_sampler(ctx->cso, PIPE_SHADER_FRAGMENT, 1, &ctx->sampler);
>
> cso_set_depth_stencil_alpha(ctx->cso, &ctx->dsa_write_depthstencil);
> set_depthstencil_fragment_shader(ctx, sampler_view->texture->target);
> }
> else if (blit_depth) {
> - cso_single_sampler(ctx->cso, 0, &ctx->sampler);
> + cso_single_sampler(ctx->cso, PIPE_SHADER_FRAGMENT, 0, &ctx->sampler);
> cso_set_depth_stencil_alpha(ctx->cso, &ctx->dsa_write_depth);
> set_depth_fragment_shader(ctx, sampler_view->texture->target);
> }
> @@ -698,17 +698,17 @@ util_blit_pixels(struct blit_state *ctx,
> /* don't filter stencil */
> ctx->sampler.min_img_filter = PIPE_TEX_FILTER_NEAREST;
> ctx->sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST;
> - cso_single_sampler(ctx->cso, 0, &ctx->sampler);
> + cso_single_sampler(ctx->cso, PIPE_SHADER_FRAGMENT, 0, &ctx->sampler);
>
> cso_set_depth_stencil_alpha(ctx->cso, &ctx->dsa_write_stencil);
> set_stencil_fragment_shader(ctx, sampler_view->texture->target);
> }
> else { /* color */
> - cso_single_sampler(ctx->cso, 0, &ctx->sampler);
> + cso_single_sampler(ctx->cso, PIPE_SHADER_FRAGMENT, 0, &ctx->sampler);
> cso_set_depth_stencil_alpha(ctx->cso, &ctx->dsa_keep_depthstencil);
> set_fragment_shader(ctx, writemask, sampler_view->texture->target);
> }
> - cso_single_sampler_done(ctx->cso);
> + cso_single_sampler_done(ctx->cso, PIPE_SHADER_FRAGMENT);
>
> /* textures */
> if (blit_depth && blit_stencil) {
> @@ -722,12 +722,12 @@ util_blit_pixels(struct blit_state *ctx,
>
> views[0] = sampler_view;
> views[1] = pipe->create_sampler_view(pipe, views[0]->texture, &templ);
> - cso_set_fragment_sampler_views(ctx->cso, 2, views);
> + cso_set_sampler_views(ctx->cso, PIPE_SHADER_FRAGMENT, 2, views);
>
> pipe_sampler_view_reference(&views[1], NULL);
> }
> else {
> - cso_set_fragment_sampler_views(ctx->cso, 1, &sampler_view);
> + cso_set_sampler_views(ctx->cso, PIPE_SHADER_FRAGMENT, 1, &sampler_view);
> }
>
> /* viewport */
> @@ -777,8 +777,8 @@ util_blit_pixels(struct blit_state *ctx,
> cso_restore_blend(ctx->cso);
> cso_restore_depth_stencil_alpha(ctx->cso);
> cso_restore_rasterizer(ctx->cso);
> - cso_restore_samplers(ctx->cso);
> - cso_restore_fragment_sampler_views(ctx->cso);
> + cso_restore_samplers(ctx->cso, PIPE_SHADER_FRAGMENT);
> + cso_restore_sampler_views(ctx->cso, PIPE_SHADER_FRAGMENT);
> cso_restore_viewport(ctx->cso);
> cso_restore_framebuffer(ctx->cso);
> cso_restore_fragment_shader(ctx->cso);
> @@ -849,8 +849,8 @@ util_blit_pixels_tex(struct blit_state *ctx,
> cso_save_blend(ctx->cso);
> cso_save_depth_stencil_alpha(ctx->cso);
> cso_save_rasterizer(ctx->cso);
> - cso_save_samplers(ctx->cso);
> - cso_save_fragment_sampler_views(ctx->cso);
> + cso_save_samplers(ctx->cso, PIPE_SHADER_FRAGMENT);
> + cso_save_sampler_views(ctx->cso, PIPE_SHADER_FRAGMENT);
> cso_save_stream_outputs(ctx->cso);
> cso_save_viewport(ctx->cso);
> cso_save_framebuffer(ctx->cso);
> @@ -871,8 +871,8 @@ util_blit_pixels_tex(struct blit_state *ctx,
> ctx->sampler.normalized_coords = normalized;
> ctx->sampler.min_img_filter = filter;
> ctx->sampler.mag_img_filter = filter;
> - cso_single_sampler(ctx->cso, 0, &ctx->sampler);
> - cso_single_sampler_done(ctx->cso);
> + cso_single_sampler(ctx->cso, PIPE_SHADER_FRAGMENT, 0, &ctx->sampler);
> + cso_single_sampler_done(ctx->cso, PIPE_SHADER_FRAGMENT);
>
> /* viewport */
> ctx->viewport.scale[0] = 0.5f * dst->width;
> @@ -886,7 +886,7 @@ util_blit_pixels_tex(struct blit_state *ctx,
> cso_set_viewport(ctx->cso, &ctx->viewport);
>
> /* texture */
> - cso_set_fragment_sampler_views(ctx->cso, 1, &src_sampler_view);
> + cso_set_sampler_views(ctx->cso, PIPE_SHADER_FRAGMENT, 1, &src_sampler_view);
>
> /* shaders */
> set_fragment_shader(ctx, TGSI_WRITEMASK_XYZW,
> @@ -921,8 +921,8 @@ util_blit_pixels_tex(struct blit_state *ctx,
> cso_restore_blend(ctx->cso);
> cso_restore_depth_stencil_alpha(ctx->cso);
> cso_restore_rasterizer(ctx->cso);
> - cso_restore_samplers(ctx->cso);
> - cso_restore_fragment_sampler_views(ctx->cso);
> + cso_restore_samplers(ctx->cso, PIPE_SHADER_FRAGMENT);
> + cso_restore_sampler_views(ctx->cso, PIPE_SHADER_FRAGMENT);
> cso_restore_viewport(ctx->cso);
> cso_restore_framebuffer(ctx->cso);
> cso_restore_fragment_shader(ctx->cso);
> diff --git a/src/gallium/auxiliary/util/u_gen_mipmap.c b/src/gallium/auxiliary/util/u_gen_mipmap.c
> index a96cf6a..222bf6b 100644
> --- a/src/gallium/auxiliary/util/u_gen_mipmap.c
> +++ b/src/gallium/auxiliary/util/u_gen_mipmap.c
> @@ -1573,8 +1573,8 @@ util_gen_mipmap(struct gen_mipmap_state *ctx,
> cso_save_blend(ctx->cso);
> cso_save_depth_stencil_alpha(ctx->cso);
> cso_save_rasterizer(ctx->cso);
> - cso_save_samplers(ctx->cso);
> - cso_save_fragment_sampler_views(ctx->cso);
> + cso_save_samplers(ctx->cso, PIPE_SHADER_FRAGMENT);
> + cso_save_sampler_views(ctx->cso, PIPE_SHADER_FRAGMENT);
> cso_save_stream_outputs(ctx->cso);
> cso_save_framebuffer(ctx->cso);
> cso_save_fragment_shader(ctx->cso);
> @@ -1675,10 +1675,10 @@ util_gen_mipmap(struct gen_mipmap_state *ctx,
> */
> ctx->sampler.min_lod = ctx->sampler.max_lod = (float) srcLevel;
> ctx->sampler.lod_bias = (float) srcLevel;
> - cso_single_sampler(ctx->cso, 0, &ctx->sampler);
> - cso_single_sampler_done(ctx->cso);
> + cso_single_sampler(ctx->cso, PIPE_SHADER_FRAGMENT, 0, &ctx->sampler);
> + cso_single_sampler_done(ctx->cso, PIPE_SHADER_FRAGMENT);
>
> - cso_set_fragment_sampler_views(ctx->cso, 1, &psv);
> + cso_set_sampler_views(ctx->cso, PIPE_SHADER_FRAGMENT, 1, &psv);
>
> /* quad coords in clip coords */
> offset = set_vertex_data(ctx,
> @@ -1703,8 +1703,8 @@ util_gen_mipmap(struct gen_mipmap_state *ctx,
> cso_restore_blend(ctx->cso);
> cso_restore_depth_stencil_alpha(ctx->cso);
> cso_restore_rasterizer(ctx->cso);
> - cso_restore_samplers(ctx->cso);
> - cso_restore_fragment_sampler_views(ctx->cso);
> + cso_restore_samplers(ctx->cso, PIPE_SHADER_FRAGMENT);
> + cso_restore_sampler_views(ctx->cso, PIPE_SHADER_FRAGMENT);
> cso_restore_framebuffer(ctx->cso);
> cso_restore_fragment_shader(ctx->cso);
> cso_restore_vertex_shader(ctx->cso);
> diff --git a/src/mesa/state_tracker/st_atom_sampler.c b/src/mesa/state_tracker/st_atom_sampler.c
> index dc0c789..84fbd9d 100644
> --- a/src/mesa/state_tracker/st_atom_sampler.c
> +++ b/src/mesa/state_tracker/st_atom_sampler.c
> @@ -219,12 +219,12 @@ update_vertex_samplers(struct st_context *st)
>
> st->state.num_vertex_samplers = su + 1;
>
> - cso_single_vertex_sampler(st->cso_context, su, sampler);
> + cso_single_sampler(st->cso_context, PIPE_SHADER_VERTEX, su, sampler);
> } else {
> - cso_single_vertex_sampler(st->cso_context, su, NULL);
> + cso_single_sampler(st->cso_context, PIPE_SHADER_VERTEX, su, NULL);
> }
> }
> - cso_single_vertex_sampler_done(st->cso_context);
> + cso_single_sampler_done(st->cso_context, PIPE_SHADER_VERTEX);
> }
>
>
> @@ -253,18 +253,18 @@ update_fragment_samplers(struct st_context *st)
> st->state.num_samplers = su + 1;
>
> /*printf("%s su=%u non-null\n", __FUNCTION__, su);*/
> - cso_single_sampler(st->cso_context, su, sampler);
> + cso_single_sampler(st->cso_context, PIPE_SHADER_FRAGMENT, su, sampler);
> }
> else if (samplers_used != 0 || su < old_max) {
> /*printf("%s su=%u null\n", __FUNCTION__, su);*/
> - cso_single_sampler(st->cso_context, su, NULL);
> + cso_single_sampler(st->cso_context, PIPE_SHADER_FRAGMENT, su, NULL);
> } else {
> /* if we've reset all the old views and we have no more new ones */
> break;
> }
> }
>
> - cso_single_sampler_done(st->cso_context);
> + cso_single_sampler_done(st->cso_context, PIPE_SHADER_FRAGMENT);
> }
>
>
> diff --git a/src/mesa/state_tracker/st_atom_texture.c b/src/mesa/state_tracker/st_atom_texture.c
> index fefa598..f5db65a 100644
> --- a/src/mesa/state_tracker/st_atom_texture.c
> +++ b/src/mesa/state_tracker/st_atom_texture.c
> @@ -288,9 +288,10 @@ update_vertex_textures(struct st_context *st)
> if (ctx->Const.MaxVertexTextureImageUnits > 0) {
> GLuint numUnits = MIN2(st->state.num_vertex_textures,
> ctx->Const.MaxVertexTextureImageUnits);
> - cso_set_vertex_sampler_views(st->cso_context,
> - numUnits,
> - st->state.sampler_vertex_views);
> + cso_set_sampler_views(st->cso_context,
> + PIPE_SHADER_VERTEX,
> + numUnits,
> + st->state.sampler_vertex_views);
> }
> }
>
> @@ -329,9 +330,10 @@ update_fragment_textures(struct st_context *st)
> pipe_sampler_view_reference(&st->state.sampler_views[su], sampler_view);
> }
>
> - cso_set_fragment_sampler_views(st->cso_context,
> - st->state.num_textures,
> - st->state.sampler_views);
> + cso_set_sampler_views(st->cso_context,
> + PIPE_SHADER_FRAGMENT,
> + st->state.num_textures,
> + st->state.sampler_views);
> }
>
>
> diff --git a/src/mesa/state_tracker/st_cb_bitmap.c b/src/mesa/state_tracker/st_cb_bitmap.c
> index c260588..131efca 100644
> --- a/src/mesa/state_tracker/st_cb_bitmap.c
> +++ b/src/mesa/state_tracker/st_cb_bitmap.c
> @@ -454,8 +454,8 @@ draw_bitmap_quad(struct gl_context *ctx, GLint x, GLint y, GLfloat z,
> assert(height <= (GLsizei)maxSize);
>
> cso_save_rasterizer(cso);
> - cso_save_samplers(cso);
> - cso_save_fragment_sampler_views(cso);
> + cso_save_samplers(cso, PIPE_SHADER_FRAGMENT);
> + cso_save_sampler_views(cso, PIPE_SHADER_FRAGMENT);
> cso_save_viewport(cso);
> cso_save_fragment_shader(cso);
> cso_save_stream_outputs(cso);
> @@ -487,7 +487,8 @@ draw_bitmap_quad(struct gl_context *ctx, GLint x, GLint y, GLfloat z,
> }
> samplers[fpv->bitmap_sampler] =
> &st->bitmap.samplers[sv->texture->target != PIPE_TEXTURE_RECT];
> - cso_set_samplers(cso, num, (const struct pipe_sampler_state **) samplers);
> + cso_set_samplers(cso, PIPE_SHADER_FRAGMENT, num,
> + (const struct pipe_sampler_state **) samplers);
> }
>
> /* user textures, plus the bitmap texture */
> @@ -496,7 +497,7 @@ draw_bitmap_quad(struct gl_context *ctx, GLint x, GLint y, GLfloat z,
> uint num = MAX2(fpv->bitmap_sampler + 1, st->state.num_textures);
> memcpy(sampler_views, st->state.sampler_views, sizeof(sampler_views));
> sampler_views[fpv->bitmap_sampler] = sv;
> - cso_set_fragment_sampler_views(cso, num, sampler_views);
> + cso_set_sampler_views(cso, PIPE_SHADER_FRAGMENT, num, sampler_views);
> }
>
> /* viewport state: viewport matching window dims */
> @@ -535,8 +536,8 @@ draw_bitmap_quad(struct gl_context *ctx, GLint x, GLint y, GLfloat z,
>
> /* restore state */
> cso_restore_rasterizer(cso);
> - cso_restore_samplers(cso);
> - cso_restore_fragment_sampler_views(cso);
> + cso_restore_samplers(cso, PIPE_SHADER_FRAGMENT);
> + cso_restore_sampler_views(cso, PIPE_SHADER_FRAGMENT);
> cso_restore_viewport(cso);
> cso_restore_fragment_shader(cso);
> cso_restore_vertex_shader(cso);
> diff --git a/src/mesa/state_tracker/st_cb_drawpixels.c b/src/mesa/state_tracker/st_cb_drawpixels.c
> index f288a96..88068ac 100644
> --- a/src/mesa/state_tracker/st_cb_drawpixels.c
> +++ b/src/mesa/state_tracker/st_cb_drawpixels.c
> @@ -679,8 +679,8 @@ draw_textured_quad(struct gl_context *ctx, GLint x, GLint y, GLfloat z,
>
> cso_save_rasterizer(cso);
> cso_save_viewport(cso);
> - cso_save_samplers(cso);
> - cso_save_fragment_sampler_views(cso);
> + cso_save_samplers(cso, PIPE_SHADER_FRAGMENT);
> + cso_save_sampler_views(cso, PIPE_SHADER_FRAGMENT);
> cso_save_fragment_shader(cso);
> cso_save_stream_outputs(cso);
> cso_save_vertex_shader(cso);
> @@ -751,11 +751,11 @@ draw_textured_quad(struct gl_context *ctx, GLint x, GLint y, GLfloat z,
> sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST;
> sampler.normalized_coords = normalized;
>
> - cso_single_sampler(cso, 0, &sampler);
> + cso_single_sampler(cso, PIPE_SHADER_FRAGMENT, 0, &sampler);
> if (num_sampler_view > 1) {
> - cso_single_sampler(cso, 1, &sampler);
> + cso_single_sampler(cso, PIPE_SHADER_FRAGMENT, 1, &sampler);
> }
> - cso_single_sampler_done(cso);
> + cso_single_sampler_done(cso, PIPE_SHADER_FRAGMENT);
> }
>
> /* viewport state: viewport matching window dims */
> @@ -778,7 +778,7 @@ draw_textured_quad(struct gl_context *ctx, GLint x, GLint y, GLfloat z,
> cso_set_stream_outputs(st->cso_context, 0, NULL, 0);
>
> /* texture state: */
> - cso_set_fragment_sampler_views(cso, num_sampler_view, sv);
> + cso_set_sampler_views(cso, PIPE_SHADER_FRAGMENT, num_sampler_view, sv);
>
> /* Compute Gallium window coords (y=0=top) with pixel zoom.
> * Recall that these coords are transformed by the current
> @@ -804,8 +804,8 @@ draw_textured_quad(struct gl_context *ctx, GLint x, GLint y, GLfloat z,
> /* restore state */
> cso_restore_rasterizer(cso);
> cso_restore_viewport(cso);
> - cso_restore_samplers(cso);
> - cso_restore_fragment_sampler_views(cso);
> + cso_restore_samplers(cso, PIPE_SHADER_FRAGMENT);
> + cso_restore_sampler_views(cso, PIPE_SHADER_FRAGMENT);
> cso_restore_fragment_shader(cso);
> cso_restore_vertex_shader(cso);
> cso_restore_geometry_shader(cso);
> --
> 1.7.3.4
>
> _______________________________________________
> mesa-dev mailing list
> mesa-dev at lists.freedesktop.org
> http://lists.freedesktop.org/mailman/listinfo/mesa-dev
More information about the mesa-dev
mailing list