src/mesa/state_tracker/st_atom_array.c

   1
   2 /**************************************************************************
   3  *
   4  * Copyright 2007 VMware, Inc.
   5  * Copyright 2012 Marek Olšák <maraeo@gmail.com>
   6  * All Rights Reserved.
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and associated documentation files (the
  10  * "Software"), to deal in the Software without restriction, including
  11  * without limitation the rights to use, copy, modify, merge, publish,
  12  * distribute, sub license, and/or sell copies of the Software, and to
  13  * permit persons to whom the Software is furnished to do so, subject to
  14  * the following conditions:
  15  *
  16  * The above copyright notice and this permission notice (including the
  17  * next paragraph) shall be included in all copies or substantial portions
  18  * of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  21  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  23  * IN NO EVENT SHALL AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR
  24  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  25  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  26  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27  *
  28  **************************************************************************/
  29
  30 /*
  31  * This converts the VBO's vertex attribute/array information into
  32  * Gallium vertex state and binds it.
  33  *
  34  * Authors:
  35  *   Keith Whitwell <keithw@vmware.com>
  36  *   Marek Olšák <maraeo@gmail.com>
  37  */
  38
  39 #include "st_context.h"
  40 #include "st_atom.h"
  41 #include "st_cb_bufferobjects.h"
  42 #include "st_draw.h"
  43 #include "st_program.h"
  44
  45 #include "cso_cache/cso_context.h"
  46 #include "util/u_math.h"
  47 #include "util/u_upload_mgr.h"
  48 #include "main/bufferobj.h"
  49 #include "main/glformats.h"
  50 #include "main/varray.h"
  51 #include "main/arrayobj.h"
  52
  53 static void set_velement(struct pipe_vertex_element *velement,
  54                           int src_offset, int format,
  55                           int instance_divisor, int vbo_index)
  56 {
  57    velement->src_offset = src_offset;
  58    velement->src_format = format;
  59    velement->instance_divisor = instance_divisor;
  60    velement->vertex_buffer_index = vbo_index;
  61    assert(velement->src_format);
  62 }
  63
  64 static void init_velement_64bit(const struct st_vertex_program *vp,
  65                                 struct pipe_vertex_element *velements,
  66                                 const struct gl_vertex_format *vformat,
  67                                 int src_offset, int instance_divisor,
  68                                 int vbo_index, int idx)
  69 {
  70    const GLubyte nr_components = vformat->Size;
  71    int lower_format;
  72
  73    if (nr_components < 2)
  74       lower_format = PIPE_FORMAT_R32G32_UINT;
  75    else
  76       lower_format = PIPE_FORMAT_R32G32B32A32_UINT;
  77
  78    set_velement(&velements[idx], src_offset,
  79                 lower_format, instance_divisor, vbo_index);
  80    idx++;
  81
  82    if (idx < vp->num_inputs &&
  83        vp->index_to_input[idx] == ST_DOUBLE_ATTRIB_PLACEHOLDER) {
  84       if (nr_components >= 3) {
  85          if (nr_components == 3)
  86             lower_format = PIPE_FORMAT_R32G32_UINT;
  87          else
  88             lower_format = PIPE_FORMAT_R32G32B32A32_UINT;
  89
  90          set_velement(&velements[idx], src_offset + 4 * sizeof(float),
  91                       lower_format, instance_divisor, vbo_index);
  92       } else {
  93          /* The values here are undefined. Fill in some conservative
  94           * dummy values.
  95           */
  96          set_velement(&velements[idx], src_offset, PIPE_FORMAT_R32G32_UINT,
  97                       instance_divisor, vbo_index);
  98       }
  99    }
 100 }
 101
 102 /* Always inline the non-64bit element code, so that the compiler can see
 103  * that velements is on the stack.
 104  */
 105 static void ALWAYS_INLINE
 106 init_velement(const struct st_vertex_program *vp,
 107               struct pipe_vertex_element *velements,
 108               const struct gl_vertex_format *vformat,
 109               int src_offset, int instance_divisor,
 110               int vbo_index, int idx)
 111 {
 112    if (!vformat->Doubles) {
 113       velements[idx].src_offset = src_offset;
 114       velements[idx].src_format = vformat->_PipeFormat;
 115       velements[idx].instance_divisor = instance_divisor;
 116       velements[idx].vertex_buffer_index = vbo_index;
 117       assert(velements[idx].src_format);
 118       return;
 119    }
 120
 121    init_velement_64bit(vp, velements, vformat, src_offset, instance_divisor,
 122                        vbo_index, idx);
 123 }
 124
 125 /* ALWAYS_INLINE helps the compiler realize that most of the parameters are
 126  * on the stack.
 127  */
 128 void ALWAYS_INLINE
 129 st_setup_arrays(struct st_context *st,
 130                 const struct st_vertex_program *vp,
 131                 const struct st_common_variant *vp_variant,
 132                 struct pipe_vertex_element *velements,
 133                 struct pipe_vertex_buffer *vbuffer, unsigned *num_vbuffers,
 134                 bool *has_user_vertex_buffers)
 135 {
 136    struct gl_context *ctx = st->ctx;
 137    const struct gl_vertex_array_object *vao = ctx->Array._DrawVAO;
 138    const GLbitfield inputs_read = vp_variant->vert_attrib_mask;
 139    const ubyte *input_to_index = vp->input_to_index;
 140
 141    /* Process attribute array data. */
 142    GLbitfield mask = inputs_read & _mesa_draw_array_bits(ctx);
 143    GLbitfield userbuf_attribs = inputs_read & _mesa_draw_user_array_bits(ctx);
 144
 145    *has_user_vertex_buffers = userbuf_attribs != 0;
 146    st->draw_needs_minmax_index =
 147       (userbuf_attribs & ~_mesa_draw_nonzero_divisor_bits(ctx)) != 0;
 148
 149    while (mask) {
 150       /* The attribute index to start pulling a binding */
 151       const gl_vert_attrib i = ffs(mask) - 1;
 152       const struct gl_vertex_buffer_binding *const binding
 153          = _mesa_draw_buffer_binding(vao, i);
 154       const unsigned bufidx = (*num_vbuffers)++;
 155
 156       if (_mesa_is_bufferobj(binding->BufferObj)) {
 157          /* Set the binding */
 158          struct st_buffer_object *stobj = st_buffer_object(binding->BufferObj);
 159
 160          vbuffer[bufidx].buffer.resource = stobj ? stobj->buffer : NULL;
 161          vbuffer[bufidx].is_user_buffer = false;
 162          vbuffer[bufidx].buffer_offset = _mesa_draw_binding_offset(binding);
 163       } else {
 164          /* Set the binding */
 165          const void *ptr = (const void *)_mesa_draw_binding_offset(binding);
 166          vbuffer[bufidx].buffer.user = ptr;
 167          vbuffer[bufidx].is_user_buffer = true;
 168          vbuffer[bufidx].buffer_offset = 0;
 169       }
 170       vbuffer[bufidx].stride = binding->Stride; /* in bytes */
 171
 172       const GLbitfield boundmask = _mesa_draw_bound_attrib_bits(binding);
 173       GLbitfield attrmask = mask & boundmask;
 174       /* Mark the those attributes as processed */
 175       mask &= ~boundmask;
 176       /* We can assume that we have array for the binding */
 177       assert(attrmask);
 178       /* Walk attributes belonging to the binding */
 179       do {
 180          const gl_vert_attrib attr = u_bit_scan(&attrmask);
 181          const struct gl_array_attributes *const attrib
 182             = _mesa_draw_array_attrib(vao, attr);
 183          const GLuint off = _mesa_draw_attributes_relative_offset(attrib);
 184          init_velement(vp, velements, &attrib->Format, off,
 185                        binding->InstanceDivisor, bufidx,
 186                        input_to_index[attr]);
 187       } while (attrmask);
 188    }
 189 }
 190
 191 /* ALWAYS_INLINE helps the compiler realize that most of the parameters are
 192  * on the stack.
 193  *
 194  * Return the index of the vertex buffer where current attribs have been
 195  * uploaded.
 196  */
 197 static int ALWAYS_INLINE
 198 st_setup_current(struct st_context *st,
 199                  const struct st_vertex_program *vp,
 200                  const struct st_common_variant *vp_variant,
 201                  struct pipe_vertex_element *velements,
 202                  struct pipe_vertex_buffer *vbuffer, unsigned *num_vbuffers)
 203 {
 204    struct gl_context *ctx = st->ctx;
 205    const GLbitfield inputs_read = vp_variant->vert_attrib_mask;
 206
 207    /* Process values that should have better been uniforms in the application */
 208    GLbitfield curmask = inputs_read & _mesa_draw_current_bits(ctx);
 209    if (curmask) {
 210       const ubyte *input_to_index = vp->input_to_index;
 211       /* For each attribute, upload the maximum possible size. */
 212       GLubyte data[VERT_ATTRIB_MAX * sizeof(GLdouble) * 4];
 213       GLubyte *cursor = data;
 214       const unsigned bufidx = (*num_vbuffers)++;
 215       unsigned max_alignment = 1;
 216
 217       do {
 218          const gl_vert_attrib attr = u_bit_scan(&curmask);
 219          const struct gl_array_attributes *const attrib
 220             = _mesa_draw_current_attrib(ctx, attr);
 221          const unsigned size = attrib->Format._ElementSize;
 222          const unsigned alignment = util_next_power_of_two(size);
 223          max_alignment = MAX2(max_alignment, alignment);
 224          memcpy(cursor, attrib->Ptr, size);
 225          if (alignment != size)
 226             memset(cursor + size, 0, alignment - size);
 227
 228          init_velement(vp, velements, &attrib->Format, cursor - data, 0,
 229                        bufidx, input_to_index[attr]);
 230
 231          cursor += alignment;
 232       } while (curmask);
 233
 234       vbuffer[bufidx].is_user_buffer = false;
 235       vbuffer[bufidx].buffer.resource = NULL;
 236       /* vbuffer[bufidx].buffer_offset is set below */
 237       vbuffer[bufidx].stride = 0;
 238
 239       /* Use const_uploader for zero-stride vertex attributes, because
 240        * it may use a better memory placement than stream_uploader.
 241        * The reason is that zero-stride attributes can be fetched many
 242        * times (thousands of times), so a better placement is going to
 243        * perform better.
 244        */
 245       struct u_upload_mgr *uploader = st->can_bind_const_buffer_as_vertex ?
 246                                       st->pipe->const_uploader :
 247                                       st->pipe->stream_uploader;
 248       u_upload_data(uploader,
 249                     0, cursor - data, max_alignment, data,
 250                     &vbuffer[bufidx].buffer_offset,
 251                     &vbuffer[bufidx].buffer.resource);
 252       /* Always unmap. The uploader might use explicit flushes. */
 253       u_upload_unmap(uploader);
 254       return bufidx;
 255    }
 256    return -1;
 257 }
 258
 259 void
 260 st_setup_current_user(struct st_context *st,
 261                       const struct st_vertex_program *vp,
 262                       const struct st_common_variant *vp_variant,
 263                       struct pipe_vertex_element *velements,
 264                       struct pipe_vertex_buffer *vbuffer, unsigned *num_vbuffers)
 265 {
 266    struct gl_context *ctx = st->ctx;
 267    const GLbitfield inputs_read = vp_variant->vert_attrib_mask;
 268    const ubyte *input_to_index = vp->input_to_index;
 269
 270    /* Process values that should have better been uniforms in the application */
 271    GLbitfield curmask = inputs_read & _mesa_draw_current_bits(ctx);
 272    /* For each attribute, make an own user buffer binding. */
 273    while (curmask) {
 274       const gl_vert_attrib attr = u_bit_scan(&curmask);
 275       const struct gl_array_attributes *const attrib
 276          = _mesa_draw_current_attrib(ctx, attr);
 277       const unsigned bufidx = (*num_vbuffers)++;
 278
 279       init_velement(vp, velements, &attrib->Format, 0, 0,
 280                     bufidx, input_to_index[attr]);
 281
 282       vbuffer[bufidx].is_user_buffer = true;
 283       vbuffer[bufidx].buffer.user = attrib->Ptr;
 284       vbuffer[bufidx].buffer_offset = 0;
 285       vbuffer[bufidx].stride = 0;
 286    }
 287 }
 288
 289 void
 290 st_update_array(struct st_context *st)
 291 {
 292    /* vertex program validation must be done before this */
 293    /* _NEW_PROGRAM, ST_NEW_VS_STATE */
 294    const struct st_vertex_program *vp = (struct st_vertex_program *)st->vp;
 295    const struct st_common_variant *vp_variant = st->vp_variant;
 296
 297    struct pipe_vertex_buffer vbuffer[PIPE_MAX_ATTRIBS];
 298    unsigned num_vbuffers = 0;
 299    struct pipe_vertex_element velements[PIPE_MAX_ATTRIBS];
 300    unsigned num_velements;
 301    bool uses_user_vertex_buffers;
 302
 303    /* ST_NEW_VERTEX_ARRAYS alias ctx->DriverFlags.NewArray */
 304    /* Setup arrays */
 305    st_setup_arrays(st, vp, vp_variant, velements, vbuffer, &num_vbuffers,
 306                    &uses_user_vertex_buffers);
 307
 308    /* _NEW_CURRENT_ATTRIB */
 309    /* Setup zero-stride attribs. */
 310    int current_attrib_buffer =
 311       st_setup_current(st, vp, vp_variant, velements, vbuffer, &num_vbuffers);
 312
 313    /* Set the array into cso */
 314    num_velements = vp->num_inputs + vp_variant->key.passthrough_edgeflags;
 315
 316    /* Set vertex buffers and elements. */
 317    struct cso_context *cso = st->cso_context;
 318    unsigned unbind_trailing_vbuffers =
 319       st->last_num_vbuffers > num_vbuffers ?
 320          st->last_num_vbuffers - num_vbuffers : 0;
 321    cso_set_vertex_buffers_and_elements(cso, num_velements, velements,
 322                                        num_vbuffers,
 323                                        unbind_trailing_vbuffers,
 324                                        vbuffer, uses_user_vertex_buffers);
 325    st->last_num_vbuffers = num_vbuffers;
 326
 327    /* Unreference uploaded current attrib buffer. */
 328    if (current_attrib_buffer >= 0)
 329       pipe_resource_reference(&vbuffer[current_attrib_buffer].buffer.resource, NULL);
 330 }