I have this issue on radeonsi as well, but the bad commit is:
commit f1998e15ffccf260552bf559abe1a733a8ce990e
Author: Erik Faye-Lund <erik.faye-l...@collabora.com>
Date: Wed Nov 21 20:09:46 2018 +0100
mesa/main: remove ARB suffix from glGetnTexImage
This function has been core since OpenGL 4.3, so naming the
implementation and reporting erros using an ARB-suffix can be
confusing.
Signed-off-by: Erik Faye-Lund <erik.faye-l...@collabora.com>
Reviewed-by: Juan A. Suarez <jasua...@igalia.com>
Reverting the commit fixes supertuxkart.
Marek
On Mon, Nov 26, 2018 at 1:40 PM Erik Faye-Lund <erik.faye-l...@collabora.com>
wrote:
> On Mon, 2018-05-07 at 08:14 +0200, mathias.froehl...@gmx.net wrote:
> > From: Mathias Fröhlich <mathias.froehl...@web.de>
> >
> > Finally make use of the binding information in the VAO when
> > setting up arrays for draw.
> >
> > v2: Emit less relocations also for interleaved userspace arrays.
> >
> > Signed-off-by: Mathias Fröhlich <mathias.froehl...@web.de>
>
> I know this is *very* late notice, but this commit broke Super Tux Kart
> on VirGL. Both the player-models as as well as the level data renders
> with gibberish vertex positions since this commit.
>
> The fix that Rob Clark did on top does not fix the problem (and
> shouldn't have; VirGL doesn't use NIR).
>
> > ---
> > src/mesa/state_tracker/st_atom_array.c | 432 ++++++++---------------
> > ----------
> > 1 file changed, 107 insertions(+), 325 deletions(-)
> >
> > diff --git a/src/mesa/state_tracker/st_atom_array.c
> > b/src/mesa/state_tracker/st_atom_array.c
> > index 2fd67e8d84..6b39b4186d 100644
> > --- a/src/mesa/state_tracker/st_atom_array.c
> > +++ b/src/mesa/state_tracker/st_atom_array.c
> > @@ -48,6 +48,7 @@
> > #include "main/bufferobj.h"
> > #include "main/glformats.h"
> > #include "main/varray.h"
> > +#include "main/arrayobj.h"
> >
> > /* vertex_formats[gltype - GL_BYTE][integer*2 + normalized][size -
> > 1] */
> > static const uint16_t vertex_formats[][4][4] = {
> > @@ -306,79 +307,6 @@ st_pipe_vertex_format(const struct
> > gl_array_attributes *attrib)
> > return vertex_formats[type - GL_BYTE][index][size-1];
> > }
> >
> > -static const struct gl_vertex_array *
> > -get_client_array(const struct gl_vertex_array *arrays,
> > - unsigned mesaAttr)
> > -{
> > - /* st_program uses 0xffffffff to denote a double placeholder
> > attribute */
> > - if (mesaAttr == ST_DOUBLE_ATTRIB_PLACEHOLDER)
> > - return NULL;
> > - return &arrays[mesaAttr];
> > -}
> > -
> > -/**
> > - * Examine the active arrays to determine if we have interleaved
> > - * vertex arrays all living in one VBO, or all living in user space.
> > - */
> > -static GLboolean
> > -is_interleaved_arrays(const struct st_vertex_program *vp,
> > - const struct gl_vertex_array *arrays,
> > - unsigned num_inputs)
> > -{
> > - GLuint attr;
> > - const struct gl_buffer_object *firstBufObj = NULL;
> > - GLint firstStride = -1;
> > - const GLubyte *firstPtr = NULL;
> > - GLboolean userSpaceBuffer = GL_FALSE;
> > -
> > - for (attr = 0; attr < num_inputs; attr++) {
> > - const struct gl_vertex_array *array;
> > - const struct gl_vertex_buffer_binding *binding;
> > - const struct gl_array_attributes *attrib;
> > - const GLubyte *ptr;
> > - const struct gl_buffer_object *bufObj;
> > - GLsizei stride;
> > -
> > - array = get_client_array(arrays, vp->index_to_input[attr]);
> > - if (!array)
> > - continue;
> > -
> > - binding = array->BufferBinding;
> > - attrib = array->VertexAttrib;
> > - stride = binding->Stride; /* in bytes */
> > - ptr = _mesa_vertex_attrib_address(attrib, binding);
> > -
> > - /* To keep things simple, don't allow interleaved zero-stride
> > attribs. */
> > - if (stride == 0)
> > - return false;
> > -
> > - bufObj = binding->BufferObj;
> > - if (attr == 0) {
> > - /* save info about the first array */
> > - firstStride = stride;
> > - firstPtr = ptr;
> > - firstBufObj = bufObj;
> > - userSpaceBuffer = !_mesa_is_bufferobj(bufObj);
> > - }
> > - else {
> > - /* check if other arrays interleave with the first, in same
> > buffer */
> > - if (stride != firstStride)
> > - return GL_FALSE; /* strides don't match */
> > -
> > - if (bufObj != firstBufObj)
> > - return GL_FALSE; /* arrays in different VBOs */
> > -
> > - if (llabs(ptr - firstPtr) > firstStride)
> > - return GL_FALSE; /* arrays start too far apart */
> > -
> > - if ((!_mesa_is_bufferobj(bufObj)) != userSpaceBuffer)
> > - return GL_FALSE; /* mix of VBO and user-space arrays */
> > - }
> > - }
> > -
> > - return GL_TRUE;
> > -}
> > -
> > static void init_velement(struct pipe_vertex_element *velement,
> > int src_offset, int format,
> > int instance_divisor, int vbo_index)
> > @@ -392,13 +320,14 @@ static void init_velement(struct
> > pipe_vertex_element *velement,
> >
> > static void init_velement_lowered(const struct st_vertex_program
> > *vp,
> > struct pipe_vertex_element
> > *velements,
> > - int src_offset, int format,
> > - int instance_divisor, int
> > vbo_index,
> > - int nr_components, GLboolean
> > doubles,
> > - GLuint *attr_idx)
> > + const struct gl_array_attributes
> > *attrib,
> > + int src_offset, int
> > instance_divisor,
> > + int vbo_index, int idx)
> > {
> > - int idx = *attr_idx;
> > - if (doubles) {
> > + const unsigned format = st_pipe_vertex_format(attrib);
> > + const GLubyte nr_components = attrib->Size;
> > +
> > + if (attrib->Doubles) {
> > int lower_format;
> >
> > if (nr_components < 2)
> > @@ -427,15 +356,11 @@ static void init_velement_lowered(const struct
> > st_vertex_program *vp,
> > init_velement(&velements[idx], src_offset,
> > PIPE_FORMAT_R32G32_UINT,
> > instance_divisor, vbo_index);
> > }
> > -
> > - idx++;
> > }
> > } else {
> > init_velement(&velements[idx], src_offset,
> > format, instance_divisor, vbo_index);
> > - idx++;
> > }
> > - *attr_idx = idx;
> > }
> >
> > static void
> > @@ -457,274 +382,131 @@ set_vertex_attribs(struct st_context *st,
> > cso_set_vertex_elements(cso, num_velements, velements);
> > }
> >
> > -/**
> > - * Set up for drawing interleaved arrays that all live in one VBO
> > - * or all live in user space.
> > - * \param vbuffer returns vertex buffer info
> > - * \param velements returns vertex element info
> > - */
> > -static void
> > -setup_interleaved_attribs(struct st_context *st,
> > - const struct st_vertex_program *vp,
> > - const struct gl_vertex_array *arrays,
> > - unsigned num_inputs)
> > -{
> > - struct pipe_vertex_buffer vbuffer;
> > - struct pipe_vertex_element velements[PIPE_MAX_ATTRIBS] = {{0}};
> > - GLuint attr;
> > - const GLubyte *low_addr = NULL;
> > - GLboolean usingVBO; /* all arrays in a VBO? */
> > - struct gl_buffer_object *bufobj;
> > - GLsizei stride;
> > -
> > - /* Find the lowest address of the arrays we're drawing,
> > - * Init bufobj and stride.
> > - */
> > - if (num_inputs) {
> > - const struct gl_vertex_array *array;
> > - const struct gl_vertex_buffer_binding *binding;
> > - const struct gl_array_attributes *attrib;
> > -
> > - array = get_client_array(arrays, vp->index_to_input[0]);
> > - assert(array);
> > -
> > - binding = array->BufferBinding;
> > - attrib = array->VertexAttrib;
> > -
> > - /* Since we're doing interleaved arrays, we know there'll be
> > at most
> > - * one buffer object and the stride will be the same for all
> > arrays.
> > - * Grab them now.
> > - */
> > - bufobj = binding->BufferObj;
> > - stride = binding->Stride;
> > -
> > - low_addr = _mesa_vertex_attrib_address(attrib, binding);
> > -
> > - for (attr = 1; attr < num_inputs; attr++) {
> > - const GLubyte *start;
> > - array = get_client_array(arrays, vp->index_to_input[attr]);
> > - if (!array)
> > - continue;
> > - binding = array->BufferBinding;
> > - attrib = array->VertexAttrib;
> > - start = _mesa_vertex_attrib_address(attrib, binding);
> > - low_addr = MIN2(low_addr, start);
> > - }
> > - }
> > - else {
> > - /* not sure we'll ever have zero inputs, but play it safe */
> > - bufobj = NULL;
> > - stride = 0;
> > - low_addr = 0;
> > - }
> > -
> > - /* are the arrays in user space? */
> > - usingVBO = _mesa_is_bufferobj(bufobj);
> > -
> > - for (attr = 0; attr < num_inputs;) {
> > - const struct gl_vertex_array *array;
> > - const struct gl_vertex_buffer_binding *binding;
> > - const struct gl_array_attributes *attrib;
> > - const GLubyte *ptr;
> > - unsigned src_offset;
> > - unsigned src_format;
> > -
> > - array = get_client_array(arrays, vp->index_to_input[attr]);
> > - assert(array);
> > -
> > - binding = array->BufferBinding;
> > - attrib = array->VertexAttrib;
> > - ptr = _mesa_vertex_attrib_address(attrib, binding);
> > -
> > - src_offset = (unsigned) (ptr - low_addr);
> > -
> > - src_format = st_pipe_vertex_format(attrib);
> > -
> > - init_velement_lowered(vp, velements, src_offset, src_format,
> > - binding->InstanceDivisor, 0,
> > - attrib->Size, attrib->Doubles, &attr);
> > - }
> > -
> > - /*
> > - * Return the vbuffer info and setup user-space attrib info, if
> > needed.
> > - */
> > - if (num_inputs == 0) {
> > - /* just defensive coding here */
> > - vbuffer.buffer.resource = NULL;
> > - vbuffer.is_user_buffer = false;
> > - vbuffer.buffer_offset = 0;
> > - vbuffer.stride = 0;
> > - }
> > - else if (usingVBO) {
> > - /* all interleaved arrays in a VBO */
> > - struct st_buffer_object *stobj = st_buffer_object(bufobj);
> > -
> > - if (!stobj || !stobj->buffer) {
> > - st->vertex_array_out_of_memory = true;
> > - return; /* out-of-memory error probably */
> > - }
> > -
> > - vbuffer.buffer.resource = stobj->buffer;
> > - vbuffer.is_user_buffer = false;
> > - vbuffer.buffer_offset = pointer_to_offset(low_addr);
> > - vbuffer.stride = stride;
> > - }
> > - else {
> > - /* all interleaved arrays in user memory */
> > - vbuffer.buffer.user = low_addr;
> > - vbuffer.is_user_buffer = !!low_addr; /* if NULL, then unbind
> > */
> > - vbuffer.buffer_offset = 0;
> > - vbuffer.stride = stride;
> > -
> > - if (low_addr)
> > - st->draw_needs_minmax_index = true;
> > - }
> > -
> > - set_vertex_attribs(st, &vbuffer, num_inputs ? 1 : 0,
> > - velements, num_inputs);
> > -}
> > -
> > -/**
> > - * Set up a separate pipe_vertex_buffer and pipe_vertex_element for
> > each
> > - * vertex attribute.
> > - * \param vbuffer returns vertex buffer info
> > - * \param velements returns vertex element info
> > - */
> > -static void
> > -setup_non_interleaved_attribs(struct st_context *st,
> > - const struct st_vertex_program *vp,
> > - const struct gl_vertex_array *arrays,
> > - unsigned num_inputs)
> > +void st_update_array(struct st_context *st)
> > {
> > struct gl_context *ctx = st->ctx;
> > + /* vertex program validation must be done before this */
> > + const struct st_vertex_program *vp = st->vp;
> > + /* _NEW_PROGRAM, ST_NEW_VS_STATE */
> > + const GLbitfield inputs_read = st->vp_variant->vert_attrib_mask;
> > + const struct gl_vertex_array_object *vao = ctx->Array._DrawVAO;
> > + const ubyte *input_to_index = vp->input_to_index;
> > +
> > struct pipe_vertex_buffer vbuffer[PIPE_MAX_ATTRIBS];
> > - struct pipe_vertex_element velements[PIPE_MAX_ATTRIBS] = {{0}};
> > + struct pipe_vertex_element velements[PIPE_MAX_ATTRIBS];
> > unsigned num_vbuffers = 0;
> > - unsigned unref_buffers = 0;
> > - GLuint attr;
> > -
> > - for (attr = 0; attr < num_inputs;) {
> > - const unsigned mesaAttr = vp->index_to_input[attr];
> > - const struct gl_vertex_array *array;
> > - const struct gl_vertex_buffer_binding *binding;
> > - const struct gl_array_attributes *attrib;
> > - struct gl_buffer_object *bufobj;
> > - GLsizei stride;
> > - unsigned src_format;
> > - unsigned bufidx;
> > -
> > - array = get_client_array(arrays, mesaAttr);
> > - assert(array);
> > -
> > - bufidx = num_vbuffers++;
> > -
> > - binding = array->BufferBinding;
> > - attrib = array->VertexAttrib;
> > - stride = binding->Stride;
> > - bufobj = binding->BufferObj;
> > -
> > - if (_mesa_is_bufferobj(bufobj)) {
> > - /* Attribute data is in a VBO.
> > - * Recall that for VBOs, the gl_vertex_array->Ptr field is
> > - * really an offset from the start of the VBO, not a
> > pointer.
> > - */
> > - struct st_buffer_object *stobj = st_buffer_object(bufobj);
> >
> > + st->vertex_array_out_of_memory = FALSE;
> > + st->draw_needs_minmax_index = false;
> > +
> > + /* _NEW_PROGRAM */
> > + /* ST_NEW_VERTEX_ARRAYS alias ctx->DriverFlags.NewArray */
> > + /* Process attribute array data. */
> > + GLbitfield mask = inputs_read & _mesa_draw_array_bits(ctx);
> > + while (mask) {
> > + /* The attribute index to start pulling a binding */
> > + const gl_vert_attrib i = ffs(mask) - 1;
> > + const struct gl_vertex_buffer_binding *const binding
> > + = _mesa_draw_buffer_binding(vao, i);
> > + const unsigned bufidx = num_vbuffers++;
> > +
> > + if (_mesa_is_bufferobj(binding->BufferObj)) {
> > + struct st_buffer_object *stobj = st_buffer_object(binding-
> > >BufferObj);
> > if (!stobj || !stobj->buffer) {
> > st->vertex_array_out_of_memory = true;
> > return; /* out-of-memory error probably */
> > }
> >
> > + /* Set the binding */
> > vbuffer[bufidx].buffer.resource = stobj->buffer;
> > vbuffer[bufidx].is_user_buffer = false;
> > - vbuffer[bufidx].buffer_offset =
> > - binding->Offset + attrib->RelativeOffset;
> > + vbuffer[bufidx].buffer_offset =
> > _mesa_draw_binding_offset(binding);
> > + } else {
> > + /* Set the binding */
> > + const void *ptr = (const void
> > *)_mesa_draw_binding_offset(binding);
> > + vbuffer[bufidx].buffer.user = ptr;
> > + vbuffer[bufidx].is_user_buffer = true;
> > + vbuffer[bufidx].buffer_offset = 0;
> > +
> > + if (!binding->InstanceDivisor)
> > + st->draw_needs_minmax_index = true;
> > }
> > - else {
> > - if (stride == 0) {
> > - unsigned size = attrib->_ElementSize;
> > - /* This is optimal for GPU cache line usage if the
> > upload size
> > - * is <= cache line size.
> > - */
> > - unsigned alignment = util_next_power_of_two(size);
> > -
> > - assert(attrib->Ptr);
> > - vbuffer[bufidx].buffer.user = attrib->Ptr;
> > - void *ptr = attrib->Ptr ? (void*)attrib->Ptr :
> > - (void*)ctx-
> > >Current.Attrib[mesaAttr];
> > -
> > - vbuffer[bufidx].is_user_buffer = false;
> > - vbuffer[bufidx].buffer.resource = NULL;
> > -
> > - /* Use const_uploader for zero-stride vertex attributes,
> > because
> > - * it may use a better memory placement than
> > stream_uploader.
> > - * The reason is that zero-stride attributes can be
> > fetched many
> > - * times (thousands of times), so a better placement is
> > going to
> > - * perform better.
> > - *
> > - * Upload the maximum possible size, which is 4x
> > GLdouble = 32.
> > - */
> > - u_upload_data(st->can_bind_const_buffer_as_vertex ?
> > - st->pipe->const_uploader :
> > - st->pipe->stream_uploader,
> > - 0, size, alignment, ptr,
> > - &vbuffer[bufidx].buffer_offset,
> > - &vbuffer[bufidx].buffer.resource);
> > - unref_buffers |= 1u << bufidx;
> > - } else {
> > - assert(attrib->Ptr);
> > - vbuffer[bufidx].buffer.user = attrib->Ptr;
> > - vbuffer[bufidx].is_user_buffer = true;
> > - vbuffer[bufidx].buffer_offset = 0;
> > -
> > - if (!binding->InstanceDivisor)
> > - st->draw_needs_minmax_index = true;
> > - }
> > + vbuffer[bufidx].stride = binding->Stride; /* in bytes */
> > +
> > + const GLbitfield boundmask =
> > _mesa_draw_bound_attrib_bits(binding);
> > + GLbitfield attrmask = mask & boundmask;
> > + /* Mark the those attributes as processed */
> > + mask &= ~boundmask;
> > + /* We can assume that we have array for the binding */
> > + assert(attrmask);
> > + /* Walk attributes belonging to the binding */
> > + while (attrmask) {
> > + const gl_vert_attrib attr = u_bit_scan(&attrmask);
> > + const struct gl_array_attributes *const attrib
> > + = _mesa_draw_array_attrib(vao, attr);
> > + const GLuint off =
> > _mesa_draw_attributes_relative_offset(attrib);
> > + init_velement_lowered(vp, velements, attrib, off,
> > + binding->InstanceDivisor, bufidx,
> > + input_to_index[attr]);
> > }
> > + }
> >
> > - /* common-case setup */
> > - vbuffer[bufidx].stride = stride; /* in bytes */
> > + const unsigned first_current_vbuffer = num_vbuffers;
> > + /* _NEW_PROGRAM | _NEW_CURRENT_ATTRIB */
> > + /* Process values that should have better been uniforms in the
> > application */
> > + GLbitfield curmask = inputs_read & _mesa_draw_current_bits(ctx);
> > + if (curmask) {
> > + /* For each attribute, upload the maximum possible size. */
> > + GLubyte data[VERT_ATTRIB_MAX*sizeof(GLdouble)*4];
> > + GLubyte *cursor = data;
> > + const unsigned bufidx = num_vbuffers++;
> > + unsigned max_alignment = 1;
> > +
> > + while (curmask) {
> > + const gl_vert_attrib attr = u_bit_scan(&curmask);
> > + const struct gl_array_attributes *const attrib
> > + = _mesa_draw_current_attrib(ctx, attr);
> > + const unsigned size = attrib->_ElementSize;
> > + const unsigned alignment = util_next_power_of_two(size);
> > + max_alignment = MAX2(max_alignment, alignment);
> > + memcpy(cursor, attrib->Ptr, size);
> > + if (alignment != size)
> > + memset(cursor + size, 0, alignment - size);
> > +
> > + init_velement_lowered(vp, velements, attrib, cursor - data,
> > 0,
> > + bufidx, input_to_index[attr]);
> > +
> > + cursor += alignment;
> > + }
> >
> > - src_format = st_pipe_vertex_format(attrib);
> > + vbuffer[bufidx].is_user_buffer = false;
> > + vbuffer[bufidx].buffer.resource = NULL;
> > + /* vbuffer[bufidx].buffer_offset is set below */
> > + vbuffer[bufidx].stride = 0;
> >
> > - init_velement_lowered(vp, velements, 0, src_format,
> > - binding->InstanceDivisor, bufidx,
> > - attrib->Size, attrib->Doubles, &attr);
> > + /* Use const_uploader for zero-stride vertex attributes,
> > because
> > + * it may use a better memory placement than stream_uploader.
> > + * The reason is that zero-stride attributes can be fetched
> > many
> > + * times (thousands of times), so a better placement is going
> > to
> > + * perform better.
> > + */
> > + u_upload_data(st->can_bind_const_buffer_as_vertex ?
> > + st->pipe->const_uploader :
> > + st->pipe->stream_uploader,
> > + 0, cursor - data, max_alignment, data,
> > + &vbuffer[bufidx].buffer_offset,
> > + &vbuffer[bufidx].buffer.resource);
> > }
> >
> > if (!ctx->Const.AllowMappedBuffersDuringExecution) {
> > u_upload_unmap(st->pipe->stream_uploader);
> > }
> >
> > + const unsigned num_inputs = st->vp_variant->num_inputs;
> > set_vertex_attribs(st, vbuffer, num_vbuffers, velements,
> > num_inputs);
> >
> > /* Unreference uploaded zero-stride vertex buffers. */
> > - while (unref_buffers) {
> > - unsigned i = u_bit_scan(&unref_buffers);
> > + for (unsigned i = first_current_vbuffer; i < num_vbuffers; ++i) {
> > pipe_resource_reference(&vbuffer[i].buffer.resource, NULL);
> > }
> > }
> > -
> > -void st_update_array(struct st_context *st)
> > -{
> > - struct gl_context *ctx = st->ctx;
> > - const struct gl_vertex_array *arrays = ctx->Array._DrawArrays;
> > - const struct st_vertex_program *vp;
> > - unsigned num_inputs;
> > -
> > - st->vertex_array_out_of_memory = FALSE;
> > - st->draw_needs_minmax_index = false;
> > -
> > - /* No drawing has been done yet, so do nothing. */
> > - if (!arrays)
> > - return;
> > -
> > - /* vertex program validation must be done before this */
> > - vp = st->vp;
> > - num_inputs = st->vp_variant->num_inputs;
> > -
> > - if (is_interleaved_arrays(vp, arrays, num_inputs))
> > - setup_interleaved_attribs(st, vp, arrays, num_inputs);
> > - else
> > - setup_non_interleaved_attribs(st, vp, arrays, num_inputs);
> > -}
>
> _______________________________________________
> mesa-dev mailing list
> mesa-dev@lists.freedesktop.org
> https://lists.freedesktop.org/mailman/listinfo/mesa-dev
>
_______________________________________________
mesa-dev mailing list
mesa-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/mesa-dev
