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
 147    while (mask) {
 148       /* The attribute index to start pulling a binding */
 149       const gl_vert_attrib i = ffs(mask) - 1;
 150       const struct gl_vertex_buffer_binding *const binding
 151          = _mesa_draw_buffer_binding(vao, i);
 152       const unsigned bufidx = (*num_vbuffers)++;
 153
 154       if (_mesa_is_bufferobj(binding->BufferObj)) {
 155          /* Set the binding */
 156          struct st_buffer_object *stobj = st_buffer_object(binding->BufferObj);
 157
 158          vbuffer[bufidx].buffer.resource = stobj ? stobj->buffer : NULL;
 159          vbuffer[bufidx].is_user_buffer = false;
 160          vbuffer[bufidx].buffer_offset = _mesa_draw_binding_offset(binding);
 161       } else {
 162          /* Set the binding */
 163          const void *ptr = (const void *)_mesa_draw_binding_offset(binding);
 164          vbuffer[bufidx].buffer.user = ptr;
 165          vbuffer[bufidx].is_user_buffer = true;
 166          vbuffer[bufidx].buffer_offset = 0;
 167
 168          if (!binding->InstanceDivisor)
 169             st->draw_needs_minmax_index = true;
 170       }
 171       vbuffer[bufidx].stride = binding->Stride; /* in bytes */
 172
 173       const GLbitfield boundmask = _mesa_draw_bound_attrib_bits(binding);
 174       GLbitfield attrmask = mask & boundmask;
 175       /* Mark the those attributes as processed */
 176       mask &= ~boundmask;
 177       /* We can assume that we have array for the binding */
 178       assert(attrmask);
 179       /* Walk attributes belonging to the binding */
 180       while (attrmask) {
 181          const gl_vert_attrib attr = u_bit_scan(&attrmask);
 182          const struct gl_array_attributes *const attrib
 183             = _mesa_draw_array_attrib(vao, attr);
 184          const GLuint off = _mesa_draw_attributes_relative_offset(attrib);
 185          init_velement(vp, velements, &attrib->Format, off,
 186                        binding->InstanceDivisor, bufidx,
 187                        input_to_index[attr]);
 188       }
 189    }
 190 }
 191
 192 /* ALWAYS_INLINE helps the compiler realize that most of the parameters are
 193  * on the stack.
 194  */
 195 void ALWAYS_INLINE
 196 st_setup_current(struct st_context *st,
 197                  const struct st_vertex_program *vp,
 198                  const struct st_common_variant *vp_variant,
 199                  struct pipe_vertex_element *velements,
 200                  struct pipe_vertex_buffer *vbuffer, unsigned *num_vbuffers)
 201 {
 202    struct gl_context *ctx = st->ctx;
 203    const GLbitfield inputs_read = vp_variant->vert_attrib_mask;
 204
 205    /* Process values that should have better been uniforms in the application */
 206    GLbitfield curmask = inputs_read & _mesa_draw_current_bits(ctx);
 207    if (curmask) {
 208       const ubyte *input_to_index = vp->input_to_index;
 209       /* For each attribute, upload the maximum possible size. */
 210       GLubyte data[VERT_ATTRIB_MAX * sizeof(GLdouble) * 4];
 211       GLubyte *cursor = data;
 212       const unsigned bufidx = (*num_vbuffers)++;
 213       unsigned max_alignment = 1;
 214
 215       while (curmask) {
 216          const gl_vert_attrib attr = u_bit_scan(&curmask);
 217          const struct gl_array_attributes *const attrib
 218             = _mesa_draw_current_attrib(ctx, attr);
 219          const unsigned size = attrib->Format._ElementSize;
 220          const unsigned alignment = util_next_power_of_two(size);
 221          max_alignment = MAX2(max_alignment, alignment);
 222          memcpy(cursor, attrib->Ptr, size);
 223          if (alignment != size)
 224             memset(cursor + size, 0, alignment - size);
 225
 226          init_velement(vp, velements, &attrib->Format, cursor - data, 0,
 227                        bufidx, input_to_index[attr]);
 228
 229          cursor += alignment;
 230       }
 231
 232       vbuffer[bufidx].is_user_buffer = false;
 233       vbuffer[bufidx].buffer.resource = NULL;
 234       /* vbuffer[bufidx].buffer_offset is set below */
 235       vbuffer[bufidx].stride = 0;
 236
 237       /* Use const_uploader for zero-stride vertex attributes, because
 238        * it may use a better memory placement than stream_uploader.
 239        * The reason is that zero-stride attributes can be fetched many
 240        * times (thousands of times), so a better placement is going to
 241        * perform better.
 242        */
 243       struct u_upload_mgr *uploader = st->can_bind_const_buffer_as_vertex ?
 244                                       st->pipe->const_uploader :
 245                                       st->pipe->stream_uploader;
 246       u_upload_data(uploader,
 247                     0, cursor - data, max_alignment, data,
 248                     &vbuffer[bufidx].buffer_offset,
 249                     &vbuffer[bufidx].buffer.resource);
 250       /* Always unmap. The uploader might use explicit flushes. */
 251       u_upload_unmap(uploader);
 252    }
 253 }
 254
 255 void
 256 st_setup_current_user(struct st_context *st,
 257                       const struct st_vertex_program *vp,
 258                       const struct st_common_variant *vp_variant,
 259                       struct pipe_vertex_element *velements,
 260                       struct pipe_vertex_buffer *vbuffer, unsigned *num_vbuffers)
 261 {
 262    struct gl_context *ctx = st->ctx;
 263    const GLbitfield inputs_read = vp_variant->vert_attrib_mask;
 264    const ubyte *input_to_index = vp->input_to_index;
 265
 266    /* Process values that should have better been uniforms in the application */
 267    GLbitfield curmask = inputs_read & _mesa_draw_current_bits(ctx);
 268    /* For each attribute, make an own user buffer binding. */
 269    while (curmask) {
 270       const gl_vert_attrib attr = u_bit_scan(&curmask);
 271       const struct gl_array_attributes *const attrib
 272          = _mesa_draw_current_attrib(ctx, attr);
 273       const unsigned bufidx = (*num_vbuffers)++;
 274
 275       init_velement(vp, velements, &attrib->Format, 0, 0,
 276                     bufidx, input_to_index[attr]);
 277
 278       vbuffer[bufidx].is_user_buffer = true;
 279       vbuffer[bufidx].buffer.user = attrib->Ptr;
 280       vbuffer[bufidx].buffer_offset = 0;
 281       vbuffer[bufidx].stride = 0;
 282    }
 283 }
 284
 285 void
 286 st_update_array(struct st_context *st)
 287 {
 288    /* vertex program validation must be done before this */
 289    /* _NEW_PROGRAM, ST_NEW_VS_STATE */
 290    const struct st_vertex_program *vp = (struct st_vertex_program *)st->vp;
 291    const struct st_common_variant *vp_variant = st->vp_variant;
 292
 293    struct pipe_vertex_buffer vbuffer[PIPE_MAX_ATTRIBS];
 294    unsigned num_vbuffers = 0, first_upload_vbuffer;
 295    struct pipe_vertex_element velements[PIPE_MAX_ATTRIBS];
 296    unsigned num_velements;
 297    bool uses_user_vertex_buffers;
 298
 299    st->draw_needs_minmax_index = false;
 300
 301    /* ST_NEW_VERTEX_ARRAYS alias ctx->DriverFlags.NewArray */
 302    /* Setup arrays */
 303    st_setup_arrays(st, vp, vp_variant, velements, vbuffer, &num_vbuffers,
 304                    &uses_user_vertex_buffers);
 305
 306    /* _NEW_CURRENT_ATTRIB */
 307    /* Setup current uploads */
 308    first_upload_vbuffer = num_vbuffers;
 309    st_setup_current(st, vp, vp_variant, velements, vbuffer, &num_vbuffers);
 310
 311    /* Set the array into cso */
 312    num_velements = vp->num_inputs + vp_variant->key.passthrough_edgeflags;
 313
 314    /* Set vertex buffers and elements. */
 315    struct cso_context *cso = st->cso_context;
 316    unsigned unbind_trailing_vbuffers =
 317       st->last_num_vbuffers > num_vbuffers ?
 318          st->last_num_vbuffers - num_vbuffers : 0;
 319    cso_set_vertex_buffers_and_elements(cso, num_velements, velements,
 320                                        num_vbuffers,
 321                                        unbind_trailing_vbuffers,
 322                                        vbuffer, uses_user_vertex_buffers);
 323    st->last_num_vbuffers = num_vbuffers;
 324
 325    /* Unreference uploaded buffer resources. */
 326    for (unsigned i = first_upload_vbuffer; i < num_vbuffers; ++i) {
 327       pipe_resource_reference(&vbuffer[i].buffer.resource, NULL);
 328    }
 329 }