src/gallium/auxiliary/util/u_vbuf_mgr.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2011 Marek Olšák <maraeo@gmail.com>
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28 #include "util/u_vbuf_mgr.h"
  29
  30 #include "util/u_format.h"
  31 #include "util/u_inlines.h"
  32 #include "util/u_memory.h"
  33 #include "util/u_upload_mgr.h"
  34 #include "translate/translate.h"
  35 #include "translate/translate_cache.h"
  36
  37 /* Hardware vertex fetcher limitations can be described by this structure. */
  38 struct u_vbuf_caps {
  39    /* Vertex format CAPs. */
  40    /* TRUE if hardware supports it. */
  41    unsigned format_fixed32:1;    /* PIPE_FORMAT_*32*_FIXED */
  42    unsigned format_float16:1;    /* PIPE_FORMAT_*16*_FLOAT */
  43    unsigned format_float64:1;    /* PIPE_FORMAT_*64*_FLOAT */
  44    unsigned format_norm32:1;     /* PIPE_FORMAT_*32*NORM */
  45    unsigned format_scaled32:1;   /* PIPE_FORMAT_*32*SCALED */
  46
  47    /* Whether vertex fetches don't have to be dword-aligned. */
  48    /* TRUE if hardware supports it. */
  49    unsigned fetch_dword_unaligned:1;
  50 };
  51
  52 struct u_vbuf_elements {
  53    unsigned count;
  54    struct pipe_vertex_element ve[PIPE_MAX_ATTRIBS];
  55
  56    unsigned src_format_size[PIPE_MAX_ATTRIBS];
  57
  58    /* If (velem[i].src_format != native_format[i]), the vertex buffer
  59     * referenced by the vertex element cannot be used for rendering and
  60     * its vertex data must be translated to native_format[i]. */
  61    enum pipe_format native_format[PIPE_MAX_ATTRIBS];
  62    unsigned native_format_size[PIPE_MAX_ATTRIBS];
  63
  64    /* This might mean two things:
  65     * - src_format != native_format, as discussed above.
  66     * - src_offset % 4 != 0 (if the caps don't allow such an offset). */
  67    boolean incompatible_layout;
  68 };
  69
  70 struct u_vbuf_priv {
  71    struct u_vbuf_mgr b;
  72    struct u_vbuf_caps caps;
  73    struct pipe_context *pipe;
  74
  75    struct translate_cache *translate_cache;
  76    unsigned translate_vb_slot;
  77
  78    struct u_vbuf_elements *ve;
  79    void *saved_ve, *fallback_ve;
  80    boolean ve_binding_lock;
  81
  82    boolean any_user_vbs;
  83    boolean incompatible_vb_layout;
  84 };
  85
  86 static void u_vbuf_init_format_caps(struct u_vbuf_priv *mgr)
  87 {
  88    struct pipe_screen *screen = mgr->pipe->screen;
  89
  90    mgr->caps.format_fixed32 =
  91       screen->is_format_supported(screen, PIPE_FORMAT_R32_FIXED, PIPE_BUFFER,
  92                                   0, PIPE_BIND_VERTEX_BUFFER);
  93
  94    mgr->caps.format_float16 =
  95       screen->is_format_supported(screen, PIPE_FORMAT_R16_FLOAT, PIPE_BUFFER,
  96                                   0, PIPE_BIND_VERTEX_BUFFER);
  97
  98    mgr->caps.format_float64 =
  99       screen->is_format_supported(screen, PIPE_FORMAT_R64_FLOAT, PIPE_BUFFER,
 100                                   0, PIPE_BIND_VERTEX_BUFFER);
 101
 102    mgr->caps.format_norm32 =
 103       screen->is_format_supported(screen, PIPE_FORMAT_R32_UNORM, PIPE_BUFFER,
 104                                   0, PIPE_BIND_VERTEX_BUFFER) &&
 105       screen->is_format_supported(screen, PIPE_FORMAT_R32_SNORM, PIPE_BUFFER,
 106                                   0, PIPE_BIND_VERTEX_BUFFER);
 107
 108    mgr->caps.format_scaled32 =
 109       screen->is_format_supported(screen, PIPE_FORMAT_R32_USCALED, PIPE_BUFFER,
 110                                   0, PIPE_BIND_VERTEX_BUFFER) &&
 111       screen->is_format_supported(screen, PIPE_FORMAT_R32_SSCALED, PIPE_BUFFER,
 112                                   0, PIPE_BIND_VERTEX_BUFFER);
 113 }
 114
 115 struct u_vbuf_mgr *
 116 u_vbuf_create(struct pipe_context *pipe,
 117               unsigned upload_buffer_size,
 118               unsigned upload_buffer_alignment,
 119               unsigned upload_buffer_bind,
 120               enum u_fetch_alignment fetch_alignment)
 121 {
 122    struct u_vbuf_priv *mgr = CALLOC_STRUCT(u_vbuf_priv);
 123
 124    mgr->pipe = pipe;
 125    mgr->translate_cache = translate_cache_create();
 126
 127    mgr->b.uploader = u_upload_create(pipe, upload_buffer_size,
 128                                      upload_buffer_alignment,
 129                                      upload_buffer_bind);
 130
 131    mgr->caps.fetch_dword_unaligned =
 132          fetch_alignment == U_VERTEX_FETCH_BYTE_ALIGNED;
 133
 134    u_vbuf_init_format_caps(mgr);
 135
 136    return &mgr->b;
 137 }
 138
 139 void u_vbuf_destroy(struct u_vbuf_mgr *mgrb)
 140 {
 141    struct u_vbuf_priv *mgr = (struct u_vbuf_priv*)mgrb;
 142    unsigned i;
 143
 144    for (i = 0; i < mgr->b.nr_vertex_buffers; i++) {
 145       pipe_resource_reference(&mgr->b.vertex_buffer[i].buffer, NULL);
 146    }
 147    for (i = 0; i < mgr->b.nr_real_vertex_buffers; i++) {
 148       pipe_resource_reference(&mgr->b.real_vertex_buffer[i].buffer, NULL);
 149    }
 150
 151    translate_cache_destroy(mgr->translate_cache);
 152    u_upload_destroy(mgr->b.uploader);
 153    FREE(mgr);
 154 }
 155
 156
 157 static void
 158 u_vbuf_translate_begin(struct u_vbuf_priv *mgr,
 159                        int min_index, int max_index)
 160 {
 161    struct translate_key key;
 162    struct translate_element *te;
 163    unsigned tr_elem_index[PIPE_MAX_ATTRIBS];
 164    struct translate *tr;
 165    boolean vb_translated[PIPE_MAX_ATTRIBS] = {0};
 166    uint8_t *vb_map[PIPE_MAX_ATTRIBS] = {0}, *out_map;
 167    struct pipe_transfer *vb_transfer[PIPE_MAX_ATTRIBS] = {0};
 168    struct pipe_resource *out_buffer = NULL;
 169    unsigned i, num_verts, out_offset;
 170    struct pipe_vertex_element new_velems[PIPE_MAX_ATTRIBS];
 171    boolean upload_flushed = FALSE;
 172
 173    memset(&key, 0, sizeof(key));
 174    memset(tr_elem_index, 0xff, sizeof(tr_elem_index));
 175
 176    /* Initialize the translate key, i.e. the recipe how vertices should be
 177      * translated. */
 178    memset(&key, 0, sizeof key);
 179    for (i = 0; i < mgr->ve->count; i++) {
 180       struct pipe_vertex_buffer *vb =
 181             &mgr->b.vertex_buffer[mgr->ve->ve[i].vertex_buffer_index];
 182       enum pipe_format output_format = mgr->ve->native_format[i];
 183       unsigned output_format_size = mgr->ve->native_format_size[i];
 184
 185       /* Check for support. */
 186       if (mgr->ve->ve[i].src_format == mgr->ve->native_format[i] &&
 187           (mgr->caps.fetch_dword_unaligned ||
 188            (vb->buffer_offset % 4 == 0 &&
 189             vb->stride % 4 == 0 &&
 190             mgr->ve->ve[i].src_offset % 4 == 0))) {
 191          continue;
 192       }
 193
 194       /* Workaround for translate: output floats instead of halfs. */
 195       switch (output_format) {
 196       case PIPE_FORMAT_R16_FLOAT:
 197          output_format = PIPE_FORMAT_R32_FLOAT;
 198          output_format_size = 4;
 199          break;
 200       case PIPE_FORMAT_R16G16_FLOAT:
 201          output_format = PIPE_FORMAT_R32G32_FLOAT;
 202          output_format_size = 8;
 203          break;
 204       case PIPE_FORMAT_R16G16B16_FLOAT:
 205          output_format = PIPE_FORMAT_R32G32B32_FLOAT;
 206          output_format_size = 12;
 207          break;
 208       case PIPE_FORMAT_R16G16B16A16_FLOAT:
 209          output_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
 210          output_format_size = 16;
 211          break;
 212       default:;
 213       }
 214
 215       /* Add this vertex element. */
 216       te = &key.element[key.nr_elements];
 217       /*te->type;
 218         te->instance_divisor;*/
 219       te->input_buffer = mgr->ve->ve[i].vertex_buffer_index;
 220       te->input_format = mgr->ve->ve[i].src_format;
 221       te->input_offset = mgr->ve->ve[i].src_offset;
 222       te->output_format = output_format;
 223       te->output_offset = key.output_stride;
 224
 225       key.output_stride += output_format_size;
 226       vb_translated[mgr->ve->ve[i].vertex_buffer_index] = TRUE;
 227       tr_elem_index[i] = key.nr_elements;
 228       key.nr_elements++;
 229    }
 230
 231    /* Get a translate object. */
 232    tr = translate_cache_find(mgr->translate_cache, &key);
 233
 234    /* Map buffers we want to translate. */
 235    for (i = 0; i < mgr->b.nr_vertex_buffers; i++) {
 236       if (vb_translated[i]) {
 237          struct pipe_vertex_buffer *vb = &mgr->b.vertex_buffer[i];
 238
 239          vb_map[i] = pipe_buffer_map(mgr->pipe, vb->buffer,
 240                                      PIPE_TRANSFER_READ, &vb_transfer[i]);
 241
 242          tr->set_buffer(tr, i,
 243                         vb_map[i] + vb->buffer_offset + vb->stride * min_index,
 244                         vb->stride, ~0);
 245       }
 246    }
 247
 248    /* Create and map the output buffer. */
 249    num_verts = max_index + 1 - min_index;
 250
 251    u_upload_alloc(mgr->b.uploader,
 252                   key.output_stride * min_index,
 253                   key.output_stride * num_verts,
 254                   &out_offset, &out_buffer, &upload_flushed,
 255                   (void**)&out_map);
 256
 257    out_offset -= key.output_stride * min_index;
 258
 259    /* Translate. */
 260    tr->run(tr, 0, num_verts, 0, out_map);
 261
 262    /* Unmap all buffers. */
 263    for (i = 0; i < mgr->b.nr_vertex_buffers; i++) {
 264       if (vb_translated[i]) {
 265          pipe_buffer_unmap(mgr->pipe, vb_transfer[i]);
 266       }
 267    }
 268
 269    /* Setup the new vertex buffer in the first free slot. */
 270    mgr->translate_vb_slot = ~0;
 271    for (i = 0; i < PIPE_MAX_ATTRIBS; i++) {
 272       if (!mgr->b.vertex_buffer[i].buffer) {
 273          mgr->translate_vb_slot = i;
 274
 275          if (i >= mgr->b.nr_vertex_buffers) {
 276             mgr->b.nr_real_vertex_buffers = i+1;
 277          }
 278          break;
 279       }
 280    }
 281
 282    if (mgr->translate_vb_slot != ~0) {
 283       /* Setup the new vertex buffer. */
 284       pipe_resource_reference(
 285             &mgr->b.real_vertex_buffer[mgr->translate_vb_slot].buffer, out_buffer);
 286       mgr->b.real_vertex_buffer[mgr->translate_vb_slot].buffer_offset = out_offset;
 287       mgr->b.real_vertex_buffer[mgr->translate_vb_slot].stride = key.output_stride;
 288
 289       /* Setup new vertex elements. */
 290       for (i = 0; i < mgr->ve->count; i++) {
 291          if (tr_elem_index[i] < key.nr_elements) {
 292             te = &key.element[tr_elem_index[i]];
 293             new_velems[i].instance_divisor = mgr->ve->ve[i].instance_divisor;
 294             new_velems[i].src_format = te->output_format;
 295             new_velems[i].src_offset = te->output_offset;
 296             new_velems[i].vertex_buffer_index = mgr->translate_vb_slot;
 297          } else {
 298             memcpy(&new_velems[i], &mgr->ve->ve[i],
 299                    sizeof(struct pipe_vertex_element));
 300          }
 301       }
 302
 303       mgr->fallback_ve =
 304             mgr->pipe->create_vertex_elements_state(mgr->pipe, mgr->ve->count,
 305                                                     new_velems);
 306
 307       /* Preserve saved_ve. */
 308       mgr->ve_binding_lock = TRUE;
 309       mgr->pipe->bind_vertex_elements_state(mgr->pipe, mgr->fallback_ve);
 310       mgr->ve_binding_lock = FALSE;
 311    }
 312
 313    pipe_resource_reference(&out_buffer, NULL);
 314 }
 315
 316 static void u_vbuf_translate_end(struct u_vbuf_priv *mgr)
 317 {
 318    if (mgr->fallback_ve == NULL) {
 319       return;
 320    }
 321
 322    /* Restore vertex elements. */
 323    /* Note that saved_ve will be overwritten in bind_vertex_elements_state. */
 324    mgr->pipe->bind_vertex_elements_state(mgr->pipe, mgr->saved_ve);
 325    mgr->pipe->delete_vertex_elements_state(mgr->pipe, mgr->fallback_ve);
 326    mgr->fallback_ve = NULL;
 327
 328    /* Delete the now-unused VBO. */
 329    pipe_resource_reference(&mgr->b.real_vertex_buffer[mgr->translate_vb_slot].buffer,
 330                            NULL);
 331    mgr->b.nr_real_vertex_buffers = mgr->b.nr_vertex_buffers;
 332 }
 333
 334 #define FORMAT_REPLACE(what, withwhat) \
 335     case PIPE_FORMAT_##what: format = PIPE_FORMAT_##withwhat; break
 336
 337 struct u_vbuf_elements *
 338 u_vbuf_create_vertex_elements(struct u_vbuf_mgr *mgrb,
 339                               unsigned count,
 340                               const struct pipe_vertex_element *attribs,
 341                               struct pipe_vertex_element *native_attribs)
 342 {
 343    struct u_vbuf_priv *mgr = (struct u_vbuf_priv*)mgrb;
 344    unsigned i;
 345    struct u_vbuf_elements *ve = CALLOC_STRUCT(u_vbuf_elements);
 346
 347    ve->count = count;
 348
 349    if (!count) {
 350       return ve;
 351    }
 352
 353    memcpy(ve->ve, attribs, sizeof(struct pipe_vertex_element) * count);
 354    memcpy(native_attribs, attribs, sizeof(struct pipe_vertex_element) * count);
 355
 356    /* Set the best native format in case the original format is not
 357     * supported. */
 358    for (i = 0; i < count; i++) {
 359       enum pipe_format format = ve->ve[i].src_format;
 360
 361       ve->src_format_size[i] = util_format_get_blocksize(format);
 362
 363       /* Choose a native format.
 364        * For now we don't care about the alignment, that's going to
 365        * be sorted out later. */
 366       if (!mgr->caps.format_fixed32) {
 367          switch (format) {
 368             FORMAT_REPLACE(R32_FIXED,           R32_FLOAT);
 369             FORMAT_REPLACE(R32G32_FIXED,        R32G32_FLOAT);
 370             FORMAT_REPLACE(R32G32B32_FIXED,     R32G32B32_FLOAT);
 371             FORMAT_REPLACE(R32G32B32A32_FIXED,  R32G32B32A32_FLOAT);
 372             default:;
 373          }
 374       }
 375       if (!mgr->caps.format_float16) {
 376          switch (format) {
 377             FORMAT_REPLACE(R16_FLOAT,           R32_FLOAT);
 378             FORMAT_REPLACE(R16G16_FLOAT,        R32G32_FLOAT);
 379             FORMAT_REPLACE(R16G16B16_FLOAT,     R32G32B32_FLOAT);
 380             FORMAT_REPLACE(R16G16B16A16_FLOAT,  R32G32B32A32_FLOAT);
 381             default:;
 382          }
 383       }
 384       if (!mgr->caps.format_float64) {
 385          switch (format) {
 386             FORMAT_REPLACE(R64_FLOAT,           R32_FLOAT);
 387             FORMAT_REPLACE(R64G64_FLOAT,        R32G32_FLOAT);
 388             FORMAT_REPLACE(R64G64B64_FLOAT,     R32G32B32_FLOAT);
 389             FORMAT_REPLACE(R64G64B64A64_FLOAT,  R32G32B32A32_FLOAT);
 390             default:;
 391          }
 392       }
 393       if (!mgr->caps.format_norm32) {
 394          switch (format) {
 395             FORMAT_REPLACE(R32_UNORM,           R32_FLOAT);
 396             FORMAT_REPLACE(R32G32_UNORM,        R32G32_FLOAT);
 397             FORMAT_REPLACE(R32G32B32_UNORM,     R32G32B32_FLOAT);
 398             FORMAT_REPLACE(R32G32B32A32_UNORM,  R32G32B32A32_FLOAT);
 399             FORMAT_REPLACE(R32_SNORM,           R32_FLOAT);
 400             FORMAT_REPLACE(R32G32_SNORM,        R32G32_FLOAT);
 401             FORMAT_REPLACE(R32G32B32_SNORM,     R32G32B32_FLOAT);
 402             FORMAT_REPLACE(R32G32B32A32_SNORM,  R32G32B32A32_FLOAT);
 403             default:;
 404          }
 405       }
 406       if (!mgr->caps.format_scaled32) {
 407          switch (format) {
 408             FORMAT_REPLACE(R32_USCALED,         R32_FLOAT);
 409             FORMAT_REPLACE(R32G32_USCALED,      R32G32_FLOAT);
 410             FORMAT_REPLACE(R32G32B32_USCALED,   R32G32B32_FLOAT);
 411             FORMAT_REPLACE(R32G32B32A32_USCALED,R32G32B32A32_FLOAT);
 412             FORMAT_REPLACE(R32_SSCALED,         R32_FLOAT);
 413             FORMAT_REPLACE(R32G32_SSCALED,      R32G32_FLOAT);
 414             FORMAT_REPLACE(R32G32B32_SSCALED,   R32G32B32_FLOAT);
 415             FORMAT_REPLACE(R32G32B32A32_SSCALED,R32G32B32A32_FLOAT);
 416             default:;
 417          }
 418       }
 419
 420       native_attribs[i].src_format = format;
 421       ve->native_format[i] = format;
 422       ve->native_format_size[i] =
 423             util_format_get_blocksize(ve->native_format[i]);
 424
 425       ve->incompatible_layout =
 426             ve->incompatible_layout ||
 427             ve->ve[i].src_format != ve->native_format[i] ||
 428             (!mgr->caps.fetch_dword_unaligned && ve->ve[i].src_offset % 4 != 0);
 429    }
 430
 431    /* Align the formats to the size of DWORD if needed. */
 432    if (!mgr->caps.fetch_dword_unaligned) {
 433       for (i = 0; i < count; i++) {
 434          ve->native_format_size[i] = align(ve->native_format_size[i], 4);
 435       }
 436    }
 437
 438    return ve;
 439 }
 440
 441 void u_vbuf_bind_vertex_elements(struct u_vbuf_mgr *mgrb,
 442                                  void *cso,
 443                                  struct u_vbuf_elements *ve)
 444 {
 445    struct u_vbuf_priv *mgr = (struct u_vbuf_priv*)mgrb;
 446
 447    if (!cso) {
 448       return;
 449    }
 450
 451    if (!mgr->ve_binding_lock) {
 452       mgr->saved_ve = cso;
 453       mgr->ve = ve;
 454    }
 455 }
 456
 457 void u_vbuf_destroy_vertex_elements(struct u_vbuf_mgr *mgr,
 458                                     struct u_vbuf_elements *ve)
 459 {
 460    FREE(ve);
 461 }
 462
 463 void u_vbuf_set_vertex_buffers(struct u_vbuf_mgr *mgrb,
 464                                unsigned count,
 465                                const struct pipe_vertex_buffer *bufs)
 466 {
 467    struct u_vbuf_priv *mgr = (struct u_vbuf_priv*)mgrb;
 468    unsigned i;
 469
 470    mgr->any_user_vbs = FALSE;
 471    mgr->incompatible_vb_layout = FALSE;
 472
 473    if (!mgr->caps.fetch_dword_unaligned) {
 474       /* Check if the strides and offsets are aligned to the size of DWORD. */
 475       for (i = 0; i < count; i++) {
 476          if (bufs[i].buffer) {
 477             if (bufs[i].stride % 4 != 0 ||
 478                 bufs[i].buffer_offset % 4 != 0) {
 479                mgr->incompatible_vb_layout = TRUE;
 480                break;
 481             }
 482          }
 483       }
 484    }
 485
 486    for (i = 0; i < count; i++) {
 487       const struct pipe_vertex_buffer *vb = &bufs[i];
 488
 489       pipe_resource_reference(&mgr->b.vertex_buffer[i].buffer, vb->buffer);
 490       pipe_resource_reference(&mgr->b.real_vertex_buffer[i].buffer, NULL);
 491
 492       mgr->b.real_vertex_buffer[i].buffer_offset =
 493       mgr->b.vertex_buffer[i].buffer_offset = vb->buffer_offset;
 494
 495       mgr->b.real_vertex_buffer[i].stride =
 496       mgr->b.vertex_buffer[i].stride = vb->stride;
 497
 498       if (!vb->buffer) {
 499          continue;
 500       }
 501
 502       if (u_vbuf_resource(vb->buffer)->user_ptr) {
 503          mgr->any_user_vbs = TRUE;
 504          continue;
 505       }
 506
 507       pipe_resource_reference(&mgr->b.real_vertex_buffer[i].buffer, vb->buffer);
 508    }
 509
 510    for (i = count; i < mgr->b.nr_vertex_buffers; i++) {
 511       pipe_resource_reference(&mgr->b.vertex_buffer[i].buffer, NULL);
 512    }
 513    for (i = count; i < mgr->b.nr_real_vertex_buffers; i++) {
 514       pipe_resource_reference(&mgr->b.real_vertex_buffer[i].buffer, NULL);
 515    }
 516
 517    mgr->b.nr_vertex_buffers = count;
 518    mgr->b.nr_real_vertex_buffers = count;
 519 }
 520
 521 static void
 522 u_vbuf_upload_buffers(struct u_vbuf_priv *mgr,
 523                       int min_index, int max_index,
 524                       unsigned instance_count)
 525 {
 526    unsigned i;
 527    unsigned count = max_index + 1 - min_index;
 528    unsigned nr_velems = mgr->ve->count;
 529    unsigned nr_vbufs = mgr->b.nr_vertex_buffers;
 530    unsigned start_offset[PIPE_MAX_ATTRIBS];
 531    unsigned end_offset[PIPE_MAX_ATTRIBS] = {0};
 532
 533    /* Determine how much data needs to be uploaded. */
 534    for (i = 0; i < nr_velems; i++) {
 535       struct pipe_vertex_element *velem = &mgr->ve->ve[i];
 536       unsigned index = velem->vertex_buffer_index;
 537       unsigned instance_div = velem->instance_divisor;
 538       struct pipe_vertex_buffer *vb = &mgr->b.vertex_buffer[index];
 539       unsigned first, size;
 540
 541       assert(vb->buffer);
 542
 543       if (!u_vbuf_resource(vb->buffer)->user_ptr) {
 544          continue;
 545       }
 546
 547       first = vb->buffer_offset + velem->src_offset;
 548
 549       if (!vb->stride) {
 550          /* Constant attrib. */
 551          size = mgr->ve->src_format_size[i];
 552       } else if (instance_div) {
 553          /* Per-instance attrib. */
 554          unsigned count = (instance_count + instance_div - 1) / instance_div;
 555          size = vb->stride * (count - 1) + mgr->ve->src_format_size[i];
 556       } else {
 557          /* Per-vertex attrib. */
 558          first += vb->stride * min_index;
 559          size = vb->stride * (count - 1) + mgr->ve->src_format_size[i];
 560       }
 561
 562       /* Update offsets. */
 563       if (!end_offset[index]) {
 564          start_offset[index] = first;
 565          end_offset[index] = first + size;
 566       } else {
 567          if (first < start_offset[index])
 568             start_offset[index] = first;
 569          if (first + size > end_offset[index])
 570             end_offset[index] = first + size;
 571       }
 572    }
 573
 574    /* Upload buffers. */
 575    for (i = 0; i < nr_vbufs; i++) {
 576       unsigned start = start_offset[i];
 577       unsigned end = end_offset[i];
 578       boolean flushed;
 579
 580       if (!end) {
 581          continue;
 582       }
 583       assert(start < end);
 584
 585       u_upload_data(mgr->b.uploader, start, end - start,
 586                     u_vbuf_resource(mgr->b.vertex_buffer[i].buffer)->user_ptr + start,
 587                     &mgr->b.real_vertex_buffer[i].buffer_offset,
 588                     &mgr->b.real_vertex_buffer[i].buffer,
 589                     &flushed);
 590
 591       mgr->b.real_vertex_buffer[i].buffer_offset -= start;
 592    }
 593 }
 594
 595 static void u_vbuf_compute_max_index(struct u_vbuf_priv *mgr)
 596 {
 597    unsigned i, nr = mgr->ve->count;
 598
 599    mgr->b.max_index = ~0;
 600
 601    for (i = 0; i < nr; i++) {
 602       struct pipe_vertex_buffer *vb =
 603             &mgr->b.vertex_buffer[mgr->ve->ve[i].vertex_buffer_index];
 604       unsigned max_index, src_size, unused;
 605
 606       if (!vb->buffer ||
 607           !vb->stride ||
 608           u_vbuf_resource(vb->buffer)->user_ptr ||
 609           mgr->ve->ve[i].instance_divisor) {
 610          continue;
 611       }
 612
 613       src_size = mgr->ve->ve[i].src_offset + mgr->ve->src_format_size[i];
 614
 615       /* If src_offset is greater than stride (which means it's a buffer
 616        * offset rather than a vertex offset)... */
 617       if (src_size >= vb->stride) {
 618          unused = 0;
 619       } else {
 620          /* How many bytes is unused after the last vertex.
 621           * width0 may be "count*stride - unused" and we have to compensate
 622           * for that when dividing by stride. */
 623          unused = vb->stride - src_size;
 624       }
 625
 626       /* Compute the maximum index for this vertex element. */
 627       max_index =
 628          (vb->buffer->width0 - vb->buffer_offset + (unsigned)unused) /
 629          vb->stride - 1;
 630
 631       mgr->b.max_index = MIN2(mgr->b.max_index, max_index);
 632    }
 633 }
 634
 635 enum u_vbuf_return_flags
 636 u_vbuf_draw_begin(struct u_vbuf_mgr *mgrb,
 637                   const struct pipe_draw_info *info)
 638 {
 639    struct u_vbuf_priv *mgr = (struct u_vbuf_priv*)mgrb;
 640    int min_index, max_index;
 641
 642    u_vbuf_compute_max_index(mgr);
 643
 644    if (info->indexed) {
 645       min_index = info->min_index;
 646       if (info->max_index == ~0) {
 647          max_index = mgr->b.max_index;
 648       } else {
 649          max_index = MIN2(info->max_index, mgr->b.max_index);
 650       }
 651       min_index += info->index_bias;
 652       max_index += info->index_bias;
 653    } else {
 654       min_index = info->start;
 655       max_index = info->start + info->count - 1;
 656    }
 657
 658    /* Translate vertices with non-native layouts or formats. */
 659    if (mgr->incompatible_vb_layout || mgr->ve->incompatible_layout) {
 660       u_vbuf_translate_begin(mgr, min_index, max_index);
 661    }
 662
 663    /* Upload user buffers. */
 664    if (mgr->any_user_vbs) {
 665       u_vbuf_upload_buffers(mgr, min_index, max_index, info->instance_count);
 666    }
 667    return mgr->any_user_vbs || mgr->fallback_ve ? U_VBUF_BUFFERS_UPDATED : 0;
 668 }
 669
 670 void u_vbuf_draw_end(struct u_vbuf_mgr *mgrb)
 671 {
 672    struct u_vbuf_priv *mgr = (struct u_vbuf_priv*)mgrb;
 673
 674    if (mgr->fallback_ve) {
 675       u_vbuf_translate_end(mgr);
 676    }
 677 }