ctx->pipe->set_shader_buffers(ctx->pipe, sh, 0, maxssbo, ssbos, 0);
}
if (maximg > 0) {
- ctx->pipe->set_shader_images(ctx->pipe, sh, 0, maximg, NULL);
+ ctx->pipe->set_shader_images(ctx->pipe, sh, 0, 0, maximg, NULL);
}
for (int i = 0; i < maxcb; i++) {
ctx->pipe->set_constant_buffer(ctx->pipe, sh, i, false, NULL);
dd_context_set_shader_images(struct pipe_context *_pipe,
enum pipe_shader_type shader,
unsigned start, unsigned num,
+ unsigned unbind_num_trailing_slots,
const struct pipe_image_view *views)
{
struct dd_context *dctx = dd_context(_pipe);
safe_memcpy(&dctx->draw_state.shader_images[shader][start], views,
sizeof(views[0]) * num);
- pipe->set_shader_images(pipe, shader, start, num, views);
+ safe_memcpy(&dctx->draw_state.shader_images[shader][start + num], NULL,
+ sizeof(views[0]) * unbind_num_trailing_slots);
+ pipe->set_shader_images(pipe, shader, start, num,
+ unbind_num_trailing_slots, views);
}
static void
static void trace_context_set_shader_images(struct pipe_context *_context,
enum pipe_shader_type shader,
unsigned start, unsigned nr,
+ unsigned unbind_num_trailing_slots,
const struct pipe_image_view *images)
{
struct trace_context *tr_context = trace_context(_context);
trace_dump_arg_begin("images");
trace_dump_struct_array(image_view, images, nr);
trace_dump_arg_end();
+ trace_dump_arg(uint, unbind_num_trailing_slots);
trace_dump_call_end();
- context->set_shader_images(context, shader, start, nr, images);
+ context->set_shader_images(context, shader, start, nr,
+ unbind_num_trailing_slots, images);
}
static void trace_context_launch_grid(struct pipe_context *_pipe,
image.u.tex.first_layer = 0;
image.u.tex.last_layer = (unsigned)(dst->array_size - 1);
- ctx->set_shader_images(ctx, PIPE_SHADER_COMPUTE, 0, 1, &image);
+ ctx->set_shader_images(ctx, PIPE_SHADER_COMPUTE, 0, 1, 0, &image);
struct pipe_sampler_state sampler_state={0};
sampler_state.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
ctx->memory_barrier(ctx, PIPE_BARRIER_ALL);
- ctx->set_shader_images(ctx, PIPE_SHADER_COMPUTE, 0, 1, NULL);
+ ctx->set_shader_images(ctx, PIPE_SHADER_COMPUTE, 0, 0, 1, NULL);
ctx->set_constant_buffer(ctx, PIPE_SHADER_COMPUTE, 0, false, NULL);
ctx->set_sampler_views(ctx, PIPE_SHADER_COMPUTE, 0, 1, NULL);
pipe_sampler_view_reference(&src_view, NULL);
image.shader_access = image.access = PIPE_IMAGE_ACCESS_READ_WRITE;
image.format = cb->format;
- ctx->set_shader_images(ctx, PIPE_SHADER_COMPUTE, 0, 1, &image);
+ ctx->set_shader_images(ctx, PIPE_SHADER_COMPUTE, 0, 1, 0, &image);
/* Dispatch compute. */
struct pipe_grid_info info = {0};
struct tc_shader_images {
ubyte shader, start, count;
- bool unbind;
+ ubyte unbind_num_trailing_slots;
struct pipe_image_view slot[0]; /* more will be allocated if needed */
};
struct tc_shader_images *p = (struct tc_shader_images *)payload;
unsigned count = p->count;
- if (p->unbind) {
- pipe->set_shader_images(pipe, p->shader, p->start, p->count, NULL);
+ if (!p->count) {
+ pipe->set_shader_images(pipe, p->shader, p->start, 0,
+ p->unbind_num_trailing_slots, NULL);
return;
}
- pipe->set_shader_images(pipe, p->shader, p->start, p->count, p->slot);
+ pipe->set_shader_images(pipe, p->shader, p->start, p->count,
+ p->unbind_num_trailing_slots, p->slot);
for (unsigned i = 0; i < count; i++)
pipe_resource_reference(&p->slot[i].resource, NULL);
tc_set_shader_images(struct pipe_context *_pipe,
enum pipe_shader_type shader,
unsigned start, unsigned count,
+ unsigned unbind_num_trailing_slots,
const struct pipe_image_view *images)
{
- if (!count)
+ if (!count && !unbind_num_trailing_slots)
return;
struct threaded_context *tc = threaded_context(_pipe);
p->shader = shader;
p->start = start;
- p->count = count;
- p->unbind = images == NULL;
if (images) {
+ p->count = count;
+ p->unbind_num_trailing_slots = unbind_num_trailing_slots;
+
for (unsigned i = 0; i < count; i++) {
tc_set_resource_reference(&p->slot[i].resource, images[i].resource);
}
}
memcpy(p->slot, images, count * sizeof(images[0]));
+ } else {
+ p->count = 0;
+ p->unbind_num_trailing_slots = count + unbind_num_trailing_slots;
}
}
image.shader_access = image.access = PIPE_IMAGE_ACCESS_READ_WRITE;
image.format = c->fb_state.cbufs[0]->texture->format;
- ctx->set_shader_images(c->pipe, PIPE_SHADER_COMPUTE, 0, 1, &image);
+ ctx->set_shader_images(c->pipe, PIPE_SHADER_COMPUTE, 0, 1, 0, &image);
/* Bind compute shader */
ctx->bind_compute_state(ctx, cs);
cs_launch(c, layer->cs, &(drawn.area));
/* Unbind. */
- c->pipe->set_shader_images(c->pipe, PIPE_SHADER_COMPUTE, 0, 1, NULL);
+ c->pipe->set_shader_images(c->pipe, PIPE_SHADER_COMPUTE, 0, 0, 1, NULL);
c->pipe->set_constant_buffer(c->pipe, PIPE_SHADER_COMPUTE, 0, false, NULL);
c->pipe->set_sampler_views(c->pipe, PIPE_SHADER_FRAGMENT, 0,
num_sampler_views, NULL);
static void fd6_set_shader_images(struct pipe_context *pctx,
enum pipe_shader_type shader,
unsigned start, unsigned count,
+ unsigned unbind_num_trailing_slots,
const struct pipe_image_view *images)
{
struct fd_context *ctx = fd_context(pctx);
struct fd_shaderimg_stateobj *so = &ctx->shaderimg[shader];
- fd_set_shader_images(pctx, shader, start, count, images);
+ fd_set_shader_images(pctx, shader, start, count,
+ unbind_num_trailing_slots, images);
if (!images)
return;
fd_set_shader_images(struct pipe_context *pctx,
enum pipe_shader_type shader,
unsigned start, unsigned count,
+ unsigned unbind_num_trailing_slots,
const struct pipe_image_view *images)
{
struct fd_context *ctx = fd_context(pctx);
so->enabled_mask &= ~mask;
}
+ for (unsigned i = 0; i < unbind_num_trailing_slots; i++)
+ pipe_resource_reference(&so->si[i + start + count].resource, NULL);
+
+ so->enabled_mask &= ~(BITFIELD_MASK(unbind_num_trailing_slots) << (start + count));
+
ctx->dirty_shader[shader] |= FD_DIRTY_SHADER_IMAGE;
ctx->dirty |= FD_DIRTY_IMAGE;
}
void fd_set_shader_images(struct pipe_context *pctx,
enum pipe_shader_type shader,
unsigned start, unsigned count,
+ unsigned unbind_num_trailing_slots,
const struct pipe_image_view *images);
void fd_state_init(struct pipe_context *pctx);
iris_set_shader_images(struct pipe_context *ctx,
enum pipe_shader_type p_stage,
unsigned start_slot, unsigned count,
+ unsigned unbind_num_trailing_slots,
const struct pipe_image_view *p_images)
{
struct iris_context *ice = (struct iris_context *) ctx;
ice->state.stage_dirty |= IRIS_STAGE_DIRTY_CONSTANTS_VS << stage;
shs->sysvals_need_upload = true;
}
+
+ if (unbind_num_trailing_slots) {
+ iris_set_shader_images(ctx, p_stage, start_slot + count,
+ unbind_num_trailing_slots, 0, NULL);
+ }
}
static void
llvmpipe_set_shader_images(struct pipe_context *pipe,
enum pipe_shader_type shader, unsigned start_slot,
- unsigned count, const struct pipe_image_view *images)
+ unsigned count, unsigned unbind_num_trailing_slots,
+ const struct pipe_image_view *images)
{
struct llvmpipe_context *llvmpipe = llvmpipe_context(pipe);
unsigned i, idx;
llvmpipe->cs_dirty |= LP_CSNEW_IMAGES;
else
llvmpipe->dirty |= LP_NEW_FS_IMAGES;
+
+ if (unbind_num_trailing_slots) {
+ llvmpipe_set_shader_images(pipe, shader, start_slot + count,
+ unbind_num_trailing_slots, 0, NULL);
+ }
}
/**
nvc0_set_shader_images(struct pipe_context *pipe,
enum pipe_shader_type shader,
unsigned start, unsigned nr,
+ unsigned unbind_num_trailing_slots,
const struct pipe_image_view *images)
{
const unsigned s = nvc0_shader_stage(shader);
+
+ nvc0_bind_images_range(nvc0_context(pipe), s, start + nr,
+ unbind_num_trailing_slots, NULL);
+
if (!nvc0_bind_images_range(nvc0_context(pipe), s, start, nr, images))
return;
panfrost_set_shader_images(
struct pipe_context *pctx,
enum pipe_shader_type shader,
- unsigned start_slot, unsigned count,
+ unsigned start_slot, unsigned count, unsigned unbind_num_trailing_slots,
const struct pipe_image_view *iviews)
{
struct panfrost_context *ctx = pan_context(pctx);
/* Unbind start_slot...start_slot+count */
if (!iviews) {
- for (int i = start_slot; i < start_slot + count; i++) {
+ for (int i = start_slot; i < start_slot + count + unbind_num_trailing_slots; i++) {
pipe_resource_reference(&ctx->images[shader][i].resource, NULL);
}
util_copy_image_view(&ctx->images[shader][start_slot+i], image);
}
+
+ /* Unbind start_slot+count...start_slot+count+unbind_num_trailing_slots */
+ for (int i = 0; i < unbind_num_trailing_slots; i++) {
+ SET_BIT(ctx->image_mask[shader], 1 << (start_slot + count + i), NULL);
+ util_copy_image_view(&ctx->images[shader][start_slot+count+i], NULL);
+ }
}
static void *
static void evergreen_set_shader_images(struct pipe_context *ctx,
enum pipe_shader_type shader, unsigned start_slot,
- unsigned count,
+ unsigned count, unsigned unbind_num_trailing_slots,
const struct pipe_image_view *images)
{
struct r600_context *rctx = (struct r600_context *)ctx;
unsigned old_mask;
struct r600_image_state *istate = NULL;
int idx;
- if (shader != PIPE_SHADER_FRAGMENT && shader != PIPE_SHADER_COMPUTE && count == 0)
+ if (shader != PIPE_SHADER_FRAGMENT && shader != PIPE_SHADER_COMPUTE)
+ return;
+ if (!count && !unbind_num_trailing_slots)
return;
if (shader == PIPE_SHADER_FRAGMENT)
istate->enabled_mask |= (1 << i);
}
+ for (i = start_slot + count, idx = 0;
+ i < start_slot + count + unbind_num_trailing_slots; i++, idx++) {
+ rview = &istate->views[i];
+
+ pipe_resource_reference((struct pipe_resource **)&rview->base.resource, NULL);
+ istate->enabled_mask &= ~(1 << i);
+ istate->compressed_colortex_mask &= ~(1 << i);
+ istate->compressed_depthtex_mask &= ~(1 << i);
+ }
+
istate->atom.num_dw = util_bitcount(istate->enabled_mask) * 46;
istate->dirty_buffer_constants = TRUE;
rctx->b.flags |= R600_CONTEXT_WAIT_3D_IDLE | R600_CONTEXT_FLUSH_AND_INV;
if (is_dcc_decompress)
image[1].access |= SI_IMAGE_ACCESS_DCC_OFF;
- ctx->set_shader_images(ctx, PIPE_SHADER_COMPUTE, 0, 2, image);
+ ctx->set_shader_images(ctx, PIPE_SHADER_COMPUTE, 0, 2, 0, image);
struct pipe_grid_info info = {0};
si_launch_grid_internal(sctx, &info, saved_cs,
SI_CS_WAIT_FOR_IDLE | SI_CS_IMAGE_OP);
- ctx->set_shader_images(ctx, PIPE_SHADER_COMPUTE, 0, 2, saved_image);
+ ctx->set_shader_images(ctx, PIPE_SHADER_COMPUTE, 0, 2, 0, saved_image);
for (int i = 0; i < 2; i++)
pipe_resource_reference(&saved_image[i].resource, NULL);
if (!is_dcc_decompress) {
img[2].u.buf.offset = tex->surface.display_dcc_offset;
img[2].u.buf.size = tex->surface.u.gfx9.display_dcc_size;
- ctx->set_shader_images(ctx, PIPE_SHADER_COMPUTE, 0, 3, img);
+ ctx->set_shader_images(ctx, PIPE_SHADER_COMPUTE, 0, 3, 0, img);
/* Bind the compute shader. */
if (!sctx->cs_dcc_retile)
*/
/* Restore states. */
- ctx->set_shader_images(ctx, PIPE_SHADER_COMPUTE, 0, 3, saved_img);
+ ctx->set_shader_images(ctx, PIPE_SHADER_COMPUTE, 0, 3, 0, saved_img);
for (unsigned i = 0; i < 3; i++) {
pipe_resource_reference(&saved_img[i].resource, NULL);
if (is_array)
image.u.tex.last_layer = tex->array_size - 1;
- ctx->set_shader_images(ctx, PIPE_SHADER_COMPUTE, 0, 1, &image);
+ ctx->set_shader_images(ctx, PIPE_SHADER_COMPUTE, 0, 1, 0, &image);
/* Bind the shader. */
void **shader = &sctx->cs_fmask_expand[log_samples - 1][is_array];
SI_CS_WAIT_FOR_IDLE | SI_CS_IMAGE_OP);
/* Restore previous states. */
- ctx->set_shader_images(ctx, PIPE_SHADER_COMPUTE, 0, 1, &saved_image);
+ ctx->set_shader_images(ctx, PIPE_SHADER_COMPUTE, 0, 1, 0, &saved_image);
pipe_resource_reference(&saved_image.resource, NULL);
/* Array of fully expanded FMASK values, arranged by [log2(fragments)][log2(samples)-1]. */
image.u.tex.first_layer = 0; /* 3D images ignore first_layer (BASE_ARRAY) */
image.u.tex.last_layer = dstsurf->u.tex.last_layer;
- ctx->set_shader_images(ctx, PIPE_SHADER_COMPUTE, 0, 1, &image);
+ ctx->set_shader_images(ctx, PIPE_SHADER_COMPUTE, 0, 1, 0, &image);
struct pipe_grid_info info = {0};
SI_CS_WAIT_FOR_IDLE | SI_CS_IMAGE_OP |
(render_condition_enabled ? SI_CS_RENDER_COND_ENABLE : 0));
- ctx->set_shader_images(ctx, PIPE_SHADER_COMPUTE, 0, 1, &saved_image);
+ ctx->set_shader_images(ctx, PIPE_SHADER_COMPUTE, 0, 1, 0, &saved_image);
ctx->set_constant_buffer(ctx, PIPE_SHADER_COMPUTE, 0, true, &saved_cb);
pipe_resource_reference(&saved_image.resource, NULL);
}
static void si_set_shader_images(struct pipe_context *pipe, enum pipe_shader_type shader,
unsigned start_slot, unsigned count,
+ unsigned unbind_num_trailing_slots,
const struct pipe_image_view *views)
{
struct si_context *ctx = (struct si_context *)pipe;
assert(shader < SI_NUM_SHADERS);
- if (!count)
+ if (!count && !unbind_num_trailing_slots)
return;
- assert(start_slot + count <= SI_NUM_IMAGES);
+ assert(start_slot + count + unbind_num_trailing_slots <= SI_NUM_IMAGES);
if (views) {
for (i = 0, slot = start_slot; i < count; ++i, ++slot)
si_set_shader_image(ctx, shader, slot, NULL, false);
}
+ for (i = 0; i < unbind_num_trailing_slots; ++i, ++slot)
+ si_set_shader_image(ctx, shader, slot, NULL, false);
+
if (shader == PIPE_SHADER_COMPUTE &&
ctx->cs_shader_state.program &&
start_slot < ctx->cs_shader_state.program->sel.cs_num_images_in_user_sgprs)
enum pipe_shader_type shader,
unsigned start,
unsigned num,
+ unsigned unbind_num_trailing_slots,
const struct pipe_image_view *images)
{
struct softpipe_context *softpipe = softpipe_context(pipe);
memset(&softpipe->tgsi.image[shader]->sp_iview[idx], 0, sizeof(struct pipe_image_view));
}
}
+
+ for (i = 0; i < unbind_num_trailing_slots; i++) {
+ int idx = start + num + i;
+
+ pipe_resource_reference(&softpipe->tgsi.image[shader]->sp_iview[idx].resource, NULL);
+ memset(&softpipe->tgsi.image[shader]->sp_iview[idx], 0, sizeof(struct pipe_image_view));
+ }
}
static void softpipe_set_shader_buffers(struct pipe_context *pipe,
static void
tegra_set_shader_images(struct pipe_context *pcontext, unsigned int shader,
unsigned start, unsigned count,
+ unsigned unbind_num_trailing_slots,
const struct pipe_image_view *images)
{
struct tegra_context *context = to_tegra_context(pcontext);
context->gpu->set_shader_images(context->gpu, shader, start, count,
- images);
+ unbind_num_trailing_slots, images);
}
static void
v3d_set_shader_images(struct pipe_context *pctx,
enum pipe_shader_type shader,
unsigned start, unsigned count,
+ unsigned unbind_num_trailing_slots,
const struct pipe_image_view *images)
{
struct v3d_context *v3d = v3d_context(pctx);
}
v3d->dirty |= VC5_DIRTY_SHADER_IMAGE;
+
+ if (unbind_num_trailing_slots) {
+ v3d_set_shader_images(pctx, shader, start + count,
+ unbind_num_trailing_slots, 0, NULL);
+ }
}
void
static void virgl_set_shader_images(struct pipe_context *ctx,
enum pipe_shader_type shader,
unsigned start_slot, unsigned count,
+ unsigned unbind_num_trailing_slots,
const struct pipe_image_view *images)
{
struct virgl_context *vctx = virgl_context(ctx);
if (!max_shader_images)
return;
virgl_encode_set_shader_images(vctx, shader, start_slot, count, images);
+
+ if (unbind_num_trailing_slots) {
+ virgl_set_shader_images(ctx, shader, start_slot + count,
+ unbind_num_trailing_slots, 0, NULL);
+ }
}
static void virgl_memory_barrier(struct pipe_context *ctx,
zink_set_shader_images(struct pipe_context *pctx,
enum pipe_shader_type p_stage,
unsigned start_slot, unsigned count,
+ unsigned unbind_num_trailing_slots,
const struct pipe_image_view *images)
{
struct zink_context *ctx = zink_context(pctx);
image_view->surface = NULL;
}
}
+
+ for (unsigned i = 0; i < unbind_num_trailing_slots; i++) {
+ struct zink_image_view *image_view = &ctx->image_views[p_stage][start_slot + count + i];
+ if (image_view->base.resource) {
+ if (image_view->base.resource->target == PIPE_BUFFER)
+ vkDestroyBufferView(zink_screen(pctx->screen)->dev, image_view->buffer_view, NULL);
+ else
+ pipe_surface_reference((struct pipe_surface**)&image_view->surface, NULL);
+ pipe_resource_reference(&image_view->base.resource, NULL);
+ image_view->base.resource = NULL;
+ image_view->surface = NULL;
+ }
+ }
}
static void
q.pipe->set_sampler_views(q.pipe, PIPE_SHADER_COMPUTE, 0,
exec.sviews.size(), exec.sviews.data());
q.pipe->set_shader_images(q.pipe, PIPE_SHADER_COMPUTE, 0,
- exec.iviews.size(), exec.iviews.data());
+ exec.iviews.size(), 0, exec.iviews.data());
q.pipe->set_compute_resources(q.pipe, 0, exec.resources.size(),
exec.resources.data());
q.pipe->set_global_binding(q.pipe, 0, exec.g_buffers.size(),
q.pipe->set_global_binding(q.pipe, 0, exec.g_buffers.size(), NULL, NULL);
q.pipe->set_compute_resources(q.pipe, 0, exec.resources.size(), NULL);
q.pipe->set_shader_images(q.pipe, PIPE_SHADER_COMPUTE, 0,
- exec.iviews.size(), NULL);
+ 0, exec.iviews.size(), NULL);
q.pipe->set_sampler_views(q.pipe, PIPE_SHADER_COMPUTE, 0,
exec.sviews.size(), NULL);
q.pipe->bind_sampler_states(q.pipe, PIPE_SHADER_COMPUTE, 0,
if (state->iv_dirty[PIPE_SHADER_COMPUTE]) {
state->pctx->set_shader_images(state->pctx, PIPE_SHADER_COMPUTE,
0, state->num_shader_images[PIPE_SHADER_COMPUTE],
- state->iv[PIPE_SHADER_COMPUTE]);
+ 0, state->iv[PIPE_SHADER_COMPUTE]);
state->iv_dirty[PIPE_SHADER_COMPUTE] = false;
}
for (sh = 0; sh < PIPE_SHADER_TYPES; sh++) {
if (state->iv_dirty[sh]) {
state->pctx->set_shader_images(state->pctx, sh,
- 0, state->num_shader_images[sh],
+ 0, state->num_shader_images[sh], 0,
state->iv[sh]);
}
}
}
state.pctx->bind_sampler_states(state.pctx, s, 0, PIPE_MAX_SAMPLERS, state.ss_cso[s]);
- state.pctx->set_shader_images(state.pctx, s, 0, device->physical_device->max_images, NULL);
+ state.pctx->set_shader_images(state.pctx, s, 0, 0, device->physical_device->max_images, NULL);
}
free(state.pending_clear_aspects);
image[2].shader_access = image[1].access = PIPE_IMAGE_ACCESS_WRITE;
image[2].format = PIPE_FORMAT_R8G8_UINT;
- pipe->set_shader_images(pipe, PIPE_SHADER_COMPUTE, 0, 3, image);
+ pipe->set_shader_images(pipe, PIPE_SHADER_COMPUTE, 0, 3, 0, image);
/* Set the constant buffer. */
uint32_t constants[4] = {def->nFrameHeight};
pipe->memory_barrier(pipe, PIPE_BARRIER_ALL);
/* Unbind. */
- pipe->set_shader_images(pipe, PIPE_SHADER_COMPUTE, 0, 3, NULL);
+ pipe->set_shader_images(pipe, PIPE_SHADER_COMPUTE, 0, 0, 3, NULL);
pipe->set_constant_buffer(pipe, PIPE_SHADER_COMPUTE, 0, false, NULL);
pipe->bind_compute_state(pipe, NULL);
} else {
* \param shader selects shader stage
* \param start_slot first image slot to bind.
* \param count number of consecutive images to bind.
+ * \param unbind_num_trailing_slots number of images to unbind after
+ * the bound slot
* \param buffers array of the images to bind, it
* should contain at least \a count elements
* unless it's NULL, in which case no images will
void (*set_shader_images)(struct pipe_context *,
enum pipe_shader_type shader,
unsigned start_slot, unsigned count,
+ unsigned unbind_num_trailing_slots,
const struct pipe_image_view *images);
void (*set_vertex_buffers)( struct pipe_context *,
}
struct pipe_context *pipe = st->pipe;
- pipe->set_shader_images(pipe, shader_type, 0, num_images, images);
-
- /* clear out any stale shader images */
unsigned last_num_images = st->state.num_images[shader_type];
- if (num_images < last_num_images) {
- pipe->set_shader_images(pipe, shader_type, num_images,
- last_num_images - num_images, NULL);
- }
+ unsigned unbind_slots = last_num_images > num_images ?
+ last_num_images - num_images : 0;
+ pipe->set_shader_images(pipe, shader_type, 0, num_images, unbind_slots,
+ images);
st->state.num_images[shader_type] = num_images;
}
image.u.buf.size = (addr.last_element - addr.first_element + 1) *
addr.bytes_per_pixel;
- pipe->set_shader_images(pipe, PIPE_SHADER_FRAGMENT, 0, 1, &image);
+ pipe->set_shader_images(pipe, PIPE_SHADER_FRAGMENT, 0, 1, 0, &image);
}
/* Set up no-attachment framebuffer */
st->state.num_sampler_views[PIPE_SHADER_FRAGMENT],
null);
st->state.num_sampler_views[PIPE_SHADER_FRAGMENT] = 0;
- pipe->set_shader_images(pipe, PIPE_SHADER_FRAGMENT, 0, 1, NULL);
+ pipe->set_shader_images(pipe, PIPE_SHADER_FRAGMENT, 0, 0, 1, NULL);
st->dirty |= ST_NEW_FS_CONSTANTS |
ST_NEW_FS_IMAGES |