ctx->dirty |= FD_DIRTY_SAMPLE_MASK;
}
+static void
+fd_set_min_samples(struct pipe_context *pctx, unsigned min_samples)
+{
+ struct fd_context *ctx = fd_context(pctx);
+ ctx->min_samples = min_samples;
+ ctx->dirty |= FD_DIRTY_MIN_SAMPLES;
+}
+
/* notes from calim on #dri-devel:
* index==0 will be non-UBO (ie. glUniformXYZ()) all packed together padded
* out to vec4's
util_copy_constant_buffer(&so->cb[index], cb);
- /* Note that the state tracker can unbind constant buffers by
+ /* Note that gallium frontends can unbind constant buffers by
* passing NULL here.
*/
if (unlikely(!cb)) {
so->enabled_mask |= 1 << index;
ctx->dirty_shader[shader] |= FD_DIRTY_SHADER_CONST;
ctx->dirty |= FD_DIRTY_CONST;
+
+ fd_resource_set_usage(cb->buffer, FD_DIRTY_CONST);
}
static void
{
struct fd_context *ctx = fd_context(pctx);
struct fd_shaderbuf_stateobj *so = &ctx->shaderbuf[shader];
- unsigned mask = 0;
+ const unsigned modified_bits = u_bit_consecutive(start, count);
- if (buffers) {
- for (unsigned i = 0; i < count; i++) {
- unsigned n = i + start;
- struct pipe_shader_buffer *buf = &so->sb[n];
+ so->enabled_mask &= ~modified_bits;
+ so->writable_mask &= ~modified_bits;
+ so->writable_mask |= writable_bitmask << start;
+ for (unsigned i = 0; i < count; i++) {
+ unsigned n = i + start;
+ struct pipe_shader_buffer *buf = &so->sb[n];
+
+ if (buffers && buffers[i].buffer) {
if ((buf->buffer == buffers[i].buffer) &&
(buf->buffer_offset == buffers[i].buffer_offset) &&
(buf->buffer_size == buffers[i].buffer_size))
continue;
- mask |= BIT(n);
-
buf->buffer_offset = buffers[i].buffer_offset;
buf->buffer_size = buffers[i].buffer_size;
pipe_resource_reference(&buf->buffer, buffers[i].buffer);
- if (buf->buffer)
- so->enabled_mask |= BIT(n);
- else
- so->enabled_mask &= ~BIT(n);
- }
- } else {
- mask = (BIT(count) - 1) << start;
-
- for (unsigned i = 0; i < count; i++) {
- unsigned n = i + start;
- struct pipe_shader_buffer *buf = &so->sb[n];
+ fd_resource_set_usage(buffers[i].buffer, FD_DIRTY_SSBO);
+ so->enabled_mask |= BIT(n);
+ } else {
pipe_resource_reference(&buf->buffer, NULL);
}
-
- so->enabled_mask &= ~mask;
}
ctx->dirty_shader[shader] |= FD_DIRTY_SHADER_SSBO;
+ ctx->dirty |= FD_DIRTY_SSBO;
}
-static void
+void
fd_set_shader_images(struct pipe_context *pctx,
enum pipe_shader_type shader,
unsigned start, unsigned count,
mask |= BIT(n);
util_copy_image_view(buf, &images[i]);
- if (buf->resource)
+ if (buf->resource) {
+ fd_resource_set_usage(buf->resource, FD_DIRTY_IMAGE);
so->enabled_mask |= BIT(n);
- else
+ } else {
so->enabled_mask &= ~BIT(n);
+ }
}
} else {
mask = (BIT(count) - 1) << start;
}
ctx->dirty_shader[shader] |= FD_DIRTY_SHADER_IMAGE;
+ ctx->dirty |= FD_DIRTY_IMAGE;
}
static void
framebuffer->width, framebuffer->height,
framebuffer->layers, framebuffer->samples);
+ fd_context_switch_from(ctx);
+
cso = &ctx->framebuffer;
if (util_framebuffer_state_equal(cso, framebuffer))
* multiple times to the same surface), so we might as
* well go ahead and flush this one:
*/
- fd_batch_flush(old_batch, false, false);
+ fd_batch_flush(old_batch);
}
fd_batch_reference(&old_batch, NULL);
- } else {
+ } else if (ctx->batch) {
DBG("%d: cbufs[0]=%p, zsbuf=%p", ctx->batch->needs_flush,
framebuffer->cbufs[0], framebuffer->zsbuf);
- fd_batch_flush(ctx->batch, false, false);
- util_copy_framebuffer_state(&ctx->batch->framebuffer, cso);
+ fd_batch_flush(ctx->batch);
}
ctx->dirty |= FD_DIRTY_FRAMEBUFFER;
util_set_vertex_buffers_mask(so->vb, &so->enabled_mask, vb, start_slot, count);
so->count = util_last_bit(so->enabled_mask);
+ if (!vb)
+ return;
+
ctx->dirty |= FD_DIRTY_VTXBUF;
+
+ for (unsigned i = 0; i < count; i++) {
+ assert(!vb[i].is_user_buffer);
+ fd_resource_set_usage(vb[i].buffer.resource, FD_DIRTY_VTXBUF);
+ }
}
static void
{
struct fd_context *ctx = fd_context(pctx);
struct pipe_scissor_state *old_scissor = fd_context_get_scissor(ctx);
+ bool discard = ctx->rasterizer && ctx->rasterizer->rasterizer_discard;
ctx->rasterizer = hwcso;
ctx->dirty |= FD_DIRTY_RASTERIZER;
+ if (ctx->rasterizer && ctx->rasterizer->scissor) {
+ ctx->current_scissor = &ctx->scissor;
+ } else {
+ ctx->current_scissor = &ctx->disabled_scissor;
+ }
+
/* if scissor enable bit changed we need to mark scissor
* state as dirty as well:
* NOTE: we can do a shallow compare, since we only care
*/
if (old_scissor != fd_context_get_scissor(ctx))
ctx->dirty |= FD_DIRTY_SCISSOR;
+
+ if (ctx->rasterizer && (discard != ctx->rasterizer->rasterizer_discard))
+ ctx->dirty |= FD_DIRTY_RASTERIZER_DISCARD;
}
static void
target->buffer_size = buffer_size;
assert(rsc->base.target == PIPE_BUFFER);
- util_range_add(&rsc->valid_buffer_range,
+ util_range_add(&rsc->base, &rsc->valid_buffer_range,
buffer_offset, buffer_offset + buffer_size);
return target;
for (i = 0; i < num_targets; i++) {
boolean changed = targets[i] != so->targets[i];
- boolean append = (offsets[i] == (unsigned)-1);
+ boolean reset = (offsets[i] != (unsigned)-1);
+
+ so->reset |= (reset << i);
- if (!changed && append)
+ if (!changed && !reset)
continue;
- if (!append)
+ if (reset)
so->offsets[i] = offsets[i];
pipe_so_target_reference(&so->targets[i], targets[i]);
for (unsigned i = 0; i < count; i++) {
unsigned n = i + first;
- if (so->buf[n]) {
- struct fd_resource *rsc = fd_resource(so->buf[n]);
- fd_bo_put_iova(rsc->bo);
- }
pipe_resource_reference(&so->buf[n], NULL);
}
pctx->set_stencil_ref = fd_set_stencil_ref;
pctx->set_clip_state = fd_set_clip_state;
pctx->set_sample_mask = fd_set_sample_mask;
+ pctx->set_min_samples = fd_set_min_samples;
pctx->set_constant_buffer = fd_set_constant_buffer;
pctx->set_shader_buffers = fd_set_shader_buffers;
pctx->set_shader_images = fd_set_shader_images;
pctx->bind_depth_stencil_alpha_state = fd_zsa_state_bind;
pctx->delete_depth_stencil_alpha_state = fd_zsa_state_delete;
- pctx->create_vertex_elements_state = fd_vertex_state_create;
+ if (!pctx->create_vertex_elements_state)
+ pctx->create_vertex_elements_state = fd_vertex_state_create;
pctx->delete_vertex_elements_state = fd_vertex_state_delete;
pctx->bind_vertex_elements_state = fd_vertex_state_bind;
projects / mesa.git / blobdiff