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