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 "main/bufferobj.h"
  48 #include "main/glformats.h"
  49
  50 /* vertex_formats[gltype - GL_BYTE][integer*2 + normalized][size - 1] */
  51 static const uint16_t vertex_formats[][4][4] = {
  52    { /* GL_BYTE */
  53       {
  54          PIPE_FORMAT_R8_SSCALED,
  55          PIPE_FORMAT_R8G8_SSCALED,
  56          PIPE_FORMAT_R8G8B8_SSCALED,
  57          PIPE_FORMAT_R8G8B8A8_SSCALED
  58       },
  59       {
  60          PIPE_FORMAT_R8_SNORM,
  61          PIPE_FORMAT_R8G8_SNORM,
  62          PIPE_FORMAT_R8G8B8_SNORM,
  63          PIPE_FORMAT_R8G8B8A8_SNORM
  64       },
  65       {
  66          PIPE_FORMAT_R8_SINT,
  67          PIPE_FORMAT_R8G8_SINT,
  68          PIPE_FORMAT_R8G8B8_SINT,
  69          PIPE_FORMAT_R8G8B8A8_SINT
  70       },
  71    },
  72    { /* GL_UNSIGNED_BYTE */
  73       {
  74          PIPE_FORMAT_R8_USCALED,
  75          PIPE_FORMAT_R8G8_USCALED,
  76          PIPE_FORMAT_R8G8B8_USCALED,
  77          PIPE_FORMAT_R8G8B8A8_USCALED
  78       },
  79       {
  80          PIPE_FORMAT_R8_UNORM,
  81          PIPE_FORMAT_R8G8_UNORM,
  82          PIPE_FORMAT_R8G8B8_UNORM,
  83          PIPE_FORMAT_R8G8B8A8_UNORM
  84       },
  85       {
  86          PIPE_FORMAT_R8_UINT,
  87          PIPE_FORMAT_R8G8_UINT,
  88          PIPE_FORMAT_R8G8B8_UINT,
  89          PIPE_FORMAT_R8G8B8A8_UINT
  90       },
  91    },
  92    { /* GL_SHORT */
  93       {
  94          PIPE_FORMAT_R16_SSCALED,
  95          PIPE_FORMAT_R16G16_SSCALED,
  96          PIPE_FORMAT_R16G16B16_SSCALED,
  97          PIPE_FORMAT_R16G16B16A16_SSCALED
  98       },
  99       {
 100          PIPE_FORMAT_R16_SNORM,
 101          PIPE_FORMAT_R16G16_SNORM,
 102          PIPE_FORMAT_R16G16B16_SNORM,
 103          PIPE_FORMAT_R16G16B16A16_SNORM
 104       },
 105       {
 106          PIPE_FORMAT_R16_SINT,
 107          PIPE_FORMAT_R16G16_SINT,
 108          PIPE_FORMAT_R16G16B16_SINT,
 109          PIPE_FORMAT_R16G16B16A16_SINT
 110       },
 111    },
 112    { /* GL_UNSIGNED_SHORT */
 113       {
 114          PIPE_FORMAT_R16_USCALED,
 115          PIPE_FORMAT_R16G16_USCALED,
 116          PIPE_FORMAT_R16G16B16_USCALED,
 117          PIPE_FORMAT_R16G16B16A16_USCALED
 118       },
 119       {
 120          PIPE_FORMAT_R16_UNORM,
 121          PIPE_FORMAT_R16G16_UNORM,
 122          PIPE_FORMAT_R16G16B16_UNORM,
 123          PIPE_FORMAT_R16G16B16A16_UNORM
 124       },
 125       {
 126          PIPE_FORMAT_R16_UINT,
 127          PIPE_FORMAT_R16G16_UINT,
 128          PIPE_FORMAT_R16G16B16_UINT,
 129          PIPE_FORMAT_R16G16B16A16_UINT
 130       },
 131    },
 132    { /* GL_INT */
 133       {
 134          PIPE_FORMAT_R32_SSCALED,
 135          PIPE_FORMAT_R32G32_SSCALED,
 136          PIPE_FORMAT_R32G32B32_SSCALED,
 137          PIPE_FORMAT_R32G32B32A32_SSCALED
 138       },
 139       {
 140          PIPE_FORMAT_R32_SNORM,
 141          PIPE_FORMAT_R32G32_SNORM,
 142          PIPE_FORMAT_R32G32B32_SNORM,
 143          PIPE_FORMAT_R32G32B32A32_SNORM
 144       },
 145       {
 146          PIPE_FORMAT_R32_SINT,
 147          PIPE_FORMAT_R32G32_SINT,
 148          PIPE_FORMAT_R32G32B32_SINT,
 149          PIPE_FORMAT_R32G32B32A32_SINT
 150       },
 151    },
 152    { /* GL_UNSIGNED_INT */
 153       {
 154          PIPE_FORMAT_R32_USCALED,
 155          PIPE_FORMAT_R32G32_USCALED,
 156          PIPE_FORMAT_R32G32B32_USCALED,
 157          PIPE_FORMAT_R32G32B32A32_USCALED
 158       },
 159       {
 160          PIPE_FORMAT_R32_UNORM,
 161          PIPE_FORMAT_R32G32_UNORM,
 162          PIPE_FORMAT_R32G32B32_UNORM,
 163          PIPE_FORMAT_R32G32B32A32_UNORM
 164       },
 165       {
 166          PIPE_FORMAT_R32_UINT,
 167          PIPE_FORMAT_R32G32_UINT,
 168          PIPE_FORMAT_R32G32B32_UINT,
 169          PIPE_FORMAT_R32G32B32A32_UINT
 170       },
 171    },
 172    { /* GL_FLOAT */
 173       {
 174          PIPE_FORMAT_R32_FLOAT,
 175          PIPE_FORMAT_R32G32_FLOAT,
 176          PIPE_FORMAT_R32G32B32_FLOAT,
 177          PIPE_FORMAT_R32G32B32A32_FLOAT
 178       },
 179       {
 180          PIPE_FORMAT_R32_FLOAT,
 181          PIPE_FORMAT_R32G32_FLOAT,
 182          PIPE_FORMAT_R32G32B32_FLOAT,
 183          PIPE_FORMAT_R32G32B32A32_FLOAT
 184       },
 185    },
 186    {{0}}, /* GL_2_BYTES */
 187    {{0}}, /* GL_3_BYTES */
 188    {{0}}, /* GL_4_BYTES */
 189    { /* GL_DOUBLE */
 190       {
 191          PIPE_FORMAT_R64_FLOAT,
 192          PIPE_FORMAT_R64G64_FLOAT,
 193          PIPE_FORMAT_R64G64B64_FLOAT,
 194          PIPE_FORMAT_R64G64B64A64_FLOAT
 195       },
 196       {
 197          PIPE_FORMAT_R64_FLOAT,
 198          PIPE_FORMAT_R64G64_FLOAT,
 199          PIPE_FORMAT_R64G64B64_FLOAT,
 200          PIPE_FORMAT_R64G64B64A64_FLOAT
 201       },
 202    },
 203    { /* GL_HALF_FLOAT */
 204       {
 205          PIPE_FORMAT_R16_FLOAT,
 206          PIPE_FORMAT_R16G16_FLOAT,
 207          PIPE_FORMAT_R16G16B16_FLOAT,
 208          PIPE_FORMAT_R16G16B16A16_FLOAT
 209       },
 210       {
 211          PIPE_FORMAT_R16_FLOAT,
 212          PIPE_FORMAT_R16G16_FLOAT,
 213          PIPE_FORMAT_R16G16B16_FLOAT,
 214          PIPE_FORMAT_R16G16B16A16_FLOAT
 215       },
 216    },
 217    { /* GL_FIXED */
 218       {
 219          PIPE_FORMAT_R32_FIXED,
 220          PIPE_FORMAT_R32G32_FIXED,
 221          PIPE_FORMAT_R32G32B32_FIXED,
 222          PIPE_FORMAT_R32G32B32A32_FIXED
 223       },
 224       {
 225          PIPE_FORMAT_R32_FIXED,
 226          PIPE_FORMAT_R32G32_FIXED,
 227          PIPE_FORMAT_R32G32B32_FIXED,
 228          PIPE_FORMAT_R32G32B32A32_FIXED
 229       },
 230    },
 231 };
 232
 233
 234 /**
 235  * Return a PIPE_FORMAT_x for the given GL datatype and size.
 236  */
 237 enum pipe_format
 238 st_pipe_vertex_format(GLenum type, GLuint size, GLenum format,
 239                       GLboolean normalized, GLboolean integer)
 240 {
 241    unsigned index;
 242
 243    assert(size >= 1 && size <= 4);
 244    assert(format == GL_RGBA || format == GL_BGRA);
 245
 246    switch (type) {
 247    case GL_HALF_FLOAT_OES:
 248       type = GL_HALF_FLOAT;
 249       break;
 250
 251    case GL_INT_2_10_10_10_REV:
 252       assert(size == 4 && !integer);
 253
 254       if (format == GL_BGRA) {
 255          if (normalized)
 256             return PIPE_FORMAT_B10G10R10A2_SNORM;
 257          else
 258             return PIPE_FORMAT_B10G10R10A2_SSCALED;
 259       } else {
 260          if (normalized)
 261             return PIPE_FORMAT_R10G10B10A2_SNORM;
 262          else
 263             return PIPE_FORMAT_R10G10B10A2_SSCALED;
 264       }
 265       break;
 266
 267    case GL_UNSIGNED_INT_2_10_10_10_REV:
 268       assert(size == 4 && !integer);
 269
 270       if (format == GL_BGRA) {
 271          if (normalized)
 272             return PIPE_FORMAT_B10G10R10A2_UNORM;
 273          else
 274             return PIPE_FORMAT_B10G10R10A2_USCALED;
 275       } else {
 276          if (normalized)
 277             return PIPE_FORMAT_R10G10B10A2_UNORM;
 278          else
 279             return PIPE_FORMAT_R10G10B10A2_USCALED;
 280       }
 281       break;
 282
 283    case GL_UNSIGNED_INT_10F_11F_11F_REV:
 284       assert(size == 3 && !integer && format == GL_RGBA);
 285       return PIPE_FORMAT_R11G11B10_FLOAT;
 286
 287    case GL_UNSIGNED_BYTE:
 288       if (format == GL_BGRA) {
 289          /* this is an odd-ball case */
 290          assert(normalized);
 291          return PIPE_FORMAT_B8G8R8A8_UNORM;
 292       }
 293       break;
 294    }
 295
 296    index = integer*2 + normalized;
 297    assert(index <= 2);
 298    assert(type >= GL_BYTE && type <= GL_FIXED);
 299    return vertex_formats[type - GL_BYTE][index][size-1];
 300 }
 301
 302 static const struct gl_vertex_array *
 303 get_client_array(const struct st_vertex_program *vp,
 304                  const struct gl_vertex_array **arrays,
 305                  int attr)
 306 {
 307    const GLuint mesaAttr = vp->index_to_input[attr];
 308    /* st_program uses 0xffffffff to denote a double placeholder attribute */
 309    if (mesaAttr == ST_DOUBLE_ATTRIB_PLACEHOLDER)
 310       return NULL;
 311    return arrays[mesaAttr];
 312 }
 313
 314 /**
 315  * Examine the active arrays to determine if we have interleaved
 316  * vertex arrays all living in one VBO, or all living in user space.
 317  */
 318 static GLboolean
 319 is_interleaved_arrays(const struct st_vertex_program *vp,
 320                       const struct st_vp_variant *vpv,
 321                       const struct gl_vertex_array **arrays)
 322 {
 323    GLuint attr;
 324    const struct gl_buffer_object *firstBufObj = NULL;
 325    GLint firstStride = -1;
 326    const GLubyte *firstPtr = NULL;
 327    GLboolean userSpaceBuffer = GL_FALSE;
 328
 329    for (attr = 0; attr < vpv->num_inputs; attr++) {
 330       const struct gl_vertex_array *array;
 331       const struct gl_buffer_object *bufObj;
 332       GLsizei stride;
 333
 334       array = get_client_array(vp, arrays, attr);
 335       if (!array)
 336          continue;
 337
 338       stride = array->StrideB; /* in bytes */
 339       bufObj = array->BufferObj;
 340       if (attr == 0) {
 341          /* save info about the first array */
 342          firstStride = stride;
 343          firstPtr = array->Ptr;
 344          firstBufObj = bufObj;
 345          userSpaceBuffer = !bufObj || !bufObj->Name;
 346       }
 347       else {
 348          /* check if other arrays interleave with the first, in same buffer */
 349          if (stride != firstStride)
 350             return GL_FALSE; /* strides don't match */
 351
 352          if (bufObj != firstBufObj)
 353             return GL_FALSE; /* arrays in different VBOs */
 354
 355          if (llabs(array->Ptr - firstPtr) > firstStride)
 356             return GL_FALSE; /* arrays start too far apart */
 357
 358          if ((!_mesa_is_bufferobj(bufObj)) != userSpaceBuffer)
 359             return GL_FALSE; /* mix of VBO and user-space arrays */
 360       }
 361    }
 362
 363    return GL_TRUE;
 364 }
 365
 366 static void init_velement(struct pipe_vertex_element *velement,
 367                           int src_offset, int format,
 368                           int instance_divisor, int vbo_index)
 369 {
 370    velement->src_offset = src_offset;
 371    velement->src_format = format;
 372    velement->instance_divisor = instance_divisor;
 373    velement->vertex_buffer_index = vbo_index;
 374    assert(velement->src_format);
 375 }
 376
 377 static void init_velement_lowered(const struct st_vertex_program *vp,
 378                                   struct pipe_vertex_element *velements,
 379                                   int src_offset, int format,
 380                                   int instance_divisor, int vbo_index,
 381                                   int nr_components, GLboolean doubles,
 382                                   GLuint *attr_idx)
 383 {
 384    int idx = *attr_idx;
 385    if (doubles) {
 386       int lower_format;
 387
 388       if (nr_components < 2)
 389          lower_format = PIPE_FORMAT_R32G32_UINT;
 390       else
 391          lower_format = PIPE_FORMAT_R32G32B32A32_UINT;
 392
 393       init_velement(&velements[idx], src_offset,
 394                     lower_format, instance_divisor, vbo_index);
 395       idx++;
 396
 397       if (idx < vp->num_inputs &&
 398           vp->index_to_input[idx] == ST_DOUBLE_ATTRIB_PLACEHOLDER) {
 399          if (nr_components >= 3) {
 400             if (nr_components == 3)
 401                lower_format = PIPE_FORMAT_R32G32_UINT;
 402             else
 403                lower_format = PIPE_FORMAT_R32G32B32A32_UINT;
 404
 405             init_velement(&velements[idx], src_offset + 4 * sizeof(float),
 406                         lower_format, instance_divisor, vbo_index);
 407          } else {
 408             /* The values here are undefined. Fill in some conservative
 409              * dummy values.
 410              */
 411             init_velement(&velements[idx], src_offset, PIPE_FORMAT_R32G32_UINT,
 412                           instance_divisor, vbo_index);
 413          }
 414
 415          idx++;
 416       }
 417    } else {
 418       init_velement(&velements[idx], src_offset,
 419                     format, instance_divisor, vbo_index);
 420       idx++;
 421    }
 422    *attr_idx = idx;
 423 }
 424
 425 /**
 426  * Set up for drawing interleaved arrays that all live in one VBO
 427  * or all live in user space.
 428  * \param vbuffer  returns vertex buffer info
 429  * \param velements  returns vertex element info
 430  */
 431 static boolean
 432 setup_interleaved_attribs(struct st_context *st,
 433                           const struct st_vertex_program *vp,
 434                           const struct st_vp_variant *vpv,
 435                           const struct gl_vertex_array **arrays,
 436                           struct pipe_vertex_buffer *vbuffer,
 437                           struct pipe_vertex_element velements[])
 438 {
 439    GLuint attr;
 440    const GLubyte *low_addr = NULL;
 441    GLboolean usingVBO;      /* all arrays in a VBO? */
 442    struct gl_buffer_object *bufobj;
 443    GLsizei stride;
 444
 445    /* Find the lowest address of the arrays we're drawing,
 446     * Init bufobj and stride.
 447     */
 448    if (vpv->num_inputs) {
 449       const struct gl_vertex_array *array;
 450
 451       array = get_client_array(vp, arrays, 0);
 452       assert(array);
 453
 454       /* Since we're doing interleaved arrays, we know there'll be at most
 455        * one buffer object and the stride will be the same for all arrays.
 456        * Grab them now.
 457        */
 458       bufobj = array->BufferObj;
 459       stride = array->StrideB;
 460
 461       low_addr = arrays[vp->index_to_input[0]]->Ptr;
 462
 463       for (attr = 1; attr < vpv->num_inputs; attr++) {
 464          const GLubyte *start;
 465          array = get_client_array(vp, arrays, attr);
 466          if (!array)
 467             continue;
 468          start = array->Ptr;
 469          low_addr = MIN2(low_addr, start);
 470       }
 471    }
 472    else {
 473       /* not sure we'll ever have zero inputs, but play it safe */
 474       bufobj = NULL;
 475       stride = 0;
 476       low_addr = 0;
 477    }
 478
 479    /* are the arrays in user space? */
 480    usingVBO = _mesa_is_bufferobj(bufobj);
 481
 482    for (attr = 0; attr < vpv->num_inputs;) {
 483       const struct gl_vertex_array *array;
 484       unsigned src_offset;
 485       unsigned src_format;
 486
 487       array = get_client_array(vp, arrays, attr);
 488       assert(array);
 489
 490       src_offset = (unsigned) (array->Ptr - low_addr);
 491       assert(array->_ElementSize ==
 492              _mesa_bytes_per_vertex_attrib(array->Size, array->Type));
 493
 494       src_format = st_pipe_vertex_format(array->Type,
 495                                          array->Size,
 496                                          array->Format,
 497                                          array->Normalized,
 498                                          array->Integer);
 499
 500       init_velement_lowered(vp, velements, src_offset, src_format,
 501                             array->InstanceDivisor, 0,
 502                             array->Size, array->Doubles, &attr);
 503    }
 504
 505    /*
 506     * Return the vbuffer info and setup user-space attrib info, if needed.
 507     */
 508    if (vpv->num_inputs == 0) {
 509       /* just defensive coding here */
 510       vbuffer->buffer = NULL;
 511       vbuffer->user_buffer = NULL;
 512       vbuffer->buffer_offset = 0;
 513       vbuffer->stride = 0;
 514    }
 515    else if (usingVBO) {
 516       /* all interleaved arrays in a VBO */
 517       struct st_buffer_object *stobj = st_buffer_object(bufobj);
 518
 519       if (!stobj || !stobj->buffer) {
 520          return FALSE; /* out-of-memory error probably */
 521       }
 522
 523       vbuffer->buffer = stobj->buffer;
 524       vbuffer->user_buffer = NULL;
 525       vbuffer->buffer_offset = pointer_to_offset(low_addr);
 526       vbuffer->stride = stride;
 527    }
 528    else {
 529       /* all interleaved arrays in user memory */
 530       vbuffer->buffer = NULL;
 531       vbuffer->user_buffer = low_addr;
 532       vbuffer->buffer_offset = 0;
 533       vbuffer->stride = stride;
 534    }
 535    return TRUE;
 536 }
 537
 538 /**
 539  * Set up a separate pipe_vertex_buffer and pipe_vertex_element for each
 540  * vertex attribute.
 541  * \param vbuffer  returns vertex buffer info
 542  * \param velements  returns vertex element info
 543  */
 544 static boolean
 545 setup_non_interleaved_attribs(struct st_context *st,
 546                               const struct st_vertex_program *vp,
 547                               const struct st_vp_variant *vpv,
 548                               const struct gl_vertex_array **arrays,
 549                               struct pipe_vertex_buffer vbuffer[],
 550                               struct pipe_vertex_element velements[],
 551                               unsigned *num_vbuffers)
 552 {
 553    struct gl_context *ctx = st->ctx;
 554    GLuint attr;
 555
 556    *num_vbuffers = 0;
 557
 558    for (attr = 0; attr < vpv->num_inputs;) {
 559       const GLuint mesaAttr = vp->index_to_input[attr];
 560       const struct gl_vertex_array *array;
 561       struct gl_buffer_object *bufobj;
 562       GLsizei stride;
 563       unsigned src_format;
 564       unsigned bufidx;
 565
 566       array = get_client_array(vp, arrays, attr);
 567       assert(array);
 568
 569       bufidx = (*num_vbuffers)++;
 570
 571       stride = array->StrideB;
 572       bufobj = array->BufferObj;
 573       assert(array->_ElementSize ==
 574              _mesa_bytes_per_vertex_attrib(array->Size, array->Type));
 575
 576       if (_mesa_is_bufferobj(bufobj)) {
 577          /* Attribute data is in a VBO.
 578           * Recall that for VBOs, the gl_vertex_array->Ptr field is
 579           * really an offset from the start of the VBO, not a pointer.
 580           */
 581          struct st_buffer_object *stobj = st_buffer_object(bufobj);
 582
 583          if (!stobj || !stobj->buffer) {
 584             return FALSE; /* out-of-memory error probably */
 585          }
 586
 587          vbuffer[bufidx].buffer = stobj->buffer;
 588          vbuffer[bufidx].user_buffer = NULL;
 589          vbuffer[bufidx].buffer_offset = pointer_to_offset(array->Ptr);
 590       }
 591       else {
 592          /* wrap user data */
 593          void *ptr;
 594
 595          if (array->Ptr) {
 596             ptr = (void *) array->Ptr;
 597          }
 598          else {
 599             /* no array, use ctx->Current.Attrib[] value */
 600             ptr = (void *) ctx->Current.Attrib[mesaAttr];
 601             stride = 0;
 602          }
 603
 604          assert(ptr);
 605
 606          vbuffer[bufidx].buffer = NULL;
 607          vbuffer[bufidx].user_buffer = ptr;
 608          vbuffer[bufidx].buffer_offset = 0;
 609       }
 610
 611       /* common-case setup */
 612       vbuffer[bufidx].stride = stride; /* in bytes */
 613
 614       src_format = st_pipe_vertex_format(array->Type,
 615                                          array->Size,
 616                                          array->Format,
 617                                          array->Normalized,
 618                                          array->Integer);
 619
 620       init_velement_lowered(vp, velements, 0, src_format,
 621                             array->InstanceDivisor, bufidx,
 622                             array->Size, array->Doubles, &attr);
 623    }
 624
 625    return TRUE;
 626 }
 627
 628 void st_update_array(struct st_context *st)
 629 {
 630    struct gl_context *ctx = st->ctx;
 631    const struct gl_vertex_array **arrays = ctx->Array._DrawArrays;
 632    const struct st_vertex_program *vp;
 633    const struct st_vp_variant *vpv;
 634    struct pipe_vertex_buffer vbuffer[PIPE_MAX_ATTRIBS];
 635    struct pipe_vertex_element velements[PIPE_MAX_ATTRIBS];
 636    unsigned num_vbuffers;
 637
 638    st->vertex_array_out_of_memory = FALSE;
 639
 640    /* No drawing has been done yet, so do nothing. */
 641    if (!arrays)
 642       return;
 643
 644    /* vertex program validation must be done before this */
 645    vp = st->vp;
 646    vpv = st->vp_variant;
 647
 648    memset(velements, 0, sizeof(struct pipe_vertex_element) * vpv->num_inputs);
 649
 650    /*
 651     * Setup the vbuffer[] and velements[] arrays.
 652     */
 653    if (is_interleaved_arrays(vp, vpv, arrays)) {
 654       if (!setup_interleaved_attribs(st, vp, vpv, arrays, vbuffer, velements)) {
 655          st->vertex_array_out_of_memory = TRUE;
 656          return;
 657       }
 658
 659       num_vbuffers = 1;
 660       if (vpv->num_inputs == 0)
 661          num_vbuffers = 0;
 662    }
 663    else {
 664       if (!setup_non_interleaved_attribs(st, vp, vpv, arrays, vbuffer,
 665                                          velements, &num_vbuffers)) {
 666          st->vertex_array_out_of_memory = TRUE;
 667          return;
 668       }
 669    }
 670
 671    cso_set_vertex_buffers(st->cso_context, 0, num_vbuffers, vbuffer);
 672    if (st->last_num_vbuffers > num_vbuffers) {
 673       /* Unbind remaining buffers, if any. */
 674       cso_set_vertex_buffers(st->cso_context, num_vbuffers,
 675                              st->last_num_vbuffers - num_vbuffers, NULL);
 676    }
 677    st->last_num_vbuffers = num_vbuffers;
 678    cso_set_vertex_elements(st->cso_context, vpv->num_inputs, velements);
 679 }