fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-03-19 07:50:37 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

gallium: remove start_slot parameter from pipe_context::set_vertex_buffers

Browse source 
This patch removes start_slot from set_vertex_buffers() as suggested in
https://gitlab.freedesktop.org/mesa/mesa/-/issues/8142

compilation testing:
all gallium drivers, nine frontend compilation has been tested.
d3d10umd compilation has not been tested

driver, frontend testing:
only llvmpipe and radeonsi driver was tested running game

only the nine frontend changes are complex. All other changes are easy.
nine front end was using start slot and also using multi context.

nine frontend code changes:
In update_vertex_elements() and update_vertex_buffers(), the vertex
buffers or streams are ordered removing the holes. In update_vertex_elements()
the vertex_buffer_index is updated for pipe driver to match the ordered list.

v2: remove start_slot usage code from Marek (Marek Olšák)
v3: nine stream number holes mask code from Axel (Axel Davy)

Reviewed-by: Mike Blumenkrantz <michael.blumenkrantz@gmail.com> (except nine, which is Ab)
Reviewed-by: Marek Olšák <marek.olsak@amd.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/22436>
This commit is contained in:
Yogesh Mohan Marimuthu 2023-04-12 11:13:18 +05:30 • committed by Marge Bot
parent e0da62c0e9
commit 973e6f3be0
67 changed files with 345 additions and 310 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
src/gallium/auxiliary/cso_cache/cso_context.c
View file

@ -1259,7 +1259,7 @@ cso_restore_vertex_elements(struct cso_context *ctx)
void
cso_set_vertex_buffers(struct cso_context *ctx,
unsigned start_slot, unsigned count,
unsigned count,
unsigned unbind_trailing_count,
bool take_ownership,
const struct pipe_vertex_buffer *buffers)
@ -1270,13 +1270,13 @@ cso_set_vertex_buffers(struct cso_context *ctx,
return;
if (vbuf) {
u_vbuf_set_vertex_buffers(vbuf, start_slot, count, unbind_trailing_count,
u_vbuf_set_vertex_buffers(vbuf, count, unbind_trailing_count,
take_ownership, buffers);
return;
}
struct pipe_context *pipe = ctx->base.pipe;
pipe->set_vertex_buffers(pipe, start_slot, count, unbind_trailing_count,
pipe->set_vertex_buffers(pipe, count, unbind_trailing_count,
take_ownership, buffers);
}
@ -1310,7 +1310,7 @@ cso_set_vertex_buffers_and_elements(struct cso_context *ctx,
/* Unbind all buffers in cso_context, because we'll use u_vbuf. */
unsigned unbind_vb_count = vb_count + unbind_trailing_vb_count;
if (unbind_vb_count)
pipe->set_vertex_buffers(pipe, 0, 0, unbind_vb_count, false, NULL);
pipe->set_vertex_buffers(pipe, 0, unbind_vb_count, false, NULL);
/* Unset this to make sure the CSO is re-bound on the next use. */
ctx->velements = NULL;
@ -1321,7 +1321,7 @@ cso_set_vertex_buffers_and_elements(struct cso_context *ctx,
}
if (vb_count || unbind_trailing_vb_count) {
u_vbuf_set_vertex_buffers(vbuf, 0, vb_count,
u_vbuf_set_vertex_buffers(vbuf, vb_count,
unbind_trailing_vb_count,
take_ownership, vbuffers);
}
@ -1333,7 +1333,7 @@ cso_set_vertex_buffers_and_elements(struct cso_context *ctx,
/* Unbind all buffers in u_vbuf, because we'll use cso_context. */
unsigned unbind_vb_count = vb_count + unbind_trailing_vb_count;
if (unbind_vb_count)
u_vbuf_set_vertex_buffers(vbuf, 0, 0, unbind_vb_count, false, NULL);
u_vbuf_set_vertex_buffers(vbuf, 0, unbind_vb_count, false, NULL);
/* Unset this to make sure the CSO is re-bound on the next use. */
u_vbuf_unset_vertex_elements(vbuf);
@ -1344,7 +1344,7 @@ cso_set_vertex_buffers_and_elements(struct cso_context *ctx,
}
if (vb_count || unbind_trailing_vb_count) {
pipe->set_vertex_buffers(pipe, 0, vb_count, unbind_trailing_vb_count,
pipe->set_vertex_buffers(pipe, vb_count, unbind_trailing_vb_count,
take_ownership, vbuffers);
}
cso_set_vertex_elements_direct(ctx, velems);
@ -1730,7 +1730,7 @@ cso_restore_state(struct cso_context *cso, unsigned unbind)
if (state_mask & CSO_BIT_VERTEX_ELEMENTS)
cso_restore_vertex_elements(cso);
if (unbind & CSO_UNBIND_VERTEX_BUFFER0)
cso->base.pipe->set_vertex_buffers(cso->base.pipe, 0, 0, 1, false, NULL);
cso->base.pipe->set_vertex_buffers(cso->base.pipe, 0, 1, false, NULL);
if (state_mask & CSO_BIT_STREAM_OUTPUTS)
cso_restore_stream_outputs(cso);
if (state_mask & CSO_BIT_PAUSE_QUERIES)

2
src/gallium/auxiliary/cso_cache/cso_context.h
View file

@ -102,7 +102,7 @@ cso_set_vertex_elements(struct cso_context *ctx,
const struct cso_velems_state *velems);
void cso_set_vertex_buffers(struct cso_context *ctx,
unsigned start_slot, unsigned count,
unsigned count,
unsigned unbind_trailing_count,
bool take_ownership,
const struct pipe_vertex_buffer *buffers);

6
src/gallium/auxiliary/draw/draw_context.c
View file

@ -404,15 +404,15 @@ draw_set_viewport_states(struct draw_context *draw,
void
draw_set_vertex_buffers(struct draw_context *draw,
unsigned start_slot, unsigned count,
unsigned count,
unsigned unbind_num_trailing_slots,
const struct pipe_vertex_buffer *buffers)
{
assert(start_slot + count <= PIPE_MAX_ATTRIBS);
assert(count <= PIPE_MAX_ATTRIBS);
util_set_vertex_buffers_count(draw->pt.vertex_buffer,
&draw->pt.nr_vertex_buffers,
buffers, start_slot, count,
buffers, count,
unbind_num_trailing_slots, false);
}

2
src/gallium/auxiliary/draw/draw_context.h
View file

@ -320,7 +320,7 @@ void draw_delete_mesh_shader(struct draw_context *draw,
*/
void draw_set_vertex_buffers(struct draw_context *draw,
unsigned start_slot, unsigned count,
unsigned count,
unsigned unbind_num_trailing_slots,
const struct pipe_vertex_buffer *buffers);

8
src/gallium/auxiliary/driver_ddebug/dd_context.c
View file

@ -570,7 +570,7 @@ dd_context_set_shader_buffers(struct pipe_context *_pipe,
static void
dd_context_set_vertex_buffers(struct pipe_context *_pipe,
unsigned start, unsigned num_buffers,
unsigned num_buffers,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *buffers)
@ -578,11 +578,11 @@ dd_context_set_vertex_buffers(struct pipe_context *_pipe,
struct dd_context *dctx = dd_context(_pipe);
struct pipe_context *pipe = dctx->pipe;
safe_memcpy(&dctx->draw_state.vertex_buffers[start], buffers,
safe_memcpy(&dctx->draw_state.vertex_buffers[0], buffers,
sizeof(buffers[0]) * num_buffers);
safe_memcpy(&dctx->draw_state.vertex_buffers[start + num_buffers], NULL,
safe_memcpy(&dctx->draw_state.vertex_buffers[num_buffers], NULL,
sizeof(buffers[0]) * unbind_num_trailing_slots);
pipe->set_vertex_buffers(pipe, start, num_buffers,
pipe->set_vertex_buffers(pipe, num_buffers,
unbind_num_trailing_slots, take_ownership,
buffers);
}

2
src/gallium/auxiliary/driver_noop/noop_state.c
View file

@ -214,7 +214,7 @@ static void noop_delete_state(struct pipe_context *ctx, void *state)
}
static void noop_set_vertex_buffers(struct pipe_context *ctx,
unsigned start_slot, unsigned count,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *buffers)

5
src/gallium/auxiliary/driver_trace/tr_context.c
View file

@ -1260,7 +1260,7 @@ trace_context_set_sampler_views(struct pipe_context *_pipe,
static void
trace_context_set_vertex_buffers(struct pipe_context *_pipe,
unsigned start_slot, unsigned num_buffers,
unsigned num_buffers,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *buffers)
@ -1271,7 +1271,6 @@ trace_context_set_vertex_buffers(struct pipe_context *_pipe,
trace_dump_call_begin("pipe_context", "set_vertex_buffers");
trace_dump_arg(ptr, pipe);
trace_dump_arg(uint, start_slot);
trace_dump_arg(uint, num_buffers);
trace_dump_arg(uint, unbind_num_trailing_slots);
trace_dump_arg(bool, take_ownership);
@ -1280,7 +1279,7 @@ trace_context_set_vertex_buffers(struct pipe_context *_pipe,
trace_dump_struct_array(vertex_buffer, buffers, num_buffers);
trace_dump_arg_end();
pipe->set_vertex_buffers(pipe, start_slot, num_buffers,
pipe->set_vertex_buffers(pipe, num_buffers,
unbind_num_trailing_slots, take_ownership,
buffers);

8
src/gallium/auxiliary/hud/hud_context.c
View file

@ -113,7 +113,7 @@ hud_draw_colored_prims(struct hud_context *hud, unsigned prim,
u_upload_unmap(hud->pipe->stream_uploader);
vbuffer.stride = 2 * sizeof(float);
cso_set_vertex_buffers(cso, 0, 1, 0, false, &vbuffer);
cso_set_vertex_buffers(cso, 1, 0, false, &vbuffer);
pipe_resource_reference(&vbuffer.buffer.resource, NULL);
cso_set_fragment_shader_handle(hud->cso, hud->fs_color);
cso_draw_arrays(cso, prim, 0, num_vertices);
@ -603,7 +603,7 @@ hud_draw_results(struct hud_context *hud, struct pipe_resource *tex)
pipe->set_constant_buffer(pipe, PIPE_SHADER_VERTEX, 0, false, &hud->constbuf);
cso_set_vertex_buffers(cso, 0, 1, 0, false, &hud->bg.vbuf);
cso_set_vertex_buffers(cso, 1, 0, false, &hud->bg.vbuf);
cso_draw_arrays(cso, MESA_PRIM_QUADS, 0, hud->bg.num_vertices);
}
pipe_resource_reference(&hud->bg.vbuf.buffer.resource, NULL);
@ -611,7 +611,7 @@ hud_draw_results(struct hud_context *hud, struct pipe_resource *tex)
/* draw accumulated vertices for text */
if (hud->text.num_vertices) {
cso_set_vertex_shader_handle(cso, hud->vs_text);
cso_set_vertex_buffers(cso, 0, 1, 0, false, &hud->text.vbuf);
cso_set_vertex_buffers(cso, 1, 0, false, &hud->text.vbuf);
cso_set_fragment_shader_handle(hud->cso, hud->fs_text);
cso_draw_arrays(cso, MESA_PRIM_QUADS, 0, hud->text.num_vertices);
}
@ -635,7 +635,7 @@ hud_draw_results(struct hud_context *hud, struct pipe_resource *tex)
if (hud->whitelines.num_vertices) {
cso_set_vertex_shader_handle(cso, hud->vs_color);
cso_set_vertex_buffers(cso, 0, 1, 0, false, &hud->whitelines.vbuf);
cso_set_vertex_buffers(cso, 1, 0, false, &hud->whitelines.vbuf);
cso_set_fragment_shader_handle(hud->cso, hud->fs_color);
cso_draw_arrays(cso, MESA_PRIM_LINES, 0, hud->whitelines.num_vertices);
}

2
src/gallium/auxiliary/postprocess/pp_run.c
View file

@ -293,7 +293,7 @@ pp_filter_misc_state(struct pp_program *p)
void
pp_filter_draw(struct pp_program *p)
{
util_draw_vertex_buffer(p->pipe, p->cso, p->vbuf, 0, 0,
util_draw_vertex_buffer(p->pipe, p->cso, p->vbuf, 0,
MESA_PRIM_QUADS, 4, 2);
}

11
src/gallium/auxiliary/util/u_blitter.c
View file

@ -315,14 +315,13 @@ struct blitter_context *util_blitter_create(struct pipe_context *pipe)
}
ctx->base.cb_slot = 0; /* 0 for now */
ctx->base.vb_slot = 0; /* 0 for now */
/* vertex elements states */
memset(&velem[0], 0, sizeof(velem[0]) * 2);
for (i = 0; i < 2; i++) {
velem[i].src_offset = i * 4 * sizeof(float);
velem[i].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
velem[i].vertex_buffer_index = ctx->base.vb_slot;
velem[i].vertex_buffer_index = 0;
}
ctx->velem_state = pipe->create_vertex_elements_state(pipe, 2, &velem[0]);
@ -336,7 +335,7 @@ struct blitter_context *util_blitter_create(struct pipe_context *pipe)
for (i = 0; i < 4; i++) {
velem[0].src_format = formats[i];
velem[0].vertex_buffer_index = ctx->base.vb_slot;
velem[0].vertex_buffer_index = 0;
ctx->velem_state_readbuf[i] =
pipe->create_vertex_elements_state(pipe, 1, &velem[0]);
}
@ -643,7 +642,7 @@ void util_blitter_restore_vertex_states(struct blitter_context *blitter)
/* Vertex buffer. */
if (ctx->base.saved_vertex_buffer.buffer.resource) {
pipe->set_vertex_buffers(pipe, ctx->base.vb_slot, 1, 0, true,
pipe->set_vertex_buffers(pipe, 1, 0, true,
&ctx->base.saved_vertex_buffer);
ctx->base.saved_vertex_buffer.buffer.resource = NULL;
}
@ -1410,7 +1409,7 @@ static void blitter_draw(struct blitter_context_priv *ctx,
return;
u_upload_unmap(pipe->stream_uploader);
pipe->set_vertex_buffers(pipe, ctx->base.vb_slot, 1, 0, false, &vb);
pipe->set_vertex_buffers(pipe, 1, 0, false, &vb);
pipe->bind_vertex_elements_state(pipe, vertex_elements_cso);
pipe->bind_vs_state(pipe, get_vs(&ctx->base));
@ -2634,7 +2633,7 @@ void util_blitter_clear_buffer(struct blitter_context *blitter,
blitter_check_saved_vertex_states(ctx);
blitter_disable_render_cond(ctx);
pipe->set_vertex_buffers(pipe, ctx->base.vb_slot, 1, 0, false, &vb);
pipe->set_vertex_buffers(pipe, 1, 0, false, &vb);
pipe->bind_vertex_elements_state(pipe,
ctx->velem_state_readbuf[num_channels-1]);
bind_vs_pos_only(ctx, num_channels);

3
src/gallium/auxiliary/util/u_blitter.h
View file

@ -129,7 +129,6 @@ struct blitter_context
unsigned cb_slot;
struct pipe_constant_buffer saved_fs_constant_buffer;
unsigned vb_slot;
struct pipe_vertex_buffer saved_vertex_buffer;
unsigned saved_num_so_targets;
@ -537,7 +536,7 @@ util_blitter_save_vertex_buffer_slot(struct blitter_context *blitter,
struct pipe_vertex_buffer *vertex_buffers)
{
pipe_vertex_buffer_reference(&blitter->saved_vertex_buffer,
&vertex_buffers[blitter->vb_slot]);
&vertex_buffers[0]);
}
static inline void

7
src/gallium/auxiliary/util/u_draw_quad.c
View file

@ -42,7 +42,6 @@ void
util_draw_vertex_buffer(struct pipe_context *pipe,
struct cso_context *cso,
struct pipe_resource *vbuf,
unsigned vbuf_slot,
unsigned offset,
enum mesa_prim prim_type,
unsigned num_verts,
@ -61,10 +60,10 @@ util_draw_vertex_buffer(struct pipe_context *pipe,
/* note: vertex elements already set by caller */
if (cso) {
cso_set_vertex_buffers(cso, vbuf_slot, 1, 0, false, &vbuffer);
cso_set_vertex_buffers(cso, 1, 0, false, &vbuffer);
cso_draw_arrays(cso, prim_type, 0, num_verts);
} else {
pipe->set_vertex_buffers(pipe, vbuf_slot, 1, 0, false, &vbuffer);
pipe->set_vertex_buffers(pipe, 1, 0, false, &vbuffer);
util_draw_arrays(pipe, prim_type, 0, num_verts);
}
}
@ -89,6 +88,6 @@ util_draw_user_vertex_buffer(struct cso_context *cso, void *buffer,
/* note: vertex elements already set by caller */
cso_set_vertex_buffers(cso, 0, 1, 0, false, &vbuffer);
cso_set_vertex_buffers(cso, 1, 0, false, &vbuffer);
cso_draw_arrays(cso, prim_type, 0, num_verts);
}

8
src/gallium/auxiliary/util/u_draw_quad.h
View file

@ -41,11 +41,11 @@ extern "C" {
struct pipe_resource;
struct cso_context;
extern void
extern void
util_draw_vertex_buffer(struct pipe_context *pipe, struct cso_context *cso,
struct pipe_resource *vbuf, unsigned vbuf_slot,
unsigned offset, enum mesa_prim prim_type,
unsigned num_attribs, unsigned num_verts);
struct pipe_resource *vbuf, unsigned offset,
enum mesa_prim prim_type, unsigned num_attribs,
unsigned num_verts);
void
util_draw_user_vertex_buffer(struct cso_context *cso, void *buffer,

12
src/gallium/auxiliary/util/u_helpers.c
View file

@ -47,16 +47,14 @@
void util_set_vertex_buffers_mask(struct pipe_vertex_buffer *dst,
uint32_t *enabled_buffers,
const struct pipe_vertex_buffer *src,
unsigned start_slot, unsigned count,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership)
{
unsigned i;
uint32_t bitmask = 0;
dst += start_slot;
*enabled_buffers &= ~u_bit_consecutive(start_slot, count);
*enabled_buffers &= ~BITFIELD_MASK(count);
if (src) {
for (i = 0; i < count; i++) {
@ -72,7 +70,7 @@ void util_set_vertex_buffers_mask(struct pipe_vertex_buffer *dst,
/* Copy over the other members of pipe_vertex_buffer. */
memcpy(dst, src, count * sizeof(struct pipe_vertex_buffer));
*enabled_buffers |= bitmask << start_slot;
*enabled_buffers |= bitmask;
}
else {
/* Unreference the buffers. */
@ -91,7 +89,7 @@ void util_set_vertex_buffers_mask(struct pipe_vertex_buffer *dst,
void util_set_vertex_buffers_count(struct pipe_vertex_buffer *dst,
unsigned *dst_count,
const struct pipe_vertex_buffer *src,
unsigned start_slot, unsigned count,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership)
{
@ -103,7 +101,7 @@ void util_set_vertex_buffers_count(struct pipe_vertex_buffer *dst,
enabled_buffers |= (1ull << i);
}
util_set_vertex_buffers_mask(dst, &enabled_buffers, src, start_slot,
util_set_vertex_buffers_mask(dst, &enabled_buffers, src,
count, unbind_num_trailing_slots,
take_ownership);

4
src/gallium/auxiliary/util/u_helpers.h
View file

@ -40,14 +40,14 @@ extern "C" {
void util_set_vertex_buffers_mask(struct pipe_vertex_buffer *dst,
uint32_t *enabled_buffers,
const struct pipe_vertex_buffer *src,
unsigned start_slot, unsigned count,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership);
void util_set_vertex_buffers_count(struct pipe_vertex_buffer *dst,
unsigned *dst_count,
const struct pipe_vertex_buffer *src,
unsigned start_slot, unsigned count,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership);

24
src/gallium/auxiliary/util/u_threaded_context.c
View file

@ -2039,7 +2039,7 @@ tc_set_shader_buffers(struct pipe_context *_pipe,
struct tc_vertex_buffers {
struct tc_call_base base;
uint8_t start, count;
uint8_t count;
uint8_t unbind_num_trailing_slots;
struct pipe_vertex_buffer slot[0]; /* more will be allocated if needed */
};
@ -2051,22 +2051,20 @@ tc_call_set_vertex_buffers(struct pipe_context *pipe, void *call, uint64_t *last
unsigned count = p->count;
if (!count) {
pipe->set_vertex_buffers(pipe, p->start, 0,
p->unbind_num_trailing_slots, false, NULL);
pipe->set_vertex_buffers(pipe, 0, p->unbind_num_trailing_slots, false, NULL);
return call_size(tc_vertex_buffers);
}
for (unsigned i = 0; i < count; i++)
tc_assert(!p->slot[i].is_user_buffer);
pipe->set_vertex_buffers(pipe, p->start, count,
p->unbind_num_trailing_slots, true, p->slot);
pipe->set_vertex_buffers(pipe, count, p->unbind_num_trailing_slots, true, p->slot);
return p->base.num_slots;
}
static void
tc_set_vertex_buffers(struct pipe_context *_pipe,
unsigned start, unsigned count,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *buffers)
@ -2079,7 +2077,6 @@ tc_set_vertex_buffers(struct pipe_context *_pipe,
if (count && buffers) {
struct tc_vertex_buffers *p =
tc_add_slot_based_call(tc, TC_CALL_set_vertex_buffers, tc_vertex_buffers, count);
p->start = start;
p->count = count;
p->unbind_num_trailing_slots = unbind_num_trailing_slots;
@ -2092,9 +2089,9 @@ tc_set_vertex_buffers(struct pipe_context *_pipe,
struct pipe_resource *buf = buffers[i].buffer.resource;
if (buf) {
tc_bind_buffer(tc, &tc->vertex_buffers[start + i], next, buf);
tc_bind_buffer(tc, &tc->vertex_buffers[i], next, buf);
} else {
tc_unbind_buffer(&tc->vertex_buffers[start + i]);
tc_unbind_buffer(&tc->vertex_buffers[i]);
}
}
} else {
@ -2110,23 +2107,22 @@ tc_set_vertex_buffers(struct pipe_context *_pipe,
dst->buffer_offset = src->buffer_offset;
if (buf) {
tc_bind_buffer(tc, &tc->vertex_buffers[start + i], next, buf);
tc_bind_buffer(tc, &tc->vertex_buffers[i], next, buf);
} else {
tc_unbind_buffer(&tc->vertex_buffers[start + i]);
tc_unbind_buffer(&tc->vertex_buffers[i]);
}
}
}
tc_unbind_buffers(&tc->vertex_buffers[start + count],
tc_unbind_buffers(&tc->vertex_buffers[count],
unbind_num_trailing_slots);
} else {
struct tc_vertex_buffers *p =
tc_add_slot_based_call(tc, TC_CALL_set_vertex_buffers, tc_vertex_buffers, 0);
p->start = start;
p->count = 0;
p->unbind_num_trailing_slots = count + unbind_num_trailing_slots;
tc_unbind_buffers(&tc->vertex_buffers[start],
tc_unbind_buffers(&tc->vertex_buffers[0],
count + unbind_num_trailing_slots);
}
}

31
src/gallium/auxiliary/util/u_vbuf.c
View file

@ -440,7 +440,7 @@ void u_vbuf_destroy(struct u_vbuf *mgr)
const unsigned num_vb = screen->get_shader_param(screen, PIPE_SHADER_VERTEX,
PIPE_SHADER_CAP_MAX_INPUTS);
mgr->pipe->set_vertex_buffers(mgr->pipe, 0, 0, num_vb, false, NULL);
mgr->pipe->set_vertex_buffers(mgr->pipe, 0, num_vb, false, NULL);
for (i = 0; i < PIPE_MAX_ATTRIBS; i++)
pipe_vertex_buffer_unreference(&mgr->vertex_buffer[i]);
@ -973,7 +973,7 @@ static void u_vbuf_delete_vertex_elements(void *ctx, void *state,
}
void u_vbuf_set_vertex_buffers(struct u_vbuf *mgr,
unsigned start_slot, unsigned count,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *bufs)
@ -989,8 +989,7 @@ void u_vbuf_set_vertex_buffers(struct u_vbuf *mgr,
uint32_t nonzero_stride_vb_mask = 0;
/* which buffers are unaligned to 2/4 bytes */
uint32_t unaligned_vb_mask[2] = {0};
uint32_t mask =
~(((1ull << (count + unbind_num_trailing_slots)) - 1) << start_slot);
uint32_t mask = ~BITFIELD64_MASK(count + unbind_num_trailing_slots);
if (!bufs) {
struct pipe_context *pipe = mgr->pipe;
@ -1007,19 +1006,18 @@ void u_vbuf_set_vertex_buffers(struct u_vbuf *mgr,
mgr->unaligned_vb_mask[1] &= mask;
for (i = 0; i < total_count; i++) {
unsigned dst_index = start_slot + i;
unsigned dst_index = i;
pipe_vertex_buffer_unreference(&mgr->vertex_buffer[dst_index]);
pipe_vertex_buffer_unreference(&mgr->real_vertex_buffer[dst_index]);
}
pipe->set_vertex_buffers(pipe, start_slot, count,
unbind_num_trailing_slots, false, NULL);
pipe->set_vertex_buffers(pipe, count, unbind_num_trailing_slots, false, NULL);
return;
}
for (i = 0; i < count; i++) {
unsigned dst_index = start_slot + i;
unsigned dst_index = i;
const struct pipe_vertex_buffer *vb = &bufs[i];
struct pipe_vertex_buffer *orig_vb = &mgr->vertex_buffer[dst_index];
struct pipe_vertex_buffer *real_vb = &mgr->real_vertex_buffer[dst_index];
@ -1087,7 +1085,7 @@ void u_vbuf_set_vertex_buffers(struct u_vbuf *mgr,
}
for (i = 0; i < unbind_num_trailing_slots; i++) {
unsigned dst_index = start_slot + count + i;
unsigned dst_index = count + i;
pipe_vertex_buffer_unreference(&mgr->vertex_buffer[dst_index]);
pipe_vertex_buffer_unreference(&mgr->real_vertex_buffer[dst_index]);
@ -1399,10 +1397,7 @@ void u_vbuf_get_minmax_index(struct pipe_context *pipe,
static void u_vbuf_set_driver_vertex_buffers(struct u_vbuf *mgr)
{
struct pipe_context *pipe = mgr->pipe;
unsigned start_slot, count;
start_slot = ffs(mgr->dirty_real_vb_mask) - 1;
count = util_last_bit(mgr->dirty_real_vb_mask >> start_slot);
unsigned count = util_last_bit(mgr->dirty_real_vb_mask);
if (mgr->dirty_real_vb_mask == mgr->enabled_vb_mask &&
mgr->dirty_real_vb_mask == mgr->user_vb_mask) {
@ -1410,18 +1405,16 @@ static void u_vbuf_set_driver_vertex_buffers(struct u_vbuf *mgr)
* to skip atomic reference counting there. These are freshly uploaded
* user buffers that can be discarded after this call.
*/
pipe->set_vertex_buffers(pipe, start_slot, count, 0, true,
mgr->real_vertex_buffer + start_slot);
pipe->set_vertex_buffers(pipe, count, 0, true, mgr->real_vertex_buffer);
/* We don't own the VBO references now. Set them to NULL. */
for (unsigned i = 0; i < count; i++) {
assert(!mgr->real_vertex_buffer[start_slot + i].is_user_buffer);
mgr->real_vertex_buffer[start_slot + i].buffer.resource = NULL;
assert(!mgr->real_vertex_buffer[i].is_user_buffer);
mgr->real_vertex_buffer[i].buffer.resource = NULL;
}
} else {
/* Slow path where we have to keep VBO references. */
pipe->set_vertex_buffers(pipe, start_slot, count, 0, false,
mgr->real_vertex_buffer + start_slot);
pipe->set_vertex_buffers(pipe, count, 0, false, mgr->real_vertex_buffer);
}
mgr->dirty_real_vb_mask = 0;
}

2
src/gallium/auxiliary/util/u_vbuf.h
View file

@ -81,7 +81,7 @@ void u_vbuf_set_vertex_elements(struct u_vbuf *mgr,
const struct cso_velems_state *velems);
void u_vbuf_unset_vertex_elements(struct u_vbuf *mgr);
void u_vbuf_set_vertex_buffers(struct u_vbuf *mgr,
unsigned start_slot, unsigned count,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *bufs);

2
src/gallium/auxiliary/vl/vl_bicubic_filter.c
View file

@ -460,7 +460,7 @@ vl_bicubic_filter_render(struct vl_bicubic_filter *filter,
filter->pipe->bind_fs_state(filter->pipe, filter->fs);
filter->pipe->set_framebuffer_state(filter->pipe, &fb_state);
filter->pipe->set_viewport_states(filter->pipe, 0, 1, &viewport);
filter->pipe->set_vertex_buffers(filter->pipe, 0, 1, 0, false, &filter->quad);
filter->pipe->set_vertex_buffers(filter->pipe, 1, 0, false, &filter->quad);
filter->pipe->bind_vertex_elements_state(filter->pipe, filter->ves);
util_draw_arrays(filter->pipe, MESA_PRIM_QUADS, 0, 4);

2
src/gallium/auxiliary/vl/vl_compositor_gfx.c
View file

@ -717,7 +717,7 @@ vl_compositor_gfx_render(struct vl_compositor_state *s,
c->pipe->set_framebuffer_state(c->pipe, &c->fb_state);
c->pipe->bind_vs_state(c->pipe, c->vs);
c->pipe->set_vertex_buffers(c->pipe, 0, 1, 0, false, &c->vertex_buf);
c->pipe->set_vertex_buffers(c->pipe, 1, 0, false, &c->vertex_buf);
c->pipe->bind_vertex_elements_state(c->pipe, c->vertex_elems_state);
pipe_set_constant_buffer(c->pipe, PIPE_SHADER_FRAGMENT, 0, s->shader_params);
c->pipe->bind_rasterizer_state(c->pipe, c->rast);

2
src/gallium/auxiliary/vl/vl_deint_filter.c
View file

@ -462,7 +462,7 @@ vl_deint_filter_render(struct vl_deint_filter *filter,
/* set up pipe state */
filter->pipe->bind_rasterizer_state(filter->pipe, filter->rs_state);
filter->pipe->set_vertex_buffers(filter->pipe, 0, 1, 0, false, &filter->quad);
filter->pipe->set_vertex_buffers(filter->pipe, 1, 0, false, &filter->quad);
filter->pipe->bind_vertex_elements_state(filter->pipe, filter->ves);
filter->pipe->bind_vs_state(filter->pipe, filter->vs);
filter->pipe->bind_sampler_states(filter->pipe, PIPE_SHADER_FRAGMENT,

2
src/gallium/auxiliary/vl/vl_matrix_filter.c
View file

@ -306,7 +306,7 @@ vl_matrix_filter_render(struct vl_matrix_filter *filter,
filter->pipe->bind_fs_state(filter->pipe, filter->fs);
filter->pipe->set_framebuffer_state(filter->pipe, &fb_state);
filter->pipe->set_viewport_states(filter->pipe, 0, 1, &viewport);
filter->pipe->set_vertex_buffers(filter->pipe, 0, 1, 0, false, &filter->quad);
filter->pipe->set_vertex_buffers(filter->pipe, 1, 0, false, &filter->quad);
filter->pipe->bind_vertex_elements_state(filter->pipe, filter->ves);
util_draw_arrays(filter->pipe, MESA_PRIM_QUADS, 0, 4);

2
src/gallium/auxiliary/vl/vl_median_filter.c
View file

@ -425,7 +425,7 @@ vl_median_filter_render(struct vl_median_filter *filter,
filter->pipe->bind_fs_state(filter->pipe, filter->fs);
filter->pipe->set_framebuffer_state(filter->pipe, &fb_state);
filter->pipe->set_viewport_states(filter->pipe, 0, 1, &viewport);
filter->pipe->set_vertex_buffers(filter->pipe, 0, 1, 0, false, &filter->quad);
filter->pipe->set_vertex_buffers(filter->pipe, 1, 0, false, &filter->quad);
filter->pipe->bind_vertex_elements_state(filter->pipe, filter->ves);
util_draw_arrays(filter->pipe, MESA_PRIM_QUADS, 0, 4);

6
src/gallium/auxiliary/vl/vl_mpeg12_decoder.c
View file

@ -794,7 +794,7 @@ vl_mpeg12_end_frame(struct pipe_video_codec *decoder,
if (!ref_frames[j] || !ref_frames[j][i]) continue;
vb[2] = vl_vb_get_mv(&buf->vertex_stream, j);
dec->context->set_vertex_buffers(dec->context, 0, 3, 0, false, vb);
dec->context->set_vertex_buffers(dec->context, 3, 0, false, vb);
vl_mc_render_ref(i ? &dec->mc_c : &dec->mc_y, &buf->mc[i], ref_frames[j][i]);
}
@ -805,7 +805,7 @@ vl_mpeg12_end_frame(struct pipe_video_codec *decoder,
if (!buf->num_ycbcr_blocks[i]) continue;
vb[1] = vl_vb_get_ycbcr(&buf->vertex_stream, i);
dec->context->set_vertex_buffers(dec->context, 0, 2, 0, false, vb);
dec->context->set_vertex_buffers(dec->context, 2, 0, false, vb);
vl_zscan_render(i ? &dec->zscan_c : & dec->zscan_y, &buf->zscan[i] , buf->num_ycbcr_blocks[i]);
@ -824,7 +824,7 @@ vl_mpeg12_end_frame(struct pipe_video_codec *decoder,
if (!buf->num_ycbcr_blocks[plane]) continue;
vb[1] = vl_vb_get_ycbcr(&buf->vertex_stream, plane);
dec->context->set_vertex_buffers(dec->context, 0, 2, 0, false, vb);
dec->context->set_vertex_buffers(dec->context, 2, 0, false, vb);
if (dec->base.entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT)
vl_idct_prepare_stage2(i ? &dec->idct_c : &dec->idct_y, &buf->idct[plane]);

7
src/gallium/drivers/asahi/agx_state.c
View file

@ -1334,15 +1334,14 @@ agx_delete_state(struct pipe_context *ctx, void *state)
/* BOs added to the batch in the uniform upload path */
static void
agx_set_vertex_buffers(struct pipe_context *pctx, unsigned start_slot,
unsigned count, unsigned unbind_num_trailing_slots,
bool take_ownership,
agx_set_vertex_buffers(struct pipe_context *pctx, unsigned count,
unsigned unbind_num_trailing_slots, bool take_ownership,
const struct pipe_vertex_buffer *buffers)
{
struct agx_context *ctx = agx_context(pctx);
util_set_vertex_buffers_mask(ctx->vertex_buffers, &ctx->vb_mask, buffers,
start_slot, count, unbind_num_trailing_slots,
count, unbind_num_trailing_slots,
take_ownership);
ctx->dirty |= AGX_DIRTY_VERTEX;

10
src/gallium/drivers/crocus/crocus_state.c
View file

@ -3658,7 +3658,7 @@ crocus_delete_state(struct pipe_context *ctx, void *state)
*/
static void
crocus_set_vertex_buffers(struct pipe_context *ctx,
unsigned start_slot, unsigned count,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *buffers)
@ -3668,15 +3668,15 @@ crocus_set_vertex_buffers(struct pipe_context *ctx,
const unsigned padding =
(GFX_VERx10 < 75 && screen->devinfo.platform != INTEL_PLATFORM_BYT) * 2;
ice->state.bound_vertex_buffers &=
~u_bit_consecutive64(start_slot, count + unbind_num_trailing_slots);
~u_bit_consecutive64(0, count + unbind_num_trailing_slots);
util_set_vertex_buffers_mask(ice->state.vertex_buffers, &ice->state.bound_vertex_buffers,
buffers, start_slot, count, unbind_num_trailing_slots,
buffers, count, unbind_num_trailing_slots,
take_ownership);
for (unsigned i = 0; i < count; i++) {
struct pipe_vertex_buffer *state =
&ice->state.vertex_buffers[start_slot + i];
&ice->state.vertex_buffers[i];
if (!state->is_user_buffer && state->buffer.resource) {
struct crocus_resource *res = (void *)state->buffer.resource;
@ -3686,7 +3686,7 @@ crocus_set_vertex_buffers(struct pipe_context *ctx,
uint32_t end = 0;
if (state->buffer.resource)
end = state->buffer.resource->width0 + padding;
ice->state.vb_end[start_slot + i] = end;
ice->state.vb_end[i] = end;
}
ice->state.dirty |= CROCUS_DIRTY_VERTEX_BUFFERS;
}

3
src/gallium/drivers/d3d12/d3d12_context.cpp
View file

@ -1309,7 +1309,6 @@ d3d12_set_polygon_stipple(struct pipe_context *pctx,
static void
d3d12_set_vertex_buffers(struct pipe_context *pctx,
unsigned start_slot,
unsigned num_buffers,
unsigned unbind_num_trailing_slots,
bool take_ownership,
@ -1317,7 +1316,7 @@ d3d12_set_vertex_buffers(struct pipe_context *pctx,
{
struct d3d12_context *ctx = d3d12_context(pctx);
util_set_vertex_buffers_count(ctx->vbs, &ctx->num_vbs,
buffers, start_slot, num_buffers,
buffers, num_buffers,
unbind_num_trailing_slots,
take_ownership);

8
src/gallium/drivers/etnaviv/etnaviv_state.c
View file

@ -450,19 +450,19 @@ etna_set_viewport_states(struct pipe_context *pctx, unsigned start_slot,
}
static void
etna_set_vertex_buffers(struct pipe_context *pctx, unsigned start_slot,
unsigned num_buffers, unsigned unbind_num_trailing_slots, bool take_ownership,
etna_set_vertex_buffers(struct pipe_context *pctx, unsigned num_buffers,
unsigned unbind_num_trailing_slots, bool take_ownership,
const struct pipe_vertex_buffer *vb)
{
struct etna_context *ctx = etna_context(pctx);
struct etna_vertexbuf_state *so = &ctx->vertex_buffer;
util_set_vertex_buffers_mask(so->vb, &so->enabled_mask, vb, start_slot,
util_set_vertex_buffers_mask(so->vb, &so->enabled_mask, vb,
num_buffers, unbind_num_trailing_slots,
take_ownership);
so->count = util_last_bit(so->enabled_mask);
for (unsigned idx = start_slot; idx < start_slot + num_buffers; ++idx) {
for (unsigned idx = 0; idx < num_buffers; ++idx) {
struct compiled_set_vertex_buffer *cs = &so->cvb[idx];
struct pipe_vertex_buffer *vbi = &so->vb[idx];

2
src/gallium/drivers/freedreno/freedreno_blitter.c
View file

@ -235,7 +235,7 @@ fd_blitter_clear(struct pipe_context *pctx, unsigned buffers,
pctx->set_viewport_states(pctx, 0, 1, &vp);
pctx->bind_vertex_elements_state(pctx, ctx->solid_vbuf_state.vtx);
pctx->set_vertex_buffers(pctx, blitter->vb_slot, 1, 0, false,
pctx->set_vertex_buffers(pctx, 1, 0, false,
&ctx->solid_vbuf_state.vertexbuf.vb[0]);
pctx->set_stream_output_targets(pctx, 0, NULL, NULL);

10
src/gallium/drivers/freedreno/freedreno_state.c
View file

@ -451,7 +451,7 @@ fd_set_viewport_states(struct pipe_context *pctx, unsigned start_slot,
}
static void
fd_set_vertex_buffers(struct pipe_context *pctx, unsigned start_slot,
fd_set_vertex_buffers(struct pipe_context *pctx,
unsigned count, unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *vb) in_dt
@ -467,9 +467,9 @@ fd_set_vertex_buffers(struct pipe_context *pctx, unsigned start_slot,
if (ctx->screen->gen < 3) {
for (i = 0; i < count; i++) {
bool new_enabled = vb && vb[i].buffer.resource;
bool old_enabled = so->vb[start_slot + i].buffer.resource != NULL;
bool old_enabled = so->vb[i].buffer.resource != NULL;
uint32_t new_stride = vb ? vb[i].stride : 0;
uint32_t old_stride = so->vb[start_slot + i].stride;
uint32_t old_stride = so->vb[i].stride;
if ((new_enabled != old_enabled) || (new_stride != old_stride)) {
fd_context_dirty(ctx, FD_DIRTY_VTXSTATE);
break;
@ -477,7 +477,7 @@ fd_set_vertex_buffers(struct pipe_context *pctx, unsigned start_slot,
}
}
util_set_vertex_buffers_mask(so->vb, &so->enabled_mask, vb, start_slot,
util_set_vertex_buffers_mask(so->vb, &so->enabled_mask, vb,
count, unbind_num_trailing_slots,
take_ownership);
so->count = util_last_bit(so->enabled_mask);
@ -497,7 +497,7 @@ fd_set_vertex_buffers(struct pipe_context *pctx, unsigned start_slot,
*/
if (vb[i].buffer.resource &&
unlikely(vb[i].buffer_offset >= vb[i].buffer.resource->width0)) {
so->vb[start_slot + i].buffer_offset = 0;
so->vb[i].buffer_offset = 0;
}
}
}

6
src/gallium/drivers/i915/i915_state.c
View file

@ -956,7 +956,7 @@ i915_delete_rasterizer_state(struct pipe_context *pipe, void *raster)
}
static void
i915_set_vertex_buffers(struct pipe_context *pipe, unsigned start_slot,
i915_set_vertex_buffers(struct pipe_context *pipe,
unsigned count, unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *buffers)
@ -965,11 +965,11 @@ i915_set_vertex_buffers(struct pipe_context *pipe, unsigned start_slot,
struct draw_context *draw = i915->draw;
util_set_vertex_buffers_count(i915->vertex_buffers, &i915->nr_vertex_buffers,
buffers, start_slot, count,
buffers, count,
unbind_num_trailing_slots, take_ownership);
/* pass-through to draw module */
draw_set_vertex_buffers(draw, start_slot, count, unbind_num_trailing_slots,
draw_set_vertex_buffers(draw, count, unbind_num_trailing_slots,
buffers);
}

12
src/gallium/drivers/iris/iris_state.c
View file

@ -3894,7 +3894,7 @@ iris_delete_state(struct pipe_context *ctx, void *state)
*/
static void
iris_set_vertex_buffers(struct pipe_context *ctx,
unsigned start_slot, unsigned count,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *buffers)
@ -3904,12 +3904,12 @@ iris_set_vertex_buffers(struct pipe_context *ctx,
struct iris_genx_state *genx = ice->state.genx;
ice->state.bound_vertex_buffers &=
~u_bit_consecutive64(start_slot, count + unbind_num_trailing_slots);
~u_bit_consecutive64(0, count + unbind_num_trailing_slots);
for (unsigned i = 0; i < count; i++) {
const struct pipe_vertex_buffer *buffer = buffers ? &buffers[i] : NULL;
struct iris_vertex_buffer_state *state =
&genx->vertex_buffers[start_slot + i];
&genx->vertex_buffers[i];
if (!buffer) {
pipe_resource_reference(&state->resource, NULL);
@ -3934,12 +3934,12 @@ iris_set_vertex_buffers(struct pipe_context *ctx,
state->offset = (int) buffer->buffer_offset;
if (res) {
ice->state.bound_vertex_buffers |= 1ull << (start_slot + i);
ice->state.bound_vertex_buffers |= 1ull << i;
res->bind_history |= PIPE_BIND_VERTEX_BUFFER;
}
iris_pack_state(GENX(VERTEX_BUFFER_STATE), state->state, vb) {
vb.VertexBufferIndex = start_slot + i;
vb.VertexBufferIndex = i;
vb.AddressModifyEnable = true;
vb.BufferPitch = buffer->stride;
if (res) {
@ -3961,7 +3961,7 @@ iris_set_vertex_buffers(struct pipe_context *ctx,
for (unsigned i = 0; i < unbind_num_trailing_slots; i++) {
struct iris_vertex_buffer_state *state =
&genx->vertex_buffers[start_slot + count + i];
&genx->vertex_buffers[count + i];
pipe_resource_reference(&state->resource, NULL);
}

6
src/gallium/drivers/lima/lima_state.c
View file

@ -186,7 +186,7 @@ lima_delete_vertex_elements_state(struct pipe_context *pctx, void *hwcso)
static void
lima_set_vertex_buffers(struct pipe_context *pctx,
unsigned start_slot, unsigned count,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *vb)
@ -195,7 +195,7 @@ lima_set_vertex_buffers(struct pipe_context *pctx,
struct lima_context_vertex_buffer *so = &ctx->vertex_buffers;
util_set_vertex_buffers_mask(so->vb, &so->enabled_mask,
vb, start_slot, count,
vb, count,
unbind_num_trailing_slots,
take_ownership);
so->count = util_last_bit(so->enabled_mask);
@ -472,5 +472,5 @@ lima_state_fini(struct lima_context *ctx)
struct lima_context_vertex_buffer *so = &ctx->vertex_buffers;
util_set_vertex_buffers_mask(so->vb, &so->enabled_mask, NULL,
0, 0, ARRAY_SIZE(so->vb), false);
0, ARRAY_SIZE(so->vb), false);
}

6
src/gallium/drivers/llvmpipe/lp_state_vertex.c
View file

@ -80,7 +80,7 @@ llvmpipe_delete_vertex_elements_state(struct pipe_context *pipe, void *velems)
static void
llvmpipe_set_vertex_buffers(struct pipe_context *pipe,
unsigned start_slot, unsigned count,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *buffers)
@ -91,13 +91,13 @@ llvmpipe_set_vertex_buffers(struct pipe_context *pipe,
util_set_vertex_buffers_count(llvmpipe->vertex_buffer,
&llvmpipe->num_vertex_buffers,
buffers, start_slot, count,
buffers, count,
unbind_num_trailing_slots,
take_ownership);
llvmpipe->dirty |= LP_NEW_VERTEX;
draw_set_vertex_buffers(llvmpipe->draw, start_slot, count,
draw_set_vertex_buffers(llvmpipe->draw, count,
unbind_num_trailing_slots, buffers);
}

2
src/gallium/drivers/nouveau/nv30/nv30_draw.c
View file

@ -396,7 +396,7 @@ nv30_render_vbo(struct pipe_context *pipe, const struct pipe_draw_info *info,
if (nv30->draw_dirty & NV30_NEW_CLIP)
draw_set_clip_state(draw, &nv30->clip);
if (nv30->draw_dirty & NV30_NEW_ARRAYS) {
draw_set_vertex_buffers(draw, 0, nv30->num_vtxbufs, 0, nv30->vtxbuf);
draw_set_vertex_buffers(draw, nv30->num_vtxbufs, 0, nv30->vtxbuf);
draw_set_vertex_elements(draw, nv30->vertex->num_elements, nv30->vertex->pipe);
}
if (nv30->draw_dirty & NV30_NEW_FRAGPROG) {

4
src/gallium/drivers/nouveau/nv30/nv30_state.c
View file

@ -436,7 +436,7 @@ nv30_set_viewport_states(struct pipe_context *pipe,
static void
nv30_set_vertex_buffers(struct pipe_context *pipe,
unsigned start_slot, unsigned count,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *vb)
@ -446,7 +446,7 @@ nv30_set_vertex_buffers(struct pipe_context *pipe,
nouveau_bufctx_reset(nv30->bufctx, BUFCTX_VTXBUF);
util_set_vertex_buffers_count(nv30->vtxbuf, &nv30->num_vtxbufs,
vb, start_slot, count,
vb, count,
unbind_num_trailing_slots,
take_ownership);

11
src/gallium/drivers/nouveau/nv50/nv50_state.c
View file

@ -1085,7 +1085,7 @@ nv50_set_window_rectangles(struct pipe_context *pipe,
static void
nv50_set_vertex_buffers(struct pipe_context *pipe,
unsigned start_slot, unsigned count,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *vb)
@ -1097,17 +1097,16 @@ nv50_set_vertex_buffers(struct pipe_context *pipe,
nv50->dirty_3d |= NV50_NEW_3D_ARRAYS;
util_set_vertex_buffers_count(nv50->vtxbuf, &nv50->num_vtxbufs, vb,
start_slot, count,
unbind_num_trailing_slots,
count, unbind_num_trailing_slots,
take_ownership);
unsigned clear_mask = ~u_bit_consecutive(start_slot + count, unbind_num_trailing_slots);
unsigned clear_mask = ~u_bit_consecutive(count, unbind_num_trailing_slots);
nv50->vbo_user &= clear_mask;
nv50->vbo_constant &= clear_mask;
nv50->vtxbufs_coherent &= clear_mask;
if (!vb) {
clear_mask = ~u_bit_consecutive(start_slot, count);
clear_mask = ~u_bit_consecutive(0, count);
nv50->vbo_user &= clear_mask;
nv50->vbo_constant &= clear_mask;
nv50->vtxbufs_coherent &= clear_mask;
@ -1115,7 +1114,7 @@ nv50_set_vertex_buffers(struct pipe_context *pipe,
}
for (i = 0; i < count; ++i) {
unsigned dst_index = start_slot + i;
unsigned dst_index = i;
if (vb[i].is_user_buffer) {
nv50->vbo_user |= 1 << dst_index;

11
src/gallium/drivers/nouveau/nvc0/nvc0_state.c
View file

@ -1038,7 +1038,7 @@ nvc0_set_patch_vertices(struct pipe_context *pipe, uint8_t patch_vertices)
static void
nvc0_set_vertex_buffers(struct pipe_context *pipe,
unsigned start_slot, unsigned count,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *vb)
@ -1050,17 +1050,16 @@ nvc0_set_vertex_buffers(struct pipe_context *pipe,
nvc0->dirty_3d |= NVC0_NEW_3D_ARRAYS;
util_set_vertex_buffers_count(nvc0->vtxbuf, &nvc0->num_vtxbufs, vb,
start_slot, count,
unbind_num_trailing_slots,
count, unbind_num_trailing_slots,
take_ownership);
unsigned clear_mask = ~u_bit_consecutive(start_slot + count, unbind_num_trailing_slots);
unsigned clear_mask = ~u_bit_consecutive(count, unbind_num_trailing_slots);
nvc0->vbo_user &= clear_mask;
nvc0->constant_vbos &= clear_mask;
nvc0->vtxbufs_coherent &= clear_mask;
if (!vb) {
clear_mask = ~u_bit_consecutive(start_slot, count);
clear_mask = ~u_bit_consecutive(0, count);
nvc0->vbo_user &= clear_mask;
nvc0->constant_vbos &= clear_mask;
nvc0->vtxbufs_coherent &= clear_mask;
@ -1068,7 +1067,7 @@ nvc0_set_vertex_buffers(struct pipe_context *pipe,
}
for (i = 0; i < count; ++i) {
unsigned dst_index = start_slot + i;
unsigned dst_index = i;
if (vb[i].is_user_buffer) {
nvc0->vbo_user |= 1 << dst_index;

7
src/gallium/drivers/panfrost/pan_context.c
View file

@ -326,8 +326,7 @@ panfrost_bind_sampler_states(struct pipe_context *pctx,
}
static void
panfrost_set_vertex_buffers(struct pipe_context *pctx, unsigned start_slot,
unsigned num_buffers,
panfrost_set_vertex_buffers(struct pipe_context *pctx, unsigned num_buffers,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *buffers)
@ -335,8 +334,8 @@ panfrost_set_vertex_buffers(struct pipe_context *pctx, unsigned start_slot,
struct panfrost_context *ctx = pan_context(pctx);
util_set_vertex_buffers_mask(ctx->vertex_buffers, &ctx->vb_mask, buffers,
start_slot, num_buffers,
unbind_num_trailing_slots, take_ownership);
num_buffers, unbind_num_trailing_slots,
take_ownership);
ctx->dirty |= PAN_DIRTY_VERTEX;
}

2
src/gallium/drivers/r300/r300_context.c
View file

@ -474,7 +474,7 @@ struct pipe_context* r300_create_context(struct pipe_screen* screen,
vb.depth0 = 1;
r300->dummy_vb.buffer.resource = screen->resource_create(screen, &vb);
r300->context.set_vertex_buffers(&r300->context, 0, 1, 0, false, &r300->dummy_vb);
r300->context.set_vertex_buffers(&r300->context, 1, 0, false, &r300->dummy_vb);
}
{

16
src/gallium/drivers/r300/r300_state.c
View file

@ -1771,7 +1771,7 @@ static void r300_set_viewport_states(struct pipe_context* pipe,
}
static void r300_set_vertex_buffers_hwtcl(struct pipe_context* pipe,
unsigned start_slot, unsigned count,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer* buffers)
@ -1780,21 +1780,21 @@ static void r300_set_vertex_buffers_hwtcl(struct pipe_context* pipe,
util_set_vertex_buffers_count(r300->vertex_buffer,
&r300->nr_vertex_buffers,
buffers, start_slot, count,
buffers, count,
unbind_num_trailing_slots, take_ownership);
/* There must be at least one vertex buffer set, otherwise it locks up. */
if (!r300->nr_vertex_buffers) {
util_set_vertex_buffers_count(r300->vertex_buffer,
&r300->nr_vertex_buffers,
&r300->dummy_vb, 0, 1, 0, false);
&r300->dummy_vb, 1, 0, false);
}
r300->vertex_arrays_dirty = true;
}
static void r300_set_vertex_buffers_swtcl(struct pipe_context* pipe,
unsigned start_slot, unsigned count,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer* buffers)
@ -1804,9 +1804,9 @@ static void r300_set_vertex_buffers_swtcl(struct pipe_context* pipe,
util_set_vertex_buffers_count(r300->vertex_buffer,
&r300->nr_vertex_buffers,
buffers, start_slot, count,
buffers, count,
unbind_num_trailing_slots, take_ownership);
draw_set_vertex_buffers(r300->draw, start_slot, count,
draw_set_vertex_buffers(r300->draw, count,
unbind_num_trailing_slots, buffers);
if (!buffers)
@ -1814,10 +1814,10 @@ static void r300_set_vertex_buffers_swtcl(struct pipe_context* pipe,
for (i = 0; i < count; i++) {
if (buffers[i].is_user_buffer) {
draw_set_mapped_vertex_buffer(r300->draw, start_slot + i,
draw_set_mapped_vertex_buffer(r300->draw, i,
buffers[i].buffer.user, ~0);
} else if (buffers[i].buffer.resource) {
draw_set_mapped_vertex_buffer(r300->draw, start_slot + i,
draw_set_mapped_vertex_buffer(r300->draw, i,
r300_resource(buffers[i].buffer.resource)->malloced_buffer, ~0);
}
}

2
src/gallium/drivers/r600/r600_pipe_common.c
View file

@ -207,7 +207,7 @@ void r600_draw_rectangle(struct blitter_context *blitter,
vbuffer.stride = 2 * 4 * sizeof(float); /* vertex size */
vbuffer.buffer_offset = offset;
rctx->b.set_vertex_buffers(&rctx->b, blitter->vb_slot, 1, 0, false, &vbuffer);
rctx->b.set_vertex_buffers(&rctx->b, 1, 0, false, &vbuffer);
util_draw_arrays_instanced(&rctx->b, R600_PRIM_RECTANGLE_LIST, 0, 3,
0, num_instances);
pipe_resource_reference(&buf, NULL);

7
src/gallium/drivers/r600/r600_state_common.c
View file

@ -568,14 +568,14 @@ void r600_vertex_buffers_dirty(struct r600_context *rctx)
}
static void r600_set_vertex_buffers(struct pipe_context *ctx,
unsigned start_slot, unsigned count,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *input)
{
struct r600_context *rctx = (struct r600_context *)ctx;
struct r600_vertexbuf_state *state = &rctx->vertex_buffer_state;
struct pipe_vertex_buffer *vb = state->vb + start_slot;
struct pipe_vertex_buffer *vb = state->vb;
unsigned i;
uint32_t disable_mask = 0;
/* These are the new buffers set by this function. */
@ -626,9 +626,6 @@ static void r600_set_vertex_buffers(struct pipe_context *ctx,
}
disable_mask |= ((1ull << unbind_num_trailing_slots) - 1) << count;
disable_mask <<= start_slot;
new_buffer_mask <<= start_slot;
rctx->vertex_buffer_state.enabled_mask &= ~disable_mask;
rctx->vertex_buffer_state.dirty_mask &= rctx->vertex_buffer_state.enabled_mask;
rctx->vertex_buffer_state.enabled_mask |= new_buffer_mask;

31
src/gallium/drivers/radeonsi/si_state.c
View file

@ -5157,29 +5157,28 @@ static void si_delete_vertex_element(struct pipe_context *ctx, void *state)
FREE(state);
}
static void si_set_vertex_buffers(struct pipe_context *ctx, unsigned start_slot, unsigned count,
static void si_set_vertex_buffers(struct pipe_context *ctx, unsigned count,
unsigned unbind_num_trailing_slots, bool take_ownership,
const struct pipe_vertex_buffer *buffers)
{
struct si_context *sctx = (struct si_context *)ctx;
struct pipe_vertex_buffer *dst = sctx->vertex_buffer + start_slot;
unsigned updated_mask = u_bit_consecutive(start_slot, count + unbind_num_trailing_slots);
unsigned updated_mask = u_bit_consecutive(0, count + unbind_num_trailing_slots);
uint32_t orig_unaligned = sctx->vertex_buffer_unaligned;
uint32_t unaligned = 0;
int i;
assert(start_slot + count + unbind_num_trailing_slots <= ARRAY_SIZE(sctx->vertex_buffer));
assert(count + unbind_num_trailing_slots <= ARRAY_SIZE(sctx->vertex_buffer));
if (buffers) {
if (take_ownership) {
for (i = 0; i < count; i++) {
const struct pipe_vertex_buffer *src = buffers + i;
struct pipe_vertex_buffer *dsti = dst + i;
struct pipe_vertex_buffer *dst = sctx->vertex_buffer + i;
struct pipe_resource *buf = src->buffer.resource;
unsigned slot_bit = 1 << (start_slot + i);
unsigned slot_bit = 1 << i;
/* Only unreference bound vertex buffers. (take_ownership) */
pipe_resource_reference(&dsti->buffer.resource, NULL);
pipe_resource_reference(&dst->buffer.resource, NULL);
if (src->buffer_offset & 3 || src->stride & 3)
unaligned |= slot_bit;
@ -5191,19 +5190,19 @@ static void si_set_vertex_buffers(struct pipe_context *ctx, unsigned start_slot,
}
}
/* take_ownership allows us to copy pipe_resource pointers without refcounting. */
memcpy(dst, buffers, count * sizeof(struct pipe_vertex_buffer));
memcpy(sctx->vertex_buffer, buffers, count * sizeof(struct pipe_vertex_buffer));
} else {
for (i = 0; i < count; i++) {
const struct pipe_vertex_buffer *src = buffers + i;
struct pipe_vertex_buffer *dsti = dst + i;
struct pipe_vertex_buffer *dst = sctx->vertex_buffer + i;
struct pipe_resource *buf = src->buffer.resource;
unsigned slot_bit = 1 << (start_slot + i);
unsigned slot_bit = 1 << i;
pipe_resource_reference(&dsti->buffer.resource, buf);
dsti->buffer_offset = src->buffer_offset;
dsti->stride = src->stride;
pipe_resource_reference(&dst->buffer.resource, buf);
dst->buffer_offset = src->buffer_offset;
dst->stride = src->stride;
if (dsti->buffer_offset & 3 || dsti->stride & 3)
if (dst->buffer_offset & 3 || dst->stride & 3)
unaligned |= slot_bit;
if (buf) {
@ -5215,11 +5214,11 @@ static void si_set_vertex_buffers(struct pipe_context *ctx, unsigned start_slot,
}
} else {
for (i = 0; i < count; i++)
pipe_resource_reference(&dst[i].buffer.resource, NULL);
pipe_resource_reference(&sctx->vertex_buffer[i].buffer.resource, NULL);
}
for (i = 0; i < unbind_num_trailing_slots; i++)
pipe_resource_reference(&dst[count + i].buffer.resource, NULL);
pipe_resource_reference(&sctx->vertex_buffer[count + i].buffer.resource, NULL);
sctx->vertex_buffers_dirty = sctx->num_vertex_elements > 0;
sctx->vertex_buffer_unaligned = (orig_unaligned & ~updated_mask) | unaligned;

7
src/gallium/drivers/softpipe/sp_state_vertex.c
View file

@ -80,7 +80,7 @@ softpipe_delete_vertex_elements_state(struct pipe_context *pipe, void *velems)
static void
softpipe_set_vertex_buffers(struct pipe_context *pipe,
unsigned start_slot, unsigned count,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *buffers)
@ -91,14 +91,13 @@ softpipe_set_vertex_buffers(struct pipe_context *pipe,
util_set_vertex_buffers_count(softpipe->vertex_buffer,
&softpipe->num_vertex_buffers,
buffers, start_slot, count,
buffers, count,
unbind_num_trailing_slots,
take_ownership);
softpipe->dirty |= SP_NEW_VERTEX;
draw_set_vertex_buffers(softpipe->draw, start_slot, count,
unbind_num_trailing_slots, buffers);
draw_set_vertex_buffers(softpipe->draw, count, unbind_num_trailing_slots, buffers);
}

4
src/gallium/drivers/svga/svga_pipe_vertex.c
View file

@ -41,7 +41,7 @@
static void
svga_set_vertex_buffers(struct pipe_context *pipe,
unsigned start_slot, unsigned count,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *buffers)
@ -50,7 +50,7 @@ svga_set_vertex_buffers(struct pipe_context *pipe,
util_set_vertex_buffers_count(svga->curr.vb,
&svga->curr.num_vertex_buffers,
buffers, start_slot, count,
buffers, count,
unbind_num_trailing_slots,
take_ownership);

2
src/gallium/drivers/svga/svga_swtnl_state.c
View file

@ -113,7 +113,7 @@ update_swtnl_draw(struct svga_context *svga, uint64_t dirty)
svga->curr.fs->draw_shader);
if (dirty & SVGA_NEW_VBUFFER)
draw_set_vertex_buffers(svga->swtnl.draw, 0,
draw_set_vertex_buffers(svga->swtnl.draw,
svga->curr.num_vertex_buffers, 0,
svga->curr.vb);

4
src/gallium/drivers/tegra/tegra_context.c
View file

@ -634,7 +634,7 @@ tegra_set_shader_images(struct pipe_context *pcontext, enum pipe_shader_type sha
}
static void
tegra_set_vertex_buffers(struct pipe_context *pcontext, unsigned start_slot,
tegra_set_vertex_buffers(struct pipe_context *pcontext,
unsigned num_buffers, unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *buffers)
@ -654,7 +654,7 @@ tegra_set_vertex_buffers(struct pipe_context *pcontext, unsigned start_slot,
buffers = buf;
}
context->gpu->set_vertex_buffers(context->gpu, start_slot, num_buffers,
context->gpu->set_vertex_buffers(context->gpu, num_buffers,
unbind_num_trailing_slots,
take_ownership, buffers);
}

5
src/gallium/drivers/v3d/v3dx_state.c
View file

@ -296,7 +296,7 @@ v3d_set_viewport_states(struct pipe_context *pctx,
static void
v3d_set_vertex_buffers(struct pipe_context *pctx,
unsigned start_slot, unsigned count,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *vb)
@ -305,8 +305,7 @@ v3d_set_vertex_buffers(struct pipe_context *pctx,
struct v3d_vertexbuf_stateobj *so = &v3d->vertexbuf;
util_set_vertex_buffers_mask(so->vb, &so->enabled_mask, vb,
start_slot, count,
unbind_num_trailing_slots,
count, unbind_num_trailing_slots,
take_ownership);
so->count = util_last_bit(so->enabled_mask);

5
src/gallium/drivers/vc4/vc4_state.c
View file

@ -312,7 +312,7 @@ vc4_set_viewport_states(struct pipe_context *pctx,
static void
vc4_set_vertex_buffers(struct pipe_context *pctx,
unsigned start_slot, unsigned count,
unsigned count,
unsigned unbind_num_trailing_slots,
bool take_ownership,
const struct pipe_vertex_buffer *vb)
@ -321,8 +321,7 @@ vc4_set_vertex_buffers(struct pipe_context *pctx,
struct vc4_vertexbuf_stateobj *so = &vc4->vertexbuf;
util_set_vertex_buffers_mask(so->vb, &so->enabled_mask, vb,
start_slot, count,
unbind_num_trailing_slots,
count, unbind_num_trailing_slots,
take_ownership);
so->count = util_last_bit(so->enabled_mask);

3
src/gallium/drivers/virgl/virgl_context.c
View file

@ -567,7 +567,6 @@ static void virgl_bind_vertex_elements_state(struct pipe_context *ctx,
}
static void virgl_set_vertex_buffers(struct pipe_context *ctx,
unsigned start_slot,
unsigned num_buffers,
unsigned unbind_num_trailing_slots,
bool take_ownership,
@ -577,7 +576,7 @@ static void virgl_set_vertex_buffers(struct pipe_context *ctx,
util_set_vertex_buffers_count(vctx->vertex_buffer,
&vctx->num_vertex_buffers,
buffers, start_slot, num_buffers,
buffers, num_buffers,
unbind_num_trailing_slots,
take_ownership);

21
src/gallium/drivers/zink/zink_context.c
View file

@ -1272,7 +1272,6 @@ update_existing_vbo(struct zink_context *ctx, unsigned slot)
static void
zink_set_vertex_buffers(struct pipe_context *pctx,
unsigned start_slot,
unsigned num_buffers,
unsigned unbind_num_trailing_slots,
bool take_ownership,
@ -1283,16 +1282,16 @@ zink_set_vertex_buffers(struct pipe_context *pctx,
const bool need_state_change = !zink_screen(pctx->screen)->info.have_EXT_extended_dynamic_state &&
!have_input_state;
uint32_t enabled_buffers = ctx->gfx_pipeline_state.vertex_buffers_enabled_mask;
enabled_buffers |= u_bit_consecutive(start_slot, num_buffers);
enabled_buffers &= ~u_bit_consecutive(start_slot + num_buffers, unbind_num_trailing_slots);
enabled_buffers |= u_bit_consecutive(0, num_buffers);
enabled_buffers &= ~u_bit_consecutive(num_buffers, unbind_num_trailing_slots);
bool stride_changed = false;
if (buffers) {
for (unsigned i = 0; i < num_buffers; ++i) {
const struct pipe_vertex_buffer *vb = buffers + i;
struct pipe_vertex_buffer *ctx_vb = &ctx->vertex_buffers[start_slot + i];
struct pipe_vertex_buffer *ctx_vb = &ctx->vertex_buffers[i];
stride_changed |= ctx_vb->stride != vb->stride;
update_existing_vbo(ctx, start_slot + i);
update_existing_vbo(ctx, i);
if (!take_ownership)
pipe_resource_reference(&ctx_vb->buffer.resource, vb->buffer.resource);
else {
@ -1301,7 +1300,7 @@ zink_set_vertex_buffers(struct pipe_context *pctx,
}
if (vb->buffer.resource) {
struct zink_resource *res = zink_resource(vb->buffer.resource);
res->vbo_bind_mask |= BITFIELD_BIT(start_slot + i);
res->vbo_bind_mask |= BITFIELD_BIT(i);
res->vbo_bind_count++;
res->gfx_barrier |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
res->barrier_access[0] |= VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
@ -1314,18 +1313,18 @@ zink_set_vertex_buffers(struct pipe_context *pctx,
zink_batch_resource_usage_set(&ctx->batch, res, false, true);
res->obj->unordered_read = false;
} else {
enabled_buffers &= ~BITFIELD_BIT(start_slot + i);
enabled_buffers &= ~BITFIELD_BIT(i);
}
}
} else {
for (unsigned i = 0; i < num_buffers; ++i) {
update_existing_vbo(ctx, start_slot + i);
pipe_resource_reference(&ctx->vertex_buffers[start_slot + i].buffer.resource, NULL);
update_existing_vbo(ctx, i);
pipe_resource_reference(&ctx->vertex_buffers[i].buffer.resource, NULL);
}
}
for (unsigned i = 0; i < unbind_num_trailing_slots; i++) {
update_existing_vbo(ctx, start_slot + i);
pipe_resource_reference(&ctx->vertex_buffers[start_slot + i].buffer.resource, NULL);
update_existing_vbo(ctx, i);
pipe_resource_reference(&ctx->vertex_buffers[i].buffer.resource, NULL);
}
if (need_state_change)
ctx->vertex_state_changed = true;

2
src/gallium/frontends/d3d10umd/InputAssembly.cpp
View file

@ -178,7 +178,7 @@ IaSetVertexBuffers(D3D10DDI_HDEVICE hDevice,
/* Resubmit old and new vertex buffers.
*/
pipe->set_vertex_buffers(pipe, 0, PIPE_MAX_ATTRIBS, 0, false, pDevice->vertex_buffers);
pipe->set_vertex_buffers(pipe, PIPE_MAX_ATTRIBS, 0, false, pDevice->vertex_buffers);
}

14
src/gallium/frontends/lavapipe/lvp_execute.c
View file

@ -148,6 +148,7 @@ struct rendering_state {
unsigned start_vb;
struct pipe_vertex_buffer vb[PIPE_MAX_ATTRIBS];
size_t vb_sizes[PIPE_MAX_ATTRIBS]; //UINT32_MAX for unset
uint8_t vertex_buffer_index[PIPE_MAX_ATTRIBS]; /* temp storage to sort for start_vb */
struct cso_velems_state velem;
bool disable_multisample;
@ -403,6 +404,12 @@ update_min_samples(struct rendering_state *state)
}
}
static void update_vertex_elements_buffer_index(struct rendering_state *state)
{
for (int i = 0; i < state->velem.count; i++)
state->velem.velems[i].vertex_buffer_index = state->vertex_buffer_index[i] - state->start_vb;
}
static void emit_state(struct rendering_state *state)
{
if (!state->shaders[MESA_SHADER_FRAGMENT] && !state->noop_fs_bound) {
@ -483,11 +490,12 @@ static void emit_state(struct rendering_state *state)
}
if (state->vb_dirty) {
cso_set_vertex_buffers(state->cso, state->start_vb, state->num_vb, 0, false, state->vb);
cso_set_vertex_buffers(state->cso, state->num_vb, 0, false, state->vb);
state->vb_dirty = false;
}
if (state->ve_dirty) {
update_vertex_elements_buffer_index(state);
cso_set_vertex_elements(state->cso, &state->velem);
state->ve_dirty = false;
}
@ -963,7 +971,7 @@ static void handle_graphics_pipeline(struct lvp_pipeline *pipeline,
u_foreach_bit(a, ps->vi->attributes_valid) {
uint32_t b = ps->vi->attributes[a].binding;
state->velem.velems[a].src_offset = ps->vi->attributes[a].offset;
state->velem.velems[a].vertex_buffer_index = b;
state->vertex_buffer_index[a] = b;
state->velem.velems[a].src_format =
lvp_vk_format_to_pipe_format(ps->vi->attributes[a].format);
state->velem.velems[a].dual_slot = false;
@ -3297,7 +3305,7 @@ static void handle_set_vertex_input(struct vk_cmd_queue_entry *cmd,
}
assert(binding);
state->velem.velems[location].src_offset = attrs[i].offset;
state->velem.velems[location].vertex_buffer_index = attrs[i].binding;
state->vertex_buffer_index[location] = attrs[i].binding;
state->velem.velems[location].src_format = lvp_vk_format_to_pipe_format(attrs[i].format);
state->vb[attrs[i].binding].stride = binding->stride;
uint32_t d = binding->divisor;

22
src/gallium/frontends/nine/device9.c
View file

@ -401,6 +401,26 @@ NineDevice9_ctor( struct NineDevice9 *This,
assert(transfer);
memset(data, 0, 16);
This->context.pipe->buffer_unmap(This->context.pipe, transfer);
/* initialize dummy_vbo_sw */
if (pScreen != This->screen_sw) {
This->dummy_vbo_sw = This->screen_sw->resource_create(This->screen_sw, &tmpl);
if (!This->dummy_vbo_sw)
return D3DERR_OUTOFVIDEOMEMORY;
u_box_1d(0, 16, &box);
data = This->pipe_sw->buffer_map(This->pipe_sw, This->dummy_vbo_sw, 0,
PIPE_MAP_WRITE |
PIPE_MAP_DISCARD_WHOLE_RESOURCE,
&box, &transfer);
assert(data);
assert(transfer);
memset(data, 0, 16);
This->pipe_sw->buffer_unmap(This->pipe_sw, transfer);
} else {
This->dummy_vbo_sw = This->dummy_vbo;
}
}
This->cursor.software = false;
@ -639,6 +659,8 @@ NineDevice9_dtor( struct NineDevice9 *This )
pipe_sampler_view_reference(&This->dummy_sampler_view, NULL);
pipe_resource_reference(&This->dummy_texture, NULL);
pipe_resource_reference(&This->dummy_vbo, NULL);
if (This->screen != This->screen_sw)
pipe_resource_reference(&This->dummy_vbo_sw, NULL);
FREE(This->state.vs_const_f);
FREE(This->context.vs_const_f);
FREE(This->state.ps_const_f);

1
src/gallium/frontends/nine/device9.h
View file

@ -158,6 +158,7 @@ struct NineDevice9
/* dummy vbo (containing 0 0 0 0) to bind if vertex shader input
* is not bound to anything by the vertex declaration */
struct pipe_resource *dummy_vbo;
struct pipe_resource *dummy_vbo_sw;
BOOL device_needs_reset;
int minor_version_num;
long long available_texture_mem;

206
src/gallium/frontends/nine/nine_state.c
View file

@ -869,6 +869,8 @@ update_vertex_elements(struct NineDevice9 *device)
int dummy_vbo_stream = -1;
BOOL need_dummy_vbo = false;
struct cso_velems_state ve;
unsigned vtxbuf_mask;
unsigned vtxbuf_holes_map[PIPE_MAX_ATTRIBS];
context->stream_usage_mask = 0;
memset(vdecl_index_map, -1, 16);
@ -897,18 +899,27 @@ update_vertex_elements(struct NineDevice9 *device)
if (need_dummy_vbo) {
u_foreach_bit(bit, BITFIELD_MASK(device->caps.MaxStreams) & ~used_streams) {
dummy_vbo_stream = bit;
break;
dummy_vbo_stream = bit;
break;
}
}
/* there are less vertex shader inputs than stream slots,
/* there are fewer vertex shader inputs than stream slots,
* so if we need a slot for the dummy vbo, we should have found one */
assert (!need_dummy_vbo || dummy_vbo_stream != -1);
/* calculate vtxbuf_holes_map to match for update_vertex_buffers() function */
i = 0;
vtxbuf_mask = context->vtxbuf_mask |
(need_dummy_vbo ? BITFIELD_BIT(dummy_vbo_stream) : 0);
u_foreach_bit(bit, vtxbuf_mask)
vtxbuf_holes_map[bit] = i++;
for (n = 0; n < vs->num_inputs; ++n) {
index = vdecl_index_map[n];
if (index >= 0) {
ve.velems[n] = vdecl->elems[index];
ve.velems[n].vertex_buffer_index =
vtxbuf_holes_map[ve.velems[n].vertex_buffer_index];
b = ve.velems[n].vertex_buffer_index;
context->stream_usage_mask |= 1 << b;
/* XXX wine just uses 1 here: */
@ -919,7 +930,7 @@ update_vertex_elements(struct NineDevice9 *device)
* vertex shader needs, we bind a dummy vbo with 0 0 0 0.
* This is not precised by the spec, but is the behaviour
* tested on win */
ve.velems[n].vertex_buffer_index = dummy_vbo_stream;
ve.velems[n].vertex_buffer_index = vtxbuf_holes_map[dummy_vbo_stream];
ve.velems[n].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
ve.velems[n].src_offset = 0;
ve.velems[n].instance_divisor = 0;
@ -930,10 +941,8 @@ update_vertex_elements(struct NineDevice9 *device)
if (context->dummy_vbo_bound_at != dummy_vbo_stream) {
if (context->dummy_vbo_bound_at >= 0)
context->changed.vtxbuf |= 1 << context->dummy_vbo_bound_at;
if (dummy_vbo_stream >= 0) {
if (dummy_vbo_stream >= 0)
context->changed.vtxbuf |= 1 << dummy_vbo_stream;
context->vbo_bound_done = false;
}
context->dummy_vbo_bound_at = dummy_vbo_stream;
}
@ -946,34 +955,36 @@ update_vertex_buffers(struct NineDevice9 *device)
{
struct nine_context *context = &device->context;
struct pipe_context *pipe = context->pipe;
struct pipe_vertex_buffer dummy_vtxbuf;
uint32_t mask = context->changed.vtxbuf;
unsigned i;
struct pipe_vertex_buffer vbuffer[PIPE_MAX_ATTRIBS];
unsigned vtxbuf_count;
unsigned trailing_count;
unsigned mask, i, vtxbuf_i;
mask = context->vtxbuf_mask |
((context->dummy_vbo_bound_at >= 0) ? BITFIELD_BIT(context->dummy_vbo_bound_at) : 0);
vtxbuf_count = util_bitcount(mask);
DBG("mask=%x\n", mask);
if (context->dummy_vbo_bound_at >= 0) {
if (!context->vbo_bound_done) {
dummy_vtxbuf.buffer.resource = device->dummy_vbo;
dummy_vtxbuf.stride = 0;
dummy_vtxbuf.is_user_buffer = false;
dummy_vtxbuf.buffer_offset = 0;
pipe->set_vertex_buffers(pipe, context->dummy_vbo_bound_at,
1, 0, false, &dummy_vtxbuf);
context->vbo_bound_done = true;
}
mask &= ~(1 << context->dummy_vbo_bound_at);
}
for (i = 0; mask; mask >>= 1, ++i) {
if (mask & 1) {
if (context->vtxbuf[i].buffer.resource)
pipe->set_vertex_buffers(pipe, i, 1, 0, false, &context->vtxbuf[i]);
else
pipe->set_vertex_buffers(pipe, i, 0, 1, false, NULL);
for (i = 0; mask; i++) {
vtxbuf_i = u_bit_scan(&mask);
if (vtxbuf_i == context->dummy_vbo_bound_at) {
vbuffer[i].buffer.resource = device->dummy_vbo;
vbuffer[i].stride = 0;
vbuffer[i].is_user_buffer = false;
vbuffer[i].buffer_offset = 0;
} else {
memcpy(&vbuffer[i], &context->vtxbuf[vtxbuf_i], sizeof(struct pipe_vertex_buffer));
}
}
trailing_count = (context->last_vtxbuf_count <= vtxbuf_count) ? 0 :
context->last_vtxbuf_count - vtxbuf_count;
if (vtxbuf_count)
pipe->set_vertex_buffers(pipe, vtxbuf_count, trailing_count, false, vbuffer);
else
pipe->set_vertex_buffers(pipe, 0, trailing_count, false, NULL);
context->last_vtxbuf_count = vtxbuf_count;
context->changed.vtxbuf = 0;
}
@ -1612,6 +1623,10 @@ CSMT_ITEM_NO_WAIT(nine_context_set_stream_source_apply,
pipe_resource_reference(&context->vtxbuf[i].buffer.resource, res);
context->changed.vtxbuf |= 1 << StreamNumber;
if (res)
context->vtxbuf_mask |= 1 << StreamNumber;
else
context->vtxbuf_mask &= ~(1 << StreamNumber);
}
void
@ -2518,7 +2533,7 @@ CSMT_ITEM_NO_WAIT(nine_context_draw_indexed_primitive_from_vtxbuf_idxbuf,
else
info.index.user = user_ibuf;
context->pipe->set_vertex_buffers(context->pipe, 0, 1, 0, false, vbuf);
context->pipe->set_vertex_buffers(context->pipe, 1, 0, false, vbuf);
context->changed.vtxbuf |= 1;
context->pipe->draw_vbo(context->pipe, &info, 0, NULL, &draw, 1);
@ -2980,10 +2995,8 @@ nine_state_set_defaults(struct NineDevice9 *device, const D3DCAPS9 *caps,
for (s = 0; s < NINE_MAX_SAMPLERS; ++s)
context->changed.sampler[s] = ~0;
if (!is_reset) {
if (!is_reset)
context->dummy_vbo_bound_at = -1;
context->vbo_bound_done = false;
}
}
void
@ -3022,6 +3035,8 @@ nine_context_clear(struct NineDevice9 *device)
if (!pipe || !cso)
return;
context->vtxbuf_mask = 0;
pipe->bind_vs_state(pipe, NULL);
pipe->bind_fs_state(pipe, NULL);
@ -3039,7 +3054,7 @@ nine_context_clear(struct NineDevice9 *device)
pipe->set_sampler_views(pipe, PIPE_SHADER_FRAGMENT, 0, 0,
NINE_MAX_SAMPLERS_PS, false, NULL);
pipe->set_vertex_buffers(pipe, 0, 0, device->caps.MaxStreams, false, NULL);
pipe->set_vertex_buffers(pipe, 0, device->caps.MaxStreams, false, NULL);
for (i = 0; i < ARRAY_SIZE(context->rt); ++i)
nine_bind(&context->rt[i], NULL);
@ -3099,20 +3114,21 @@ nine_state_init_sw(struct NineDevice9 *device)
/* There is duplication with update_vertex_elements.
* TODO: Share the code */
static void
static int
update_vertex_elements_sw(struct NineDevice9 *device)
{
struct nine_state *state = &device->state;
const struct NineVertexDeclaration9 *vdecl = device->state.vdecl;
const struct NineVertexShader9 *vs;
unsigned n, b, i;
unsigned n, b, i, j;
int index;
int8_t vdecl_index_map[16]; /* vs->num_inputs <= 16 */
int8_t used_streams[device->caps.MaxStreams];
int dummy_vbo_stream = -1;
BOOL need_dummy_vbo = false;
int dummy_vbo_stream = -1;
struct cso_velems_state ve;
bool programmable_vs = state->vs && !(state->vdecl && state->vdecl->position_t);
unsigned vtxbuf_holes_map[PIPE_MAX_ATTRIBS];
memset(vdecl_index_map, -1, 16);
memset(used_streams, 0, device->caps.MaxStreams);
@ -3140,20 +3156,32 @@ update_vertex_elements_sw(struct NineDevice9 *device)
}
if (need_dummy_vbo) {
for (i = 0; i < device->caps.MaxStreams; i++ ) {
for (i = 0; i < device->caps.MaxStreams; i++) {
if (!used_streams[i]) {
dummy_vbo_stream = i;
break;
}
}
}
/* TODO handle dummy_vbo */
assert (!need_dummy_vbo);
/* there are less vertex shader inputs than stream slots,
* so if we need a slot for the dummy vbo, we should have found one */
assert (!need_dummy_vbo || dummy_vbo_stream != -1);
/* calculate vtxbuf_holes_map to match for update_vertex_buffers_sw() function */
j = 0;
for (i = 0; i < device->caps.MaxStreams; i++) {
if (state->stream[i] || (need_dummy_vbo && dummy_vbo_stream == i)) {
vtxbuf_holes_map[i] = j;
j++;
}
}
for (n = 0; n < vs->num_inputs; ++n) {
index = vdecl_index_map[n];
if (index >= 0) {
ve.velems[n] = vdecl->elems[index];
ve.velems[n].vertex_buffer_index =
vtxbuf_holes_map[ve.velems[n].vertex_buffer_index];
b = ve.velems[n].vertex_buffer_index;
/* XXX wine just uses 1 here: */
if (state->stream_freq[b] & D3DSTREAMSOURCE_INSTANCEDATA)
@ -3163,7 +3191,7 @@ update_vertex_elements_sw(struct NineDevice9 *device)
* vertex shader needs, we bind a dummy vbo with 0 0 0 0.
* This is not precised by the spec, but is the behaviour
* tested on win */
ve.velems[n].vertex_buffer_index = dummy_vbo_stream;
ve.velems[n].vertex_buffer_index = vtxbuf_holes_map[dummy_vbo_stream];
ve.velems[n].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
ve.velems[n].src_offset = 0;
ve.velems[n].instance_divisor = 0;
@ -3173,63 +3201,68 @@ update_vertex_elements_sw(struct NineDevice9 *device)
ve.count = vs->num_inputs;
cso_set_vertex_elements(device->cso_sw, &ve);
return dummy_vbo_stream;
}
static void
update_vertex_buffers_sw(struct NineDevice9 *device, int start_vertice, int num_vertices)
update_vertex_buffers_sw(struct NineDevice9 *device, int dummy_vbo_stream,
int start_vertice, int num_vertices)
{
struct pipe_context *pipe = nine_context_get_pipe_acquire(device);
struct pipe_context *pipe_sw = device->pipe_sw;
struct nine_state *state = &device->state;
struct nine_state_sw_internal *sw_internal = &device->state_sw_internal;
struct pipe_vertex_buffer vtxbuf;
uint32_t mask = 0xf;
unsigned i;
struct pipe_vertex_buffer vbuffer[PIPE_MAX_ATTRIBS];
unsigned vtxbuf_count = 0;
unsigned i, j = 0;
DBG("mask=%x\n", mask);
for (i = 0; i < device->caps.MaxStreams; i++) {
if (dummy_vbo_stream == i) {
vbuffer[j].buffer.resource = NULL;
pipe_resource_reference(&vbuffer[j].buffer.resource, device->dummy_vbo_sw);
vbuffer[j].stride = 0;
vbuffer[j].is_user_buffer = false;
vbuffer[j].buffer_offset = 0;
j++;
} else if (state->stream[i]) {
unsigned offset;
struct pipe_resource *buf;
struct pipe_box box;
void *userbuf;
/* TODO: handle dummy_vbo_bound_at */
vbuffer[j] = state->vtxbuf[i];
buf = NineVertexBuffer9_GetResource(state->stream[i], &offset);
for (i = 0; mask; mask >>= 1, ++i) {
if (mask & 1) {
if (state->stream[i]) {
unsigned offset;
struct pipe_resource *buf;
struct pipe_box box;
void *userbuf;
DBG("Locking %p (offset %d, length %d)\n", buf,
vbuffer[j].buffer_offset, num_vertices * vbuffer[j].stride);
vtxbuf = state->vtxbuf[i];
buf = NineVertexBuffer9_GetResource(state->stream[i], &offset);
u_box_1d(vbuffer[j].buffer_offset + offset + start_vertice *
vbuffer[j].stride, num_vertices * vbuffer[j].stride, &box);
DBG("Locking %p (offset %d, length %d)\n", buf,
vtxbuf.buffer_offset, num_vertices * vtxbuf.stride);
userbuf = pipe->buffer_map(pipe, buf, 0, PIPE_MAP_READ, &box,
&(sw_internal->transfers_so[i]));
vbuffer[j].is_user_buffer = true;
vbuffer[j].buffer.user = userbuf;
u_box_1d(vtxbuf.buffer_offset + offset + start_vertice * vtxbuf.stride,
num_vertices * vtxbuf.stride, &box);
userbuf = pipe->buffer_map(pipe, buf, 0, PIPE_MAP_READ, &box,
&(sw_internal->transfers_so[i]));
vtxbuf.is_user_buffer = true;
vtxbuf.buffer.user = userbuf;
if (!device->driver_caps.user_sw_vbufs) {
vtxbuf.buffer.resource = NULL;
vtxbuf.is_user_buffer = false;
u_upload_data(device->pipe_sw->stream_uploader,
0,
box.width,
16,
userbuf,
&(vtxbuf.buffer_offset),
&(vtxbuf.buffer.resource));
u_upload_unmap(device->pipe_sw->stream_uploader);
}
pipe_sw->set_vertex_buffers(pipe_sw, i, 1, 0, false, &vtxbuf);
pipe_vertex_buffer_unreference(&vtxbuf);
} else
pipe_sw->set_vertex_buffers(pipe_sw, i, 0, 1, false, NULL);
if (!device->driver_caps.user_sw_vbufs) {
vbuffer[j].buffer.resource = NULL;
vbuffer[j].is_user_buffer = false;
u_upload_data(device->pipe_sw->stream_uploader,
0,
box.width,
16,
userbuf,
&(vbuffer[j].buffer_offset),
&(vbuffer[j].buffer.resource));
u_upload_unmap(device->pipe_sw->stream_uploader);
}
j++;
}
}
vtxbuf_count = j;
pipe_sw->set_vertex_buffers(pipe_sw, vtxbuf_count, device->caps.MaxStreams-vtxbuf_count, true, vbuffer);
nine_context_get_pipe_release(device);
}
@ -3346,14 +3379,15 @@ nine_state_prepare_draw_sw(struct NineDevice9 *device, struct NineVertexDeclarat
struct nine_state *state = &device->state;
bool programmable_vs = state->vs && !(state->vdecl && state->vdecl->position_t);
struct NineVertexShader9 *vs = programmable_vs ? device->state.vs : device->ff.vs;
int dummy_vbo_stream;
assert(programmable_vs);
DBG("Preparing draw\n");
cso_set_vertex_shader_handle(device->cso_sw,
NineVertexShader9_GetVariantProcessVertices(vs, vdecl_out, so));
update_vertex_elements_sw(device);
update_vertex_buffers_sw(device, start_vertice, num_vertices);
dummy_vbo_stream = update_vertex_elements_sw(device);
update_vertex_buffers_sw(device, dummy_vbo_stream, start_vertice, num_vertices);
update_vs_constants_sw(device);
DBG("Preparation succeeded\n");
}
@ -3366,8 +3400,8 @@ nine_state_after_draw_sw(struct NineDevice9 *device)
struct pipe_context *pipe_sw = device->pipe_sw;
int i;
pipe_sw->set_vertex_buffers(pipe_sw, 0, device->caps.MaxStreams, false, NULL);
for (i = 0; i < 4; i++) {
pipe_sw->set_vertex_buffers(pipe_sw, i, 0, 1, false, NULL);
if (sw_internal->transfers_so[i])
pipe->buffer_unmap(pipe, sw_internal->transfers_so[i]);
sw_internal->transfers_so[i] = NULL;

5
src/gallium/frontends/nine/nine_state.h
View file

@ -215,7 +215,9 @@ struct nine_state
struct NineIndexBuffer9 *idxbuf;
struct NineVertexBuffer9 *stream[PIPE_MAX_ATTRIBS];
uint32_t stream_mask; /* i bit set for *stream[i] not NULL */
struct pipe_vertex_buffer vtxbuf[PIPE_MAX_ATTRIBS]; /* vtxbuf.buffer unused */
unsigned last_vtxbuf_count;
UINT stream_freq[PIPE_MAX_ATTRIBS];
struct pipe_clip_state clip;
@ -283,6 +285,8 @@ struct nine_context {
struct NineVertexDeclaration9 *vdecl;
struct pipe_vertex_buffer vtxbuf[PIPE_MAX_ATTRIBS];
uint32_t vtxbuf_mask; /* i bit set for context->vtxbuf[i].buffer.resource not NULL */
uint32_t last_vtxbuf_count;
UINT stream_freq[PIPE_MAX_ATTRIBS];
uint32_t stream_instancedata_mask; /* derived from stream_freq */
uint32_t stream_usage_mask; /* derived from VS and vdecl */
@ -318,7 +322,6 @@ struct nine_context {
uint16_t enabled_samplers_mask_ps;
int dummy_vbo_bound_at; /* -1 = not bound , >= 0 = bound index */
bool vbo_bound_done;
bool inline_constants;

2
src/gallium/include/pipe/p_context.h
View file

@ -604,7 +604,6 @@ struct pipe_context {
/**
* Bind an array of vertex buffers to the specified slots.
*
* \param start_slot first vertex buffer slot
* \param count number of consecutive vertex buffers to bind.
* \param unbind_num_trailing_slots unbind slots after the bound slots
* \param take_ownership the caller holds buffer references and they
@ -613,7 +612,6 @@ struct pipe_context {
* \param buffers array of the buffers to bind
*/
void (*set_vertex_buffers)(struct pipe_context *,
unsigned start_slot,
unsigned num_buffers,
unsigned unbind_num_trailing_slots,
bool take_ownership,

2
src/gallium/tests/trivial/quad-tex.c
View file

@ -335,7 +335,7 @@ static void draw(struct program *p)
cso_set_vertex_elements(p->cso, &p->velem);
util_draw_vertex_buffer(p->pipe, p->cso,
p->vbuf, 0, 0,
p->vbuf, 0,
MESA_PRIM_QUADS,
4, /* verts */
2); /* attribs/vert */

2
src/gallium/tests/trivial/tri.c
View file

@ -267,7 +267,7 @@ static void draw(struct program *p)
cso_set_vertex_elements(p->cso, &p->velem);
util_draw_vertex_buffer(p->pipe, p->cso,
p->vbuf, 0, 0,
p->vbuf, 0,
MESA_PRIM_TRIANGLES,
3, /* verts */
2); /* attribs/vert */

4
src/gallium/tools/trace/dump_state.py
View file

@ -471,8 +471,8 @@ class Context(Dispatcher):
# XXX: deprecated
self._state.vs.sampler_views = views
def set_vertex_buffers(self, start_slot, num_buffers, unbind_num_trailing_slots, take_ownership, buffers):
self._update(self._state.vertex_buffers, start_slot, num_buffers, buffers)
def set_vertex_buffers(self, num_buffers, unbind_num_trailing_slots, take_ownership, buffers):
self._update(self._state.vertex_buffers, 0, num_buffers, buffers)
def create_vertex_elements_state(self, num_elements, elements):
return elements[0:num_elements]

2
src/mesa/state_tracker/st_atom_array.cpp
View file

@ -357,7 +357,7 @@ st_update_array_templ(struct st_context *st,
st->uses_user_vertex_buffers = uses_user_vertex_buffers;
} else {
/* Only vertex buffers. */
cso_set_vertex_buffers(cso, 0, num_vbuffers, unbind_trailing_vbuffers,
cso_set_vertex_buffers(cso, num_vbuffers, unbind_trailing_vbuffers,
true, vbuffer);
/* This can change only when we update vertex elements. */
assert(st->uses_user_vertex_buffers == uses_user_vertex_buffers);

2
src/mesa/state_tracker/st_cb_drawtex.c
View file

@ -295,7 +295,7 @@ st_DrawTex(struct gl_context *ctx, GLfloat x, GLfloat y, GLfloat z,
cso_set_viewport(cso, &vp);
}
util_draw_vertex_buffer(pipe, cso, vbuffer, 0,
util_draw_vertex_buffer(pipe, cso, vbuffer,
offset, /* offset */
MESA_PRIM_TRIANGLE_FAN,
4, /* verts */

2
src/mesa/state_tracker/st_draw.c
View file

@ -477,7 +477,7 @@ st_draw_quad(struct st_context *st,
u_upload_unmap(st->pipe->stream_uploader);
cso_set_vertex_buffers(st->cso_context, 0, 1, 0, false, &vb);
cso_set_vertex_buffers(st->cso_context, 1, 0, false, &vb);
st->last_num_vbuffers = MAX2(st->last_num_vbuffers, 1);
if (num_instances > 1) {

4
src/mesa/state_tracker/st_draw_feedback.c
View file

@ -166,7 +166,7 @@ st_feedback_draw_vbo(struct gl_context *ctx,
}
}
draw_set_vertex_buffers(draw, 0, num_vbuffers, 0, vbuffers);
draw_set_vertex_buffers(draw, num_vbuffers, 0, vbuffers);
draw_set_vertex_elements(draw, vp->num_inputs, velements.velems);
if (info->index_size) {
@ -465,7 +465,7 @@ st_feedback_draw_vbo(struct gl_context *ctx,
if (!vbuffers[buf].is_user_buffer)
pipe_resource_reference(&vbuffers[buf].buffer.resource, NULL);
}
draw_set_vertex_buffers(draw, 0, 0, num_vbuffers, NULL);
draw_set_vertex_buffers(draw, 0, num_vbuffers, NULL);
draw_bind_vertex_shader(draw, NULL);
}

2
src/mesa/state_tracker/st_pbo.c
View file

@ -246,7 +246,7 @@ st_pbo_draw(struct st_context *st, const struct st_pbo_addresses *addr,
cso_set_vertex_elements(cso, &velem);
cso_set_vertex_buffers(cso, 0, 1, 0, false, &vbo);
cso_set_vertex_buffers(cso, 1, 0, false, &vbo);
st->last_num_vbuffers = MAX2(st->last_num_vbuffers, 1);
pipe_resource_reference(&vbo.buffer.resource, NULL);