src/mesa/vbo/vbo_save_api.c

   1 /**************************************************************************
   2
   3 Copyright 2002-2008 VMware, Inc.
   4
   5 All Rights Reserved.
   6
   7 Permission is hereby granted, free of charge, to any person obtaining a
   8 copy of this software and associated documentation files (the "Software"),
   9 to deal in the Software without restriction, including without limitation
  10 on the rights to use, copy, modify, merge, publish, distribute, sub
  11 license, and/or sell copies of the Software, and to permit persons to whom
  12 the Software is furnished to do so, subject to the following conditions:
  13
  14 The above copyright notice and this permission notice (including the next
  15 paragraph) shall be included in all copies or substantial portions of the
  16 Software.
  17
  18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20 FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  21 VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
  22 DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  23 OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  24 USE OR OTHER DEALINGS IN THE SOFTWARE.
  25
  26 **************************************************************************/
  27
  28 /*
  29  * Authors:
  30  *   Keith Whitwell <keithw@vmware.com>
  31  */
  32
  33
  34
  35 /* Display list compiler attempts to store lists of vertices with the
  36  * same vertex layout.  Additionally it attempts to minimize the need
  37  * for execute-time fixup of these vertex lists, allowing them to be
  38  * cached on hardware.
  39  *
  40  * There are still some circumstances where this can be thwarted, for
  41  * example by building a list that consists of one very long primitive
  42  * (eg Begin(Triangles), 1000 vertices, End), and calling that list
  43  * from inside a different begin/end object (Begin(Lines), CallList,
  44  * End).
  45  *
  46  * In that case the code will have to replay the list as individual
  47  * commands through the Exec dispatch table, or fix up the copied
  48  * vertices at execute-time.
  49  *
  50  * The other case where fixup is required is when a vertex attribute
  51  * is introduced in the middle of a primitive.  Eg:
  52  *  Begin(Lines)
  53  *  TexCoord1f()           Vertex2f()
  54  *  TexCoord1f() Color3f() Vertex2f()
  55  *  End()
  56  *
  57  *  If the current value of Color isn't known at compile-time, this
  58  *  primitive will require fixup.
  59  *
  60  *
  61  * The list compiler currently doesn't attempt to compile lists
  62  * containing EvalCoord or EvalPoint commands.  On encountering one of
  63  * these, compilation falls back to opcodes.
  64  *
  65  * This could be improved to fallback only when a mix of EvalCoord and
  66  * Vertex commands are issued within a single primitive.
  67  */
  68
  69
  70 #include "main/glheader.h"
  71 #include "main/arrayobj.h"
  72 #include "main/bufferobj.h"
  73 #include "main/context.h"
  74 #include "main/dlist.h"
  75 #include "main/enums.h"
  76 #include "main/eval.h"
  77 #include "main/macros.h"
  78 #include "main/draw_validate.h"
  79 #include "main/api_arrayelt.h"
  80 #include "main/vtxfmt.h"
  81 #include "main/dispatch.h"
  82 #include "main/state.h"
  83 #include "main/varray.h"
  84 #include "util/bitscan.h"
  85 #include "util/u_memory.h"
  86
  87 #include "vbo_noop.h"
  88 #include "vbo_private.h"
  89
  90
  91 #ifdef ERROR
  92 #undef ERROR
  93 #endif
  94
  95 /**
  96  * Display list flag only used by this VBO code.
  97  */
  98 #define DLIST_DANGLING_REFS     0x1
  99
 100
 101 /* An interesting VBO number/name to help with debugging */
 102 #define VBO_BUF_ID  12345
 103
 104 static void GLAPIENTRY
 105 _save_Materialfv(GLenum face, GLenum pname, const GLfloat *params);
 106
 107 static void GLAPIENTRY
 108 _save_EvalCoord1f(GLfloat u);
 109
 110 static void GLAPIENTRY
 111 _save_EvalCoord2f(GLfloat u, GLfloat v);
 112
 113 /*
 114  * NOTE: Old 'parity' issue is gone, but copying can still be
 115  * wrong-footed on replay.
 116  */
 117 static GLuint
 118 copy_vertices(struct gl_context *ctx,
 119               const struct vbo_save_vertex_list *node,
 120               const fi_type * src_buffer)
 121 {
 122    struct vbo_save_context *save = &vbo_context(ctx)->save;
 123    struct _mesa_prim *prim = &node->prims[node->prim_count - 1];
 124    GLuint sz = save->vertex_size;
 125    const fi_type *src = src_buffer + prim->start * sz;
 126    fi_type *dst = save->copied.buffer;
 127
 128    if (prim->end)
 129       return 0;
 130
 131    return vbo_copy_vertices(ctx, prim->mode, prim->start, &prim->count,
 132                             prim->begin, sz, true, dst, src);
 133 }
 134
 135
 136 static struct vbo_save_vertex_store *
 137 alloc_vertex_store(struct gl_context *ctx, int vertex_count)
 138 {
 139    struct vbo_save_context *save = &vbo_context(ctx)->save;
 140    struct vbo_save_vertex_store *vertex_store =
 141       CALLOC_STRUCT(vbo_save_vertex_store);
 142
 143    int size = MAX2(vertex_count * save->vertex_size, VBO_SAVE_BUFFER_SIZE);
 144
 145    /* obj->Name needs to be non-zero, but won't ever be examined more
 146     * closely than that.  In particular these buffers won't be entered
 147     * into the hash and can never be confused with ones visible to the
 148     * user.  Perhaps there could be a special number for internal
 149     * buffers:
 150     */
 151    vertex_store->bufferobj = ctx->Driver.NewBufferObject(ctx, VBO_BUF_ID);
 152    if (vertex_store->bufferobj) {
 153       save->out_of_memory =
 154          !ctx->Driver.BufferData(ctx,
 155                                  GL_ARRAY_BUFFER_ARB,
 156                                  size * sizeof(GLfloat),
 157                                  NULL, GL_STATIC_DRAW_ARB,
 158                                  GL_MAP_WRITE_BIT |
 159                                  GL_DYNAMIC_STORAGE_BIT,
 160                                  vertex_store->bufferobj);
 161    }
 162    else {
 163       save->out_of_memory = GL_TRUE;
 164    }
 165
 166    if (save->out_of_memory) {
 167       _mesa_error(ctx, GL_OUT_OF_MEMORY, "internal VBO allocation");
 168       _mesa_install_save_vtxfmt(ctx, &save->vtxfmt_noop);
 169    }
 170
 171    vertex_store->buffer_map = NULL;
 172    vertex_store->used = 0;
 173
 174    return vertex_store;
 175 }
 176
 177
 178 static void
 179 free_vertex_store(struct gl_context *ctx,
 180                   struct vbo_save_vertex_store *vertex_store)
 181 {
 182    assert(!vertex_store->buffer_map);
 183
 184    if (vertex_store->bufferobj) {
 185       _mesa_reference_buffer_object(ctx, &vertex_store->bufferobj, NULL);
 186    }
 187
 188    free(vertex_store);
 189 }
 190
 191
 192 fi_type *
 193 vbo_save_map_vertex_store(struct gl_context *ctx,
 194                           struct vbo_save_vertex_store *vertex_store)
 195 {
 196    const GLbitfield access = (GL_MAP_WRITE_BIT |
 197                               GL_MAP_INVALIDATE_RANGE_BIT |
 198                               GL_MAP_UNSYNCHRONIZED_BIT |
 199                               GL_MAP_FLUSH_EXPLICIT_BIT |
 200                               MESA_MAP_ONCE);
 201
 202    assert(vertex_store->bufferobj);
 203    assert(!vertex_store->buffer_map);  /* the buffer should not be mapped */
 204
 205    if (vertex_store->bufferobj->Size > 0) {
 206       /* Map the remaining free space in the VBO */
 207       GLintptr offset = vertex_store->used * sizeof(GLfloat);
 208       GLsizeiptr size = vertex_store->bufferobj->Size - offset;
 209       fi_type *range = (fi_type *)
 210          ctx->Driver.MapBufferRange(ctx, offset, size, access,
 211                                     vertex_store->bufferobj,
 212                                     MAP_INTERNAL);
 213       if (range) {
 214          /* compute address of start of whole buffer (needed elsewhere) */
 215          vertex_store->buffer_map = range - vertex_store->used;
 216          assert(vertex_store->buffer_map);
 217          return range;
 218       }
 219       else {
 220          vertex_store->buffer_map = NULL;
 221          return NULL;
 222       }
 223    }
 224    else {
 225       /* probably ran out of memory for buffers */
 226       return NULL;
 227    }
 228 }
 229
 230
 231 void
 232 vbo_save_unmap_vertex_store(struct gl_context *ctx,
 233                             struct vbo_save_vertex_store *vertex_store)
 234 {
 235    if (vertex_store->bufferobj->Size > 0) {
 236       GLintptr offset = 0;
 237       GLsizeiptr length = vertex_store->used * sizeof(GLfloat)
 238          - vertex_store->bufferobj->Mappings[MAP_INTERNAL].Offset;
 239
 240       /* Explicitly flush the region we wrote to */
 241       ctx->Driver.FlushMappedBufferRange(ctx, offset, length,
 242                                          vertex_store->bufferobj,
 243                                          MAP_INTERNAL);
 244
 245       ctx->Driver.UnmapBuffer(ctx, vertex_store->bufferobj, MAP_INTERNAL);
 246    }
 247    vertex_store->buffer_map = NULL;
 248 }
 249
 250
 251 static struct vbo_save_primitive_store *
 252 alloc_prim_store(int prim_count)
 253 {
 254    struct vbo_save_primitive_store *store =
 255       CALLOC_STRUCT(vbo_save_primitive_store);
 256    store->size = MAX2(prim_count, VBO_SAVE_PRIM_SIZE);
 257    store->prims = calloc(store->size, sizeof(struct _mesa_prim));
 258    store->used = 0;
 259    store->refcount = 1;
 260    return store;
 261 }
 262
 263
 264 static void
 265 reset_counters(struct gl_context *ctx)
 266 {
 267    struct vbo_save_context *save = &vbo_context(ctx)->save;
 268
 269    save->prims = save->prim_store->prims + save->prim_store->used;
 270    save->buffer_map = save->vertex_store->buffer_map + save->vertex_store->used;
 271
 272    assert(save->buffer_map == save->buffer_ptr);
 273
 274    if (save->vertex_size)
 275       save->max_vert = (save->vertex_store->bufferobj->Size / sizeof(float) - save->vertex_store->used) /
 276                         save->vertex_size;
 277    else
 278       save->max_vert = 0;
 279
 280    save->vert_count = 0;
 281    save->prim_count = 0;
 282    save->prim_max = save->prim_store->size - save->prim_store->used;
 283    save->dangling_attr_ref = GL_FALSE;
 284 }
 285
 286 /**
 287  * For a list of prims, try merging prims that can just be extensions of the
 288  * previous prim.
 289  */
 290 static void
 291 merge_prims(struct gl_context *ctx, struct _mesa_prim *prim_list,
 292             GLuint *prim_count)
 293 {
 294    GLuint i;
 295    struct _mesa_prim *prev_prim = prim_list;
 296
 297    for (i = 1; i < *prim_count; i++) {
 298       struct _mesa_prim *this_prim = prim_list + i;
 299
 300       vbo_try_prim_conversion(&this_prim->mode, &this_prim->count);
 301
 302       if (vbo_merge_draws(ctx, true,
 303                           prev_prim->mode, this_prim->mode,
 304                           prev_prim->start, this_prim->start,
 305                           &prev_prim->count, this_prim->count,
 306                           prev_prim->basevertex, this_prim->basevertex,
 307                           &prev_prim->end,
 308                           this_prim->begin, this_prim->end)) {
 309          /* We've found a prim that just extend the previous one.  Tack it
 310           * onto the previous one, and let this primitive struct get dropped.
 311           */
 312          continue;
 313       }
 314
 315       /* If any previous primitives have been dropped, then we need to copy
 316        * this later one into the next available slot.
 317        */
 318       prev_prim++;
 319       if (prev_prim != this_prim)
 320          *prev_prim = *this_prim;
 321    }
 322
 323    *prim_count = prev_prim - prim_list + 1;
 324 }
 325
 326
 327 /**
 328  * Convert GL_LINE_LOOP primitive into GL_LINE_STRIP so that drivers
 329  * don't have to worry about handling the _mesa_prim::begin/end flags.
 330  * See https://bugs.freedesktop.org/show_bug.cgi?id=81174
 331  */
 332 static void
 333 convert_line_loop_to_strip(struct vbo_save_context *save,
 334                            struct vbo_save_vertex_list *node)
 335 {
 336    struct _mesa_prim *prim = &node->prims[node->prim_count - 1];
 337
 338    assert(prim->mode == GL_LINE_LOOP);
 339
 340    if (prim->end) {
 341       /* Copy the 0th vertex to end of the buffer and extend the
 342        * vertex count by one to finish the line loop.
 343        */
 344       const GLuint sz = save->vertex_size;
 345       /* 0th vertex: */
 346       const fi_type *src = save->buffer_map + prim->start * sz;
 347       /* end of buffer: */
 348       fi_type *dst = save->buffer_map + (prim->start + prim->count) * sz;
 349
 350       memcpy(dst, src, sz * sizeof(float));
 351
 352       prim->count++;
 353       node->vertex_count++;
 354       save->vert_count++;
 355       save->buffer_ptr += sz;
 356       save->vertex_store->used += sz;
 357    }
 358
 359    if (!prim->begin) {
 360       /* Drawing the second or later section of a long line loop.
 361        * Skip the 0th vertex.
 362        */
 363       prim->start++;
 364       prim->count--;
 365    }
 366
 367    prim->mode = GL_LINE_STRIP;
 368 }
 369
 370
 371 /* Compare the present vao if it has the same setup. */
 372 static bool
 373 compare_vao(gl_vertex_processing_mode mode,
 374             const struct gl_vertex_array_object *vao,
 375             const struct gl_buffer_object *bo, GLintptr buffer_offset,
 376             GLuint stride, GLbitfield64 vao_enabled,
 377             const GLubyte size[VBO_ATTRIB_MAX],
 378             const GLenum16 type[VBO_ATTRIB_MAX],
 379             const GLuint offset[VBO_ATTRIB_MAX])
 380 {
 381    if (!vao)
 382       return false;
 383
 384    /* If the enabled arrays are not the same we are not equal. */
 385    if (vao_enabled != vao->Enabled)
 386       return false;
 387
 388    /* Check the buffer binding at 0 */
 389    if (vao->BufferBinding[0].BufferObj != bo)
 390       return false;
 391    /* BufferBinding[0].Offset != buffer_offset is checked per attribute */
 392    if (vao->BufferBinding[0].Stride != stride)
 393       return false;
 394    assert(vao->BufferBinding[0].InstanceDivisor == 0);
 395
 396    /* Retrieve the mapping from VBO_ATTRIB to VERT_ATTRIB space */
 397    const GLubyte *const vao_to_vbo_map = _vbo_attribute_alias_map[mode];
 398
 399    /* Now check the enabled arrays */
 400    GLbitfield mask = vao_enabled;
 401    while (mask) {
 402       const int attr = u_bit_scan(&mask);
 403       const unsigned char vbo_attr = vao_to_vbo_map[attr];
 404       const GLenum16 tp = type[vbo_attr];
 405       const GLintptr off = offset[vbo_attr] + buffer_offset;
 406       const struct gl_array_attributes *attrib = &vao->VertexAttrib[attr];
 407       if (attrib->RelativeOffset + vao->BufferBinding[0].Offset != off)
 408          return false;
 409       if (attrib->Format.Type != tp)
 410          return false;
 411       if (attrib->Format.Size != size[vbo_attr])
 412          return false;
 413       assert(attrib->Format.Format == GL_RGBA);
 414       assert(attrib->Format.Normalized == GL_FALSE);
 415       assert(attrib->Format.Integer == vbo_attrtype_to_integer_flag(tp));
 416       assert(attrib->Format.Doubles == vbo_attrtype_to_double_flag(tp));
 417       assert(attrib->BufferBindingIndex == 0);
 418    }
 419
 420    return true;
 421 }
 422
 423
 424 /* Create or reuse the vao for the vertex processing mode. */
 425 static void
 426 update_vao(struct gl_context *ctx,
 427            gl_vertex_processing_mode mode,
 428            struct gl_vertex_array_object **vao,
 429            struct gl_buffer_object *bo, GLintptr buffer_offset,
 430            GLuint stride, GLbitfield64 vbo_enabled,
 431            const GLubyte size[VBO_ATTRIB_MAX],
 432            const GLenum16 type[VBO_ATTRIB_MAX],
 433            const GLuint offset[VBO_ATTRIB_MAX])
 434 {
 435    /* Compute the bitmasks of vao_enabled arrays */
 436    GLbitfield vao_enabled = _vbo_get_vao_enabled_from_vbo(mode, vbo_enabled);
 437
 438    /*
 439     * Check if we can possibly reuse the exisiting one.
 440     * In the long term we should reset them when something changes.
 441     */
 442    if (compare_vao(mode, *vao, bo, buffer_offset, stride,
 443                    vao_enabled, size, type, offset))
 444       return;
 445
 446    /* The initial refcount is 1 */
 447    _mesa_reference_vao(ctx, vao, NULL);
 448    *vao = _mesa_new_vao(ctx, ~((GLuint)0));
 449
 450    /*
 451     * assert(stride <= ctx->Const.MaxVertexAttribStride);
 452     * MaxVertexAttribStride is not set for drivers that does not
 453     * expose GL 44 or GLES 31.
 454     */
 455
 456    /* Bind the buffer object at binding point 0 */
 457    _mesa_bind_vertex_buffer(ctx, *vao, 0, bo, buffer_offset, stride, false,
 458                             false);
 459
 460    /* Retrieve the mapping from VBO_ATTRIB to VERT_ATTRIB space
 461     * Note that the position/generic0 aliasing is done in the VAO.
 462     */
 463    const GLubyte *const vao_to_vbo_map = _vbo_attribute_alias_map[mode];
 464    /* Now set the enable arrays */
 465    GLbitfield mask = vao_enabled;
 466    while (mask) {
 467       const int vao_attr = u_bit_scan(&mask);
 468       const GLubyte vbo_attr = vao_to_vbo_map[vao_attr];
 469       assert(offset[vbo_attr] <= ctx->Const.MaxVertexAttribRelativeOffset);
 470
 471       _vbo_set_attrib_format(ctx, *vao, vao_attr, buffer_offset,
 472                              size[vbo_attr], type[vbo_attr], offset[vbo_attr]);
 473       _mesa_vertex_attrib_binding(ctx, *vao, vao_attr, 0);
 474    }
 475    _mesa_enable_vertex_array_attribs(ctx, *vao, vao_enabled);
 476    assert(vao_enabled == (*vao)->Enabled);
 477    assert((vao_enabled & ~(*vao)->VertexAttribBufferMask) == 0);
 478
 479    /* Finalize and freeze the VAO */
 480    _mesa_set_vao_immutable(ctx, *vao);
 481 }
 482
 483
 484 static void
 485 realloc_storage(struct gl_context *ctx, int prim_count, int vertex_count)
 486 {
 487    struct vbo_save_context *save = &vbo_context(ctx)->save;
 488    if (vertex_count >= 0) {
 489       /* Unmap old store:
 490        */
 491       vbo_save_unmap_vertex_store(ctx, save->vertex_store);
 492
 493       /* Release old reference:
 494        */
 495       free_vertex_store(ctx, save->vertex_store);
 496       save->vertex_store = NULL;
 497       /* When we have a new vbo, we will for sure need a new vao */
 498       for (gl_vertex_processing_mode vpm = 0; vpm < VP_MODE_MAX; ++vpm)
 499          _mesa_reference_vao(ctx, &save->VAO[vpm], NULL);
 500
 501       /* Allocate and map new store:
 502        */
 503       save->vertex_store = alloc_vertex_store(ctx, vertex_count);
 504       save->buffer_ptr = vbo_save_map_vertex_store(ctx, save->vertex_store);
 505       save->out_of_memory = save->buffer_ptr == NULL;
 506    }
 507
 508    if (prim_count >= 0) {
 509       if (--save->prim_store->refcount == 0) {
 510          free(save->prim_store->prims);
 511          free(save->prim_store);
 512       }
 513       save->prim_store = alloc_prim_store(prim_count);
 514    }
 515 }
 516
 517
 518 /**
 519  * Insert the active immediate struct onto the display list currently
 520  * being built.
 521  */
 522 static void
 523 compile_vertex_list(struct gl_context *ctx)
 524 {
 525    struct vbo_save_context *save = &vbo_context(ctx)->save;
 526    struct vbo_save_vertex_list *node;
 527
 528    /* Allocate space for this structure in the display list currently
 529     * being compiled.
 530     */
 531    node = (struct vbo_save_vertex_list *)
 532       _mesa_dlist_alloc_aligned(ctx, save->opcode_vertex_list, sizeof(*node));
 533
 534    if (!node)
 535       return;
 536
 537    /* Make sure the pointer is aligned to the size of a pointer */
 538    assert((GLintptr) node % sizeof(void *) == 0);
 539
 540    /* Duplicate our template, increment refcounts to the storage structs:
 541     */
 542    GLintptr old_offset = 0;
 543    if (save->VAO[0]) {
 544       old_offset = save->VAO[0]->BufferBinding[0].Offset
 545          + save->VAO[0]->VertexAttrib[VERT_ATTRIB_POS].RelativeOffset;
 546    }
 547    const GLsizei stride = save->vertex_size*sizeof(GLfloat);
 548    GLintptr buffer_offset =
 549        (save->buffer_map - save->vertex_store->buffer_map) * sizeof(GLfloat);
 550    assert(old_offset <= buffer_offset);
 551    const GLintptr offset_diff = buffer_offset - old_offset;
 552    GLuint start_offset = 0;
 553    if (offset_diff > 0 && stride > 0 && offset_diff % stride == 0) {
 554       /* The vertex size is an exact multiple of the buffer offset.
 555        * This means that we can use zero-based vertex attribute pointers
 556        * and specify the start of the primitive with the _mesa_prim::start
 557        * field.  This results in issuing several draw calls with identical
 558        * vertex attribute information.  This can result in fewer state
 559        * changes in drivers.  In particular, the Gallium CSO module will
 560        * filter out redundant vertex buffer changes.
 561        */
 562       /* We cannot immediately update the primitives as some methods below
 563        * still need the uncorrected start vertices
 564        */
 565       start_offset = offset_diff/stride;
 566       assert(old_offset == buffer_offset - offset_diff);
 567       buffer_offset = old_offset;
 568    }
 569    GLuint offsets[VBO_ATTRIB_MAX];
 570    for (unsigned i = 0, offset = 0; i < VBO_ATTRIB_MAX; ++i) {
 571       offsets[i] = offset;
 572       offset += save->attrsz[i] * sizeof(GLfloat);
 573    }
 574    node->vertex_count = save->vert_count;
 575    node->wrap_count = save->copied.nr;
 576    node->prims = save->prims;
 577    node->merged.prims = NULL;
 578    node->merged.ib.obj = NULL;
 579    node->merged.prim_count = 0;
 580    node->prim_count = save->prim_count;
 581    node->prim_store = save->prim_store;
 582
 583    /* Create a pair of VAOs for the possible VERTEX_PROCESSING_MODEs
 584     * Note that this may reuse the previous one of possible.
 585     */
 586    for (gl_vertex_processing_mode vpm = VP_MODE_FF; vpm < VP_MODE_MAX; ++vpm) {
 587       /* create or reuse the vao */
 588       update_vao(ctx, vpm, &save->VAO[vpm],
 589                  save->vertex_store->bufferobj, buffer_offset, stride,
 590                  save->enabled, save->attrsz, save->attrtype, offsets);
 591       /* Reference the vao in the dlist */
 592       node->VAO[vpm] = NULL;
 593       _mesa_reference_vao(ctx, &node->VAO[vpm], save->VAO[vpm]);
 594    }
 595
 596    node->prim_store->refcount++;
 597
 598    if (save->no_current_update) {
 599       node->current_data = NULL;
 600    }
 601    else {
 602       GLuint current_size = save->vertex_size - save->attrsz[0];
 603       node->current_data = NULL;
 604
 605       if (current_size) {
 606          node->current_data = malloc(current_size * sizeof(GLfloat));
 607          if (node->current_data) {
 608             const char *buffer = (const char *)save->buffer_map;
 609             unsigned attr_offset = save->attrsz[0] * sizeof(GLfloat);
 610             unsigned vertex_offset = 0;
 611
 612             if (node->vertex_count)
 613                vertex_offset = (node->vertex_count - 1) * stride;
 614
 615             memcpy(node->current_data, buffer + vertex_offset + attr_offset,
 616                    current_size * sizeof(GLfloat));
 617          } else {
 618             _mesa_error(ctx, GL_OUT_OF_MEMORY, "Current value allocation");
 619          }
 620       }
 621    }
 622
 623    assert(save->attrsz[VBO_ATTRIB_POS] != 0 || node->vertex_count == 0);
 624
 625    if (save->dangling_attr_ref)
 626       ctx->ListState.CurrentList->Flags |= DLIST_DANGLING_REFS;
 627
 628    save->vertex_store->used += save->vertex_size * node->vertex_count;
 629    save->prim_store->used += node->prim_count;
 630
 631    /* Copy duplicated vertices
 632     */
 633    save->copied.nr = copy_vertices(ctx, node, save->buffer_map);
 634
 635    if (node->prims[node->prim_count - 1].mode == GL_LINE_LOOP) {
 636       convert_line_loop_to_strip(save, node);
 637    }
 638
 639    merge_prims(ctx, node->prims, &node->prim_count);
 640
 641    /* Correct the primitive starts, we can only do this here as copy_vertices
 642     * and convert_line_loop_to_strip above consume the uncorrected starts.
 643     * On the other hand the _vbo_loopback_vertex_list call below needs the
 644     * primitves to be corrected already.
 645     */
 646    for (unsigned i = 0; i < node->prim_count; i++) {
 647       node->prims[i].start += start_offset;
 648    }
 649
 650    /* Create an index buffer. */
 651    node->min_index = node->max_index = 0;
 652    if (save->vert_count) {
 653       /* We won't modify node->prims, so use a const alias to avoid unintended
 654        * writes to it. */
 655       const struct _mesa_prim *original_prims = node->prims;
 656
 657       int end = original_prims[node->prim_count - 1].start +
 658                 original_prims[node->prim_count - 1].count;
 659       int total_vert_count = end - original_prims[0].start;
 660
 661       node->min_index = node->prims[0].start;
 662       node->max_index = end - 1;
 663
 664       /* Estimate for the worst case: all prims are line strips (the +1 is because
 665        * wrap_buffers may call use but the last primitive may not be complete) */
 666       int max_indices_count = MAX2(total_vert_count * 2 - (node->prim_count * 2) + 1,
 667                                    total_vert_count);
 668       int size = max_indices_count * sizeof(uint32_t);
 669       uint32_t* indices = (uint32_t*) malloc(size);
 670       uint32_t max_index = 0, min_index = 0xFFFFFFFF;
 671
 672       int idx = 0;
 673
 674       int last_valid_prim = -1;
 675       /* Construct indices array. */
 676       for (unsigned i = 0; i < node->prim_count; i++) {
 677          assert(original_prims[i].basevertex == 0);
 678          GLubyte mode = original_prims[i].mode;
 679
 680          int vertex_count = original_prims[i].count;
 681          if (!vertex_count) {
 682             continue;
 683          }
 684
 685          /* Line strips get converted to lines */
 686          if (mode == GL_LINE_STRIP)
 687             mode = GL_LINES;
 688
 689          /* If 2 consecutive prims use the same mode => merge them. */
 690          bool merge_prims = last_valid_prim >= 0 &&
 691                             mode == node->merged.prims[last_valid_prim].mode &&
 692                             mode != GL_LINE_LOOP && mode != GL_TRIANGLE_FAN &&
 693                             mode != GL_QUAD_STRIP && mode != GL_POLYGON &&
 694                             mode != GL_PATCHES;
 695
 696          /* To be able to merge consecutive triangle strips we need to insert
 697           * a degenerate triangle.
 698           */
 699          if (merge_prims &&
 700              mode == GL_TRIANGLE_STRIP) {
 701             /* Insert a degenerate triangle */
 702             assert(node->merged.prims[last_valid_prim].mode == GL_TRIANGLE_STRIP);
 703             unsigned tri_count = node->merged.prims[last_valid_prim].count - 2;
 704
 705             indices[idx] = indices[idx - 1];
 706             indices[idx + 1] = original_prims[i].start;
 707             idx += 2;
 708             node->merged.prims[last_valid_prim].count += 2;
 709
 710             if (tri_count % 2) {
 711                /* Add another index to preserve winding order */
 712                indices[idx++] = original_prims[i].start;
 713                node->merged.prims[last_valid_prim].count++;
 714             }
 715          }
 716
 717          int start = idx;
 718
 719          /* Convert line strips to lines if it'll allow if the previous
 720           * prim mode is GL_LINES (so merge_prims is true) or if the next
 721           * primitive mode is GL_LINES or GL_LINE_LOOP.
 722           */
 723          if (original_prims[i].mode == GL_LINE_STRIP &&
 724              (merge_prims ||
 725               (i < node->prim_count - 1 &&
 726                (original_prims[i + 1].mode == GL_LINE_STRIP ||
 727                 original_prims[i + 1].mode == GL_LINES)))) {
 728             for (unsigned j = 0; j < vertex_count; j++) {
 729                indices[idx++] = original_prims[i].start + j;
 730                /* Repeat all but the first/last indices. */
 731                if (j && j != vertex_count - 1) {
 732                   indices[idx++] = original_prims[i].start + j;
 733                }
 734             }
 735          } else {
 736             for (unsigned j = 0; j < vertex_count; j++) {
 737                indices[idx++] = original_prims[i].start + j;
 738             }
 739          }
 740
 741          min_index = MIN2(min_index, indices[start]);
 742          max_index = MAX2(max_index, indices[idx - 1]);
 743
 744          if (merge_prims) {
 745             /* Update vertex count. */
 746             node->merged.prims[last_valid_prim].count += idx - start;
 747          } else {
 748             /* Keep this primitive */
 749             last_valid_prim += 1;
 750             assert(last_valid_prim <= i);
 751             node->merged.prims = realloc(node->merged.prims, (1 + last_valid_prim) * sizeof(struct _mesa_prim));
 752             node->merged.prims[last_valid_prim] = original_prims[i];
 753             node->merged.prims[last_valid_prim].start = start;
 754             node->merged.prims[last_valid_prim].count = idx - start;
 755          }
 756          node->merged.prims[last_valid_prim].mode = mode;
 757       }
 758
 759       if (idx == 0)
 760          goto skip_node;
 761
 762       assert(idx <= max_indices_count);
 763
 764       node->merged.prim_count = last_valid_prim + 1;
 765       node->merged.ib.ptr = NULL;
 766       node->merged.ib.count = idx;
 767       node->merged.ib.index_size_shift = (GL_UNSIGNED_INT - GL_UNSIGNED_BYTE) >> 1;
 768       node->merged.min_index = min_index;
 769       node->merged.max_index = max_index;
 770
 771       node->merged.ib.obj = ctx->Driver.NewBufferObject(ctx, VBO_BUF_ID + 1);
 772       bool success = ctx->Driver.BufferData(ctx,
 773                                             GL_ELEMENT_ARRAY_BUFFER_ARB,
 774                                             idx * sizeof(uint32_t), indices,
 775                                             GL_STATIC_DRAW_ARB, GL_MAP_WRITE_BIT,
 776                                             node->merged.ib.obj);
 777
 778       if (success)
 779          goto out;
 780
 781       ctx->Driver.DeleteBuffer(ctx, node->merged.ib.obj);
 782       _mesa_error(ctx, GL_OUT_OF_MEMORY, "IB allocation");
 783
 784    skip_node:
 785       node->merged.ib.obj = NULL;
 786       node->vertex_count = 0;
 787       node->prim_count = 0;
 788
 789    out:
 790       free(indices);
 791    }
 792
 793    /* Deal with GL_COMPILE_AND_EXECUTE:
 794     */
 795    if (ctx->ExecuteFlag) {
 796       struct _glapi_table *dispatch = GET_DISPATCH();
 797
 798       _glapi_set_dispatch(ctx->Exec);
 799
 800       /* Note that the range of referenced vertices must be mapped already */
 801       _vbo_loopback_vertex_list(ctx, node);
 802
 803       _glapi_set_dispatch(dispatch);
 804    }
 805
 806    /* Decide whether the storage structs are full, or can be used for
 807     * the next vertex lists as well.
 808     */
 809    if (save->vertex_store->used >
 810        save->vertex_store->bufferobj->Size / sizeof(float) - 16 * (save->vertex_size + 4)) {
 811       realloc_storage(ctx, -1, 0);
 812    }
 813    else {
 814       /* update buffer_ptr for next vertex */
 815       save->buffer_ptr = save->vertex_store->buffer_map
 816          + save->vertex_store->used;
 817    }
 818
 819    if (save->prim_store->used > save->prim_store->size - 6) {
 820       realloc_storage(ctx, 0, -1);
 821    }
 822
 823    /* Reset our structures for the next run of vertices:
 824     */
 825    reset_counters(ctx);
 826 }
 827
 828
 829 /**
 830  * This is called when we fill a vertex buffer before we hit a glEnd().
 831  * We
 832  * TODO -- If no new vertices have been stored, don't bother saving it.
 833  */
 834 static void
 835 wrap_buffers(struct gl_context *ctx)
 836 {
 837    struct vbo_save_context *save = &vbo_context(ctx)->save;
 838    GLint i = save->prim_count - 1;
 839    GLenum mode;
 840
 841    assert(i < (GLint) save->prim_max);
 842    assert(i >= 0);
 843
 844    /* Close off in-progress primitive.
 845     */
 846    save->prims[i].count = (save->vert_count - save->prims[i].start);
 847    mode = save->prims[i].mode;
 848
 849    /* store the copied vertices, and allocate a new list.
 850     */
 851    compile_vertex_list(ctx);
 852
 853    /* Restart interrupted primitive
 854     */
 855    save->prims[0].mode = mode;
 856    save->prims[0].begin = 0;
 857    save->prims[0].end = 0;
 858    save->prims[0].start = 0;
 859    save->prims[0].count = 0;
 860    save->prim_count = 1;
 861 }
 862
 863
 864 /**
 865  * Called only when buffers are wrapped as the result of filling the
 866  * vertex_store struct.
 867  */
 868 static void
 869 wrap_filled_vertex(struct gl_context *ctx)
 870 {
 871    struct vbo_save_context *save = &vbo_context(ctx)->save;
 872    unsigned numComponents;
 873
 874    /* Emit a glEnd to close off the last vertex list.
 875     */
 876    wrap_buffers(ctx);
 877
 878    /* Copy stored stored vertices to start of new list.
 879     */
 880    assert(save->max_vert - save->vert_count > save->copied.nr);
 881
 882    numComponents = save->copied.nr * save->vertex_size;
 883    memcpy(save->buffer_ptr,
 884           save->copied.buffer,
 885           numComponents * sizeof(fi_type));
 886    save->buffer_ptr += numComponents;
 887    save->vert_count += save->copied.nr;
 888 }
 889
 890
 891 static void
 892 copy_to_current(struct gl_context *ctx)
 893 {
 894    struct vbo_save_context *save = &vbo_context(ctx)->save;
 895    GLbitfield64 enabled = save->enabled & (~BITFIELD64_BIT(VBO_ATTRIB_POS));
 896
 897    while (enabled) {
 898       const int i = u_bit_scan64(&enabled);
 899       assert(save->attrsz[i]);
 900
 901       if (save->attrtype[i] == GL_DOUBLE ||
 902           save->attrtype[i] == GL_UNSIGNED_INT64_ARB)
 903          memcpy(save->current[i], save->attrptr[i], save->attrsz[i] * sizeof(GLfloat));
 904       else
 905          COPY_CLEAN_4V_TYPE_AS_UNION(save->current[i], save->attrsz[i],
 906                                      save->attrptr[i], save->attrtype[i]);
 907    }
 908 }
 909
 910
 911 static void
 912 copy_from_current(struct gl_context *ctx)
 913 {
 914    struct vbo_save_context *save = &vbo_context(ctx)->save;
 915    GLbitfield64 enabled = save->enabled & (~BITFIELD64_BIT(VBO_ATTRIB_POS));
 916
 917    while (enabled) {
 918       const int i = u_bit_scan64(&enabled);
 919
 920       switch (save->attrsz[i]) {
 921       case 4:
 922          save->attrptr[i][3] = save->current[i][3];
 923          FALLTHROUGH;
 924       case 3:
 925          save->attrptr[i][2] = save->current[i][2];
 926          FALLTHROUGH;
 927       case 2:
 928          save->attrptr[i][1] = save->current[i][1];
 929          FALLTHROUGH;
 930       case 1:
 931          save->attrptr[i][0] = save->current[i][0];
 932          break;
 933       case 0:
 934          unreachable("Unexpected vertex attribute size");
 935       }
 936    }
 937 }
 938
 939
 940 /**
 941  * Called when we increase the size of a vertex attribute.  For example,
 942  * if we've seen one or more glTexCoord2f() calls and now we get a
 943  * glTexCoord3f() call.
 944  * Flush existing data, set new attrib size, replay copied vertices.
 945  */
 946 static void
 947 upgrade_vertex(struct gl_context *ctx, GLuint attr, GLuint newsz)
 948 {
 949    struct vbo_save_context *save = &vbo_context(ctx)->save;
 950    GLuint oldsz;
 951    GLuint i;
 952    fi_type *tmp;
 953
 954    /* Store the current run of vertices, and emit a GL_END.  Emit a
 955     * BEGIN in the new buffer.
 956     */
 957    if (save->vert_count)
 958       wrap_buffers(ctx);
 959    else
 960       assert(save->copied.nr == 0);
 961
 962    /* Do a COPY_TO_CURRENT to ensure back-copying works for the case
 963     * when the attribute already exists in the vertex and is having
 964     * its size increased.
 965     */
 966    copy_to_current(ctx);
 967
 968    /* Fix up sizes:
 969     */
 970    oldsz = save->attrsz[attr];
 971    save->attrsz[attr] = newsz;
 972    save->enabled |= BITFIELD64_BIT(attr);
 973
 974    save->vertex_size += newsz - oldsz;
 975    save->max_vert = ((save->vertex_store->bufferobj->Size / sizeof(float) -
 976                       save->vertex_store->used) /
 977                      save->vertex_size);
 978    save->vert_count = 0;
 979
 980    /* Recalculate all the attrptr[] values:
 981     */
 982    tmp = save->vertex;
 983    for (i = 0; i < VBO_ATTRIB_MAX; i++) {
 984       if (save->attrsz[i]) {
 985          save->attrptr[i] = tmp;
 986          tmp += save->attrsz[i];
 987       }
 988       else {
 989          save->attrptr[i] = NULL;       /* will not be dereferenced. */
 990       }
 991    }
 992
 993    /* Copy from current to repopulate the vertex with correct values.
 994     */
 995    copy_from_current(ctx);
 996
 997    /* Replay stored vertices to translate them to new format here.
 998     *
 999     * If there are copied vertices and the new (upgraded) attribute
1000     * has not been defined before, this list is somewhat degenerate,
1001     * and will need fixup at runtime.
1002     */
1003    if (save->copied.nr) {
1004       const fi_type *data = save->copied.buffer;
1005       fi_type *dest = save->buffer_map;
1006
1007       /* Need to note this and fix up at runtime (or loopback):
1008        */
1009       if (attr != VBO_ATTRIB_POS && save->currentsz[attr][0] == 0) {
1010          assert(oldsz == 0);
1011          save->dangling_attr_ref = GL_TRUE;
1012       }
1013
1014       for (i = 0; i < save->copied.nr; i++) {
1015          GLbitfield64 enabled = save->enabled;
1016          while (enabled) {
1017             const int j = u_bit_scan64(&enabled);
1018             assert(save->attrsz[j]);
1019             if (j == attr) {
1020                if (oldsz) {
1021                   COPY_CLEAN_4V_TYPE_AS_UNION(dest, oldsz, data,
1022                                               save->attrtype[j]);
1023                   data += oldsz;
1024                   dest += newsz;
1025                }
1026                else {
1027                   COPY_SZ_4V(dest, newsz, save->current[attr]);
1028                   dest += newsz;
1029                }
1030             }
1031             else {
1032                GLint sz = save->attrsz[j];
1033                COPY_SZ_4V(dest, sz, data);
1034                data += sz;
1035                dest += sz;
1036             }
1037          }
1038       }
1039
1040       save->buffer_ptr = dest;
1041       save->vert_count += save->copied.nr;
1042    }
1043 }
1044
1045
1046 /**
1047  * This is called when the size of a vertex attribute changes.
1048  * For example, after seeing one or more glTexCoord2f() calls we
1049  * get a glTexCoord4f() or glTexCoord1f() call.
1050  */
1051 static void
1052 fixup_vertex(struct gl_context *ctx, GLuint attr,
1053              GLuint sz, GLenum newType)
1054 {
1055    struct vbo_save_context *save = &vbo_context(ctx)->save;
1056
1057    if (sz > save->attrsz[attr] ||
1058        newType != save->attrtype[attr]) {
1059       /* New size is larger.  Need to flush existing vertices and get
1060        * an enlarged vertex format.
1061        */
1062       upgrade_vertex(ctx, attr, sz);
1063    }
1064    else if (sz < save->active_sz[attr]) {
1065       GLuint i;
1066       const fi_type *id = vbo_get_default_vals_as_union(save->attrtype[attr]);
1067
1068       /* New size is equal or smaller - just need to fill in some
1069        * zeros.
1070        */
1071       for (i = sz; i <= save->attrsz[attr]; i++)
1072          save->attrptr[attr][i - 1] = id[i - 1];
1073    }
1074
1075    save->active_sz[attr] = sz;
1076 }
1077
1078
1079 /**
1080  * Reset the current size of all vertex attributes to the default
1081  * value of 0.  This signals that we haven't yet seen any per-vertex
1082  * commands such as glNormal3f() or glTexCoord2f().
1083  */
1084 static void
1085 reset_vertex(struct gl_context *ctx)
1086 {
1087    struct vbo_save_context *save = &vbo_context(ctx)->save;
1088
1089    while (save->enabled) {
1090       const int i = u_bit_scan64(&save->enabled);
1091       assert(save->attrsz[i]);
1092       save->attrsz[i] = 0;
1093       save->active_sz[i] = 0;
1094    }
1095
1096    save->vertex_size = 0;
1097 }
1098
1099
1100 /**
1101  * If index=0, does glVertexAttrib*() alias glVertex() to emit a vertex?
1102  * It depends on a few things, including whether we're inside or outside
1103  * of glBegin/glEnd.
1104  */
1105 static inline bool
1106 is_vertex_position(const struct gl_context *ctx, GLuint index)
1107 {
1108    return (index == 0 &&
1109            _mesa_attr_zero_aliases_vertex(ctx) &&
1110            _mesa_inside_dlist_begin_end(ctx));
1111 }
1112
1113
1114
1115 #define ERROR(err)   _mesa_compile_error(ctx, err, __func__);
1116
1117
1118 /* Only one size for each attribute may be active at once.  Eg. if
1119  * Color3f is installed/active, then Color4f may not be, even if the
1120  * vertex actually contains 4 color coordinates.  This is because the
1121  * 3f version won't otherwise set color[3] to 1.0 -- this is the job
1122  * of the chooser function when switching between Color4f and Color3f.
1123  */
1124 #define ATTR_UNION(A, N, T, C, V0, V1, V2, V3)                  \
1125 do {                                                            \
1126    struct vbo_save_context *save = &vbo_context(ctx)->save;     \
1127    int sz = (sizeof(C) / sizeof(GLfloat));                      \
1128                                                                 \
1129    if (save->active_sz[A] != N)                                 \
1130       fixup_vertex(ctx, A, N * sz, T);                          \
1131                                                                 \
1132    {                                                            \
1133       C *dest = (C *)save->attrptr[A];                          \
1134       if (N>0) dest[0] = V0;                                    \
1135       if (N>1) dest[1] = V1;                                    \
1136       if (N>2) dest[2] = V2;                                    \
1137       if (N>3) dest[3] = V3;                                    \
1138       save->attrtype[A] = T;                                    \
1139    }                                                            \
1140                                                                 \
1141    if ((A) == 0) {                                              \
1142       GLuint i;                                                 \
1143                                                                 \
1144       for (i = 0; i < save->vertex_size; i++)                   \
1145          save->buffer_ptr[i] = save->vertex[i];                 \
1146                                                                 \
1147       save->buffer_ptr += save->vertex_size;                    \
1148                                                                 \
1149       if (++save->vert_count >= save->max_vert)                 \
1150          wrap_filled_vertex(ctx);                               \
1151    }                                                            \
1152 } while (0)
1153
1154 #define TAG(x) _save_##x
1155
1156 #include "vbo_attrib_tmp.h"
1157
1158
1159
1160 #define MAT( ATTR, N, face, params )                    \
1161 do {                                                    \
1162    if (face != GL_BACK)                                 \
1163       MAT_ATTR( ATTR, N, params ); /* front */          \
1164    if (face != GL_FRONT)                                \
1165       MAT_ATTR( ATTR + 1, N, params ); /* back */       \
1166 } while (0)
1167
1168
1169 /**
1170  * Save a glMaterial call found between glBegin/End.
1171  * glMaterial calls outside Begin/End are handled in dlist.c.
1172  */
1173 static void GLAPIENTRY
1174 _save_Materialfv(GLenum face, GLenum pname, const GLfloat *params)
1175 {
1176    GET_CURRENT_CONTEXT(ctx);
1177
1178    if (face != GL_FRONT && face != GL_BACK && face != GL_FRONT_AND_BACK) {
1179       _mesa_compile_error(ctx, GL_INVALID_ENUM, "glMaterial(face)");
1180       return;
1181    }
1182
1183    switch (pname) {
1184    case GL_EMISSION:
1185       MAT(VBO_ATTRIB_MAT_FRONT_EMISSION, 4, face, params);
1186       break;
1187    case GL_AMBIENT:
1188       MAT(VBO_ATTRIB_MAT_FRONT_AMBIENT, 4, face, params);
1189       break;
1190    case GL_DIFFUSE:
1191       MAT(VBO_ATTRIB_MAT_FRONT_DIFFUSE, 4, face, params);
1192       break;
1193    case GL_SPECULAR:
1194       MAT(VBO_ATTRIB_MAT_FRONT_SPECULAR, 4, face, params);
1195       break;
1196    case GL_SHININESS:
1197       if (*params < 0 || *params > ctx->Const.MaxShininess) {
1198          _mesa_compile_error(ctx, GL_INVALID_VALUE, "glMaterial(shininess)");
1199       }
1200       else {
1201          MAT(VBO_ATTRIB_MAT_FRONT_SHININESS, 1, face, params);
1202       }
1203       break;
1204    case GL_COLOR_INDEXES:
1205       MAT(VBO_ATTRIB_MAT_FRONT_INDEXES, 3, face, params);
1206       break;
1207    case GL_AMBIENT_AND_DIFFUSE:
1208       MAT(VBO_ATTRIB_MAT_FRONT_AMBIENT, 4, face, params);
1209       MAT(VBO_ATTRIB_MAT_FRONT_DIFFUSE, 4, face, params);
1210       break;
1211    default:
1212       _mesa_compile_error(ctx, GL_INVALID_ENUM, "glMaterial(pname)");
1213       return;
1214    }
1215 }
1216
1217
1218 /* Cope with EvalCoord/CallList called within a begin/end object:
1219  *     -- Flush current buffer
1220  *     -- Fallback to opcodes for the rest of the begin/end object.
1221  */
1222 static void
1223 dlist_fallback(struct gl_context *ctx)
1224 {
1225    struct vbo_save_context *save = &vbo_context(ctx)->save;
1226
1227    if (save->vert_count || save->prim_count) {
1228       if (save->prim_count > 0) {
1229          /* Close off in-progress primitive. */
1230          GLint i = save->prim_count - 1;
1231          save->prims[i].count = save->vert_count - save->prims[i].start;
1232       }
1233
1234       /* Need to replay this display list with loopback,
1235        * unfortunately, otherwise this primitive won't be handled
1236        * properly:
1237        */
1238       save->dangling_attr_ref = GL_TRUE;
1239
1240       compile_vertex_list(ctx);
1241    }
1242
1243    copy_to_current(ctx);
1244    reset_vertex(ctx);
1245    reset_counters(ctx);
1246    if (save->out_of_memory) {
1247       _mesa_install_save_vtxfmt(ctx, &save->vtxfmt_noop);
1248    }
1249    else {
1250       _mesa_install_save_vtxfmt(ctx, &ctx->ListState.ListVtxfmt);
1251    }
1252    ctx->Driver.SaveNeedFlush = GL_FALSE;
1253 }
1254
1255
1256 static void GLAPIENTRY
1257 _save_EvalCoord1f(GLfloat u)
1258 {
1259    GET_CURRENT_CONTEXT(ctx);
1260    dlist_fallback(ctx);
1261    CALL_EvalCoord1f(ctx->Save, (u));
1262 }
1263
1264 static void GLAPIENTRY
1265 _save_EvalCoord1fv(const GLfloat * v)
1266 {
1267    GET_CURRENT_CONTEXT(ctx);
1268    dlist_fallback(ctx);
1269    CALL_EvalCoord1fv(ctx->Save, (v));
1270 }
1271
1272 static void GLAPIENTRY
1273 _save_EvalCoord2f(GLfloat u, GLfloat v)
1274 {
1275    GET_CURRENT_CONTEXT(ctx);
1276    dlist_fallback(ctx);
1277    CALL_EvalCoord2f(ctx->Save, (u, v));
1278 }
1279
1280 static void GLAPIENTRY
1281 _save_EvalCoord2fv(const GLfloat * v)
1282 {
1283    GET_CURRENT_CONTEXT(ctx);
1284    dlist_fallback(ctx);
1285    CALL_EvalCoord2fv(ctx->Save, (v));
1286 }
1287
1288 static void GLAPIENTRY
1289 _save_EvalPoint1(GLint i)
1290 {
1291    GET_CURRENT_CONTEXT(ctx);
1292    dlist_fallback(ctx);
1293    CALL_EvalPoint1(ctx->Save, (i));
1294 }
1295
1296 static void GLAPIENTRY
1297 _save_EvalPoint2(GLint i, GLint j)
1298 {
1299    GET_CURRENT_CONTEXT(ctx);
1300    dlist_fallback(ctx);
1301    CALL_EvalPoint2(ctx->Save, (i, j));
1302 }
1303
1304 static void GLAPIENTRY
1305 _save_CallList(GLuint l)
1306 {
1307    GET_CURRENT_CONTEXT(ctx);
1308    dlist_fallback(ctx);
1309    CALL_CallList(ctx->Save, (l));
1310 }
1311
1312 static void GLAPIENTRY
1313 _save_CallLists(GLsizei n, GLenum type, const GLvoid * v)
1314 {
1315    GET_CURRENT_CONTEXT(ctx);
1316    dlist_fallback(ctx);
1317    CALL_CallLists(ctx->Save, (n, type, v));
1318 }
1319
1320
1321
1322 /**
1323  * Called when a glBegin is getting compiled into a display list.
1324  * Updating of ctx->Driver.CurrentSavePrimitive is already taken care of.
1325  */
1326 void
1327 vbo_save_NotifyBegin(struct gl_context *ctx, GLenum mode,
1328                      bool no_current_update)
1329 {
1330    struct vbo_save_context *save = &vbo_context(ctx)->save;
1331    const GLuint i = save->prim_count++;
1332
1333    ctx->Driver.CurrentSavePrimitive = mode;
1334
1335    assert(i < save->prim_max);
1336    save->prims[i].mode = mode & VBO_SAVE_PRIM_MODE_MASK;
1337    save->prims[i].begin = 1;
1338    save->prims[i].end = 0;
1339    save->prims[i].start = save->vert_count;
1340    save->prims[i].count = 0;
1341
1342    save->no_current_update = no_current_update;
1343
1344    if (save->out_of_memory) {
1345       _mesa_install_save_vtxfmt(ctx, &save->vtxfmt_noop);
1346    }
1347    else {
1348       _mesa_install_save_vtxfmt(ctx, &save->vtxfmt);
1349    }
1350
1351    /* We need to call vbo_save_SaveFlushVertices() if there's state change */
1352    ctx->Driver.SaveNeedFlush = GL_TRUE;
1353 }
1354
1355
1356 static void GLAPIENTRY
1357 _save_End(void)
1358 {
1359    GET_CURRENT_CONTEXT(ctx);
1360    struct vbo_save_context *save = &vbo_context(ctx)->save;
1361    const GLint i = save->prim_count - 1;
1362
1363    ctx->Driver.CurrentSavePrimitive = PRIM_OUTSIDE_BEGIN_END;
1364    save->prims[i].end = 1;
1365    save->prims[i].count = (save->vert_count - save->prims[i].start);
1366
1367    if (i == (GLint) save->prim_max - 1) {
1368       compile_vertex_list(ctx);
1369       assert(save->copied.nr == 0);
1370    }
1371
1372    /* Swap out this vertex format while outside begin/end.  Any color,
1373     * etc. received between here and the next begin will be compiled
1374     * as opcodes.
1375     */
1376    if (save->out_of_memory) {
1377       _mesa_install_save_vtxfmt(ctx, &save->vtxfmt_noop);
1378    }
1379    else {
1380       _mesa_install_save_vtxfmt(ctx, &ctx->ListState.ListVtxfmt);
1381    }
1382 }
1383
1384
1385 static void GLAPIENTRY
1386 _save_Begin(GLenum mode)
1387 {
1388    GET_CURRENT_CONTEXT(ctx);
1389    (void) mode;
1390    _mesa_compile_error(ctx, GL_INVALID_OPERATION, "Recursive glBegin");
1391 }
1392
1393
1394 static void GLAPIENTRY
1395 _save_PrimitiveRestartNV(void)
1396 {
1397    GET_CURRENT_CONTEXT(ctx);
1398    struct vbo_save_context *save = &vbo_context(ctx)->save;
1399
1400    if (save->prim_count == 0) {
1401       /* We're not inside a glBegin/End pair, so calling glPrimitiverRestartNV
1402        * is an error.
1403        */
1404       _mesa_compile_error(ctx, GL_INVALID_OPERATION,
1405                           "glPrimitiveRestartNV called outside glBegin/End");
1406    } else {
1407       /* get current primitive mode */
1408       GLenum curPrim = save->prims[save->prim_count - 1].mode;
1409       bool no_current_update = save->no_current_update;
1410
1411       /* restart primitive */
1412       CALL_End(ctx->CurrentServerDispatch, ());
1413       vbo_save_NotifyBegin(ctx, curPrim, no_current_update);
1414    }
1415 }
1416
1417
1418 /* Unlike the functions above, these are to be hooked into the vtxfmt
1419  * maintained in ctx->ListState, active when the list is known or
1420  * suspected to be outside any begin/end primitive.
1421  * Note: OBE = Outside Begin/End
1422  */
1423 static void GLAPIENTRY
1424 _save_OBE_Rectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
1425 {
1426    GET_CURRENT_CONTEXT(ctx);
1427    struct _glapi_table *dispatch = ctx->CurrentServerDispatch;
1428
1429    vbo_save_NotifyBegin(ctx, GL_QUADS, false);
1430    CALL_Vertex2f(dispatch, (x1, y1));
1431    CALL_Vertex2f(dispatch, (x2, y1));
1432    CALL_Vertex2f(dispatch, (x2, y2));
1433    CALL_Vertex2f(dispatch, (x1, y2));
1434    CALL_End(dispatch, ());
1435 }
1436
1437
1438 static void GLAPIENTRY
1439 _save_OBE_Rectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
1440 {
1441    _save_OBE_Rectf((GLfloat) x1, (GLfloat) y1, (GLfloat) x2, (GLfloat) y2);
1442 }
1443
1444 static void GLAPIENTRY
1445 _save_OBE_Rectdv(const GLdouble *v1, const GLdouble *v2)
1446 {
1447    _save_OBE_Rectf((GLfloat) v1[0], (GLfloat) v1[1], (GLfloat) v2[0], (GLfloat) v2[1]);
1448 }
1449
1450 static void GLAPIENTRY
1451 _save_OBE_Rectfv(const GLfloat *v1, const GLfloat *v2)
1452 {
1453    _save_OBE_Rectf(v1[0], v1[1], v2[0], v2[1]);
1454 }
1455
1456 static void GLAPIENTRY
1457 _save_OBE_Recti(GLint x1, GLint y1, GLint x2, GLint y2)
1458 {
1459    _save_OBE_Rectf((GLfloat) x1, (GLfloat) y1, (GLfloat) x2, (GLfloat) y2);
1460 }
1461
1462 static void GLAPIENTRY
1463 _save_OBE_Rectiv(const GLint *v1, const GLint *v2)
1464 {
1465    _save_OBE_Rectf((GLfloat) v1[0], (GLfloat) v1[1], (GLfloat) v2[0], (GLfloat) v2[1]);
1466 }
1467
1468 static void GLAPIENTRY
1469 _save_OBE_Rects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
1470 {
1471    _save_OBE_Rectf((GLfloat) x1, (GLfloat) y1, (GLfloat) x2, (GLfloat) y2);
1472 }
1473
1474 static void GLAPIENTRY
1475 _save_OBE_Rectsv(const GLshort *v1, const GLshort *v2)
1476 {
1477    _save_OBE_Rectf((GLfloat) v1[0], (GLfloat) v1[1], (GLfloat) v2[0], (GLfloat) v2[1]);
1478 }
1479
1480 static void
1481 _ensure_draws_fits_in_storage(struct gl_context *ctx, int primcount, int vertcount)
1482 {
1483    struct vbo_save_context *save = &vbo_context(ctx)->save;
1484
1485    bool realloc_prim = save->prim_count + primcount > save->prim_max;
1486    bool realloc_vert = save->vertex_size && (save->vert_count + vertcount >= save->max_vert);
1487
1488    if (realloc_prim || realloc_vert) {
1489       if (save->vert_count || save->prim_count)
1490          compile_vertex_list(ctx);
1491       realloc_storage(ctx, realloc_prim ? primcount : -1, realloc_vert ? vertcount : -1);
1492       reset_counters(ctx);
1493       assert(save->prim_max);
1494    }
1495 }
1496
1497
1498 static void GLAPIENTRY
1499 _save_OBE_DrawArrays(GLenum mode, GLint start, GLsizei count)
1500 {
1501    GET_CURRENT_CONTEXT(ctx);
1502    struct gl_vertex_array_object *vao = ctx->Array.VAO;
1503    struct vbo_save_context *save = &vbo_context(ctx)->save;
1504    GLint i;
1505
1506    if (!_mesa_is_valid_prim_mode(ctx, mode)) {
1507       _mesa_compile_error(ctx, GL_INVALID_ENUM, "glDrawArrays(mode)");
1508       return;
1509    }
1510    if (count < 0) {
1511       _mesa_compile_error(ctx, GL_INVALID_VALUE, "glDrawArrays(count<0)");
1512       return;
1513    }
1514
1515    if (save->out_of_memory)
1516       return;
1517
1518    _ensure_draws_fits_in_storage(ctx, 1, count);
1519
1520    /* Make sure to process any VBO binding changes */
1521    _mesa_update_state(ctx);
1522
1523    _mesa_vao_map_arrays(ctx, vao, GL_MAP_READ_BIT);
1524
1525    vbo_save_NotifyBegin(ctx, mode, true);
1526
1527    for (i = 0; i < count; i++)
1528       _mesa_array_element(ctx, start + i);
1529    CALL_End(ctx->CurrentServerDispatch, ());
1530
1531    _mesa_vao_unmap_arrays(ctx, vao);
1532 }
1533
1534
1535 static void GLAPIENTRY
1536 _save_OBE_MultiDrawArrays(GLenum mode, const GLint *first,
1537                           const GLsizei *count, GLsizei primcount)
1538 {
1539    GET_CURRENT_CONTEXT(ctx);
1540    GLint i;
1541
1542    if (!_mesa_is_valid_prim_mode(ctx, mode)) {
1543       _mesa_compile_error(ctx, GL_INVALID_ENUM, "glMultiDrawArrays(mode)");
1544       return;
1545    }
1546
1547    if (primcount < 0) {
1548       _mesa_compile_error(ctx, GL_INVALID_VALUE,
1549                           "glMultiDrawArrays(primcount<0)");
1550       return;
1551    }
1552
1553    unsigned vertcount = 0;
1554    for (i = 0; i < primcount; i++) {
1555       if (count[i] < 0) {
1556          _mesa_compile_error(ctx, GL_INVALID_VALUE,
1557                              "glMultiDrawArrays(count[i]<0)");
1558          return;
1559       }
1560       vertcount += count[i];
1561    }
1562
1563    _ensure_draws_fits_in_storage(ctx, primcount, vertcount);
1564
1565    for (i = 0; i < primcount; i++) {
1566       if (count[i] > 0) {
1567          _save_OBE_DrawArrays(mode, first[i], count[i]);
1568       }
1569    }
1570 }
1571
1572
1573 static void
1574 array_element(struct gl_context *ctx,
1575               GLint basevertex, GLuint elt, unsigned index_size_shift)
1576 {
1577    /* Section 10.3.5 Primitive Restart:
1578     * [...]
1579     *    When one of the *BaseVertex drawing commands specified in section 10.5
1580     * is used, the primitive restart comparison occurs before the basevertex
1581     * offset is added to the array index.
1582     */
1583    /* If PrimitiveRestart is enabled and the index is the RestartIndex
1584     * then we call PrimitiveRestartNV and return.
1585     */
1586    if (ctx->Array._PrimitiveRestart[index_size_shift] &&
1587        elt == ctx->Array._RestartIndex[index_size_shift]) {
1588       CALL_PrimitiveRestartNV(ctx->CurrentServerDispatch, ());
1589       return;
1590    }
1591
1592    _mesa_array_element(ctx, basevertex + elt);
1593 }
1594
1595
1596 /* Could do better by copying the arrays and element list intact and
1597  * then emitting an indexed prim at runtime.
1598  */
1599 static void GLAPIENTRY
1600 _save_OBE_DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type,
1601                                  const GLvoid * indices, GLint basevertex)
1602 {
1603    GET_CURRENT_CONTEXT(ctx);
1604    struct vbo_save_context *save = &vbo_context(ctx)->save;
1605    struct gl_vertex_array_object *vao = ctx->Array.VAO;
1606    struct gl_buffer_object *indexbuf = vao->IndexBufferObj;
1607    GLint i;
1608
1609    if (!_mesa_is_valid_prim_mode(ctx, mode)) {
1610       _mesa_compile_error(ctx, GL_INVALID_ENUM, "glDrawElements(mode)");
1611       return;
1612    }
1613    if (count < 0) {
1614       _mesa_compile_error(ctx, GL_INVALID_VALUE, "glDrawElements(count<0)");
1615       return;
1616    }
1617    if (type != GL_UNSIGNED_BYTE &&
1618        type != GL_UNSIGNED_SHORT &&
1619        type != GL_UNSIGNED_INT) {
1620       _mesa_compile_error(ctx, GL_INVALID_VALUE, "glDrawElements(count<0)");
1621       return;
1622    }
1623
1624    if (save->out_of_memory)
1625       return;
1626
1627    _ensure_draws_fits_in_storage(ctx, 1, count);
1628
1629    /* Make sure to process any VBO binding changes */
1630    _mesa_update_state(ctx);
1631
1632    _mesa_vao_map(ctx, vao, GL_MAP_READ_BIT);
1633
1634    if (indexbuf)
1635       indices =
1636          ADD_POINTERS(indexbuf->Mappings[MAP_INTERNAL].Pointer, indices);
1637
1638    vbo_save_NotifyBegin(ctx, mode, true);
1639
1640    switch (type) {
1641    case GL_UNSIGNED_BYTE:
1642       for (i = 0; i < count; i++)
1643          array_element(ctx, basevertex, ((GLubyte *) indices)[i], 0);
1644       break;
1645    case GL_UNSIGNED_SHORT:
1646       for (i = 0; i < count; i++)
1647          array_element(ctx, basevertex, ((GLushort *) indices)[i], 1);
1648       break;
1649    case GL_UNSIGNED_INT:
1650       for (i = 0; i < count; i++)
1651          array_element(ctx, basevertex, ((GLuint *) indices)[i], 2);
1652       break;
1653    default:
1654       _mesa_error(ctx, GL_INVALID_ENUM, "glDrawElements(type)");
1655       break;
1656    }
1657
1658    CALL_End(ctx->CurrentServerDispatch, ());
1659
1660    _mesa_vao_unmap(ctx, vao);
1661 }
1662
1663 static void GLAPIENTRY
1664 _save_OBE_DrawElements(GLenum mode, GLsizei count, GLenum type,
1665                        const GLvoid * indices)
1666 {
1667    _save_OBE_DrawElementsBaseVertex(mode, count, type, indices, 0);
1668 }
1669
1670
1671 static void GLAPIENTRY
1672 _save_OBE_DrawRangeElements(GLenum mode, GLuint start, GLuint end,
1673                             GLsizei count, GLenum type,
1674                             const GLvoid * indices)
1675 {
1676    GET_CURRENT_CONTEXT(ctx);
1677    struct vbo_save_context *save = &vbo_context(ctx)->save;
1678
1679    if (!_mesa_is_valid_prim_mode(ctx, mode)) {
1680       _mesa_compile_error(ctx, GL_INVALID_ENUM, "glDrawRangeElements(mode)");
1681       return;
1682    }
1683    if (count < 0) {
1684       _mesa_compile_error(ctx, GL_INVALID_VALUE,
1685                           "glDrawRangeElements(count<0)");
1686       return;
1687    }
1688    if (type != GL_UNSIGNED_BYTE &&
1689        type != GL_UNSIGNED_SHORT &&
1690        type != GL_UNSIGNED_INT) {
1691       _mesa_compile_error(ctx, GL_INVALID_ENUM, "glDrawRangeElements(type)");
1692       return;
1693    }
1694    if (end < start) {
1695       _mesa_compile_error(ctx, GL_INVALID_VALUE,
1696                           "glDrawRangeElements(end < start)");
1697       return;
1698    }
1699
1700    if (save->out_of_memory)
1701       return;
1702
1703    _save_OBE_DrawElements(mode, count, type, indices);
1704 }
1705
1706
1707 static void GLAPIENTRY
1708 _save_OBE_MultiDrawElements(GLenum mode, const GLsizei *count, GLenum type,
1709                             const GLvoid * const *indices, GLsizei primcount)
1710 {
1711    GET_CURRENT_CONTEXT(ctx);
1712    struct _glapi_table *dispatch = ctx->CurrentServerDispatch;
1713    GLsizei i;
1714
1715    int vertcount = 0;
1716    for (i = 0; i < primcount; i++) {
1717       vertcount += count[i];
1718    }
1719    _ensure_draws_fits_in_storage(ctx, primcount, vertcount);
1720
1721    for (i = 0; i < primcount; i++) {
1722       if (count[i] > 0) {
1723          CALL_DrawElements(dispatch, (mode, count[i], type, indices[i]));
1724       }
1725    }
1726 }
1727
1728
1729 static void GLAPIENTRY
1730 _save_OBE_MultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count,
1731                                       GLenum type,
1732                                       const GLvoid * const *indices,
1733                                       GLsizei primcount,
1734                                       const GLint *basevertex)
1735 {
1736    GET_CURRENT_CONTEXT(ctx);
1737    struct _glapi_table *dispatch = ctx->CurrentServerDispatch;
1738    GLsizei i;
1739
1740    int vertcount = 0;
1741    for (i = 0; i < primcount; i++) {
1742       vertcount += count[i];
1743    }
1744    _ensure_draws_fits_in_storage(ctx, primcount, vertcount);
1745
1746    for (i = 0; i < primcount; i++) {
1747       if (count[i] > 0) {
1748          CALL_DrawElementsBaseVertex(dispatch, (mode, count[i], type,
1749                                                       indices[i],
1750                                                       basevertex[i]));
1751       }
1752    }
1753 }
1754
1755
1756 static void
1757 vtxfmt_init(struct gl_context *ctx)
1758 {
1759    struct vbo_save_context *save = &vbo_context(ctx)->save;
1760    GLvertexformat *vfmt = &save->vtxfmt;
1761
1762 #define NAME_AE(x) _ae_##x
1763 #define NAME_CALLLIST(x) _save_##x
1764 #define NAME(x) _save_##x
1765 #define NAME_ES(x) _save_##x##ARB
1766
1767 #include "vbo_init_tmp.h"
1768 }
1769
1770
1771 /**
1772  * Initialize the dispatch table with the VBO functions for display
1773  * list compilation.
1774  */
1775 void
1776 vbo_initialize_save_dispatch(const struct gl_context *ctx,
1777                              struct _glapi_table *exec)
1778 {
1779    SET_DrawArrays(exec, _save_OBE_DrawArrays);
1780    SET_MultiDrawArrays(exec, _save_OBE_MultiDrawArrays);
1781    SET_DrawElements(exec, _save_OBE_DrawElements);
1782    SET_DrawElementsBaseVertex(exec, _save_OBE_DrawElementsBaseVertex);
1783    SET_DrawRangeElements(exec, _save_OBE_DrawRangeElements);
1784    SET_MultiDrawElementsEXT(exec, _save_OBE_MultiDrawElements);
1785    SET_MultiDrawElementsBaseVertex(exec, _save_OBE_MultiDrawElementsBaseVertex);
1786    SET_Rectf(exec, _save_OBE_Rectf);
1787    SET_Rectd(exec, _save_OBE_Rectd);
1788    SET_Rectdv(exec, _save_OBE_Rectdv);
1789    SET_Rectfv(exec, _save_OBE_Rectfv);
1790    SET_Recti(exec, _save_OBE_Recti);
1791    SET_Rectiv(exec, _save_OBE_Rectiv);
1792    SET_Rects(exec, _save_OBE_Rects);
1793    SET_Rectsv(exec, _save_OBE_Rectsv);
1794
1795    /* Note: other glDraw functins aren't compiled into display lists */
1796 }
1797
1798
1799
1800 void
1801 vbo_save_SaveFlushVertices(struct gl_context *ctx)
1802 {
1803    struct vbo_save_context *save = &vbo_context(ctx)->save;
1804
1805    /* Noop when we are actually active:
1806     */
1807    if (ctx->Driver.CurrentSavePrimitive <= PRIM_MAX)
1808       return;
1809
1810    if (save->vert_count || save->prim_count)
1811       compile_vertex_list(ctx);
1812
1813    copy_to_current(ctx);
1814    reset_vertex(ctx);
1815    reset_counters(ctx);
1816    ctx->Driver.SaveNeedFlush = GL_FALSE;
1817 }
1818
1819
1820 /**
1821  * Called from glNewList when we're starting to compile a display list.
1822  */
1823 void
1824 vbo_save_NewList(struct gl_context *ctx, GLuint list, GLenum mode)
1825 {
1826    struct vbo_save_context *save = &vbo_context(ctx)->save;
1827
1828    (void) list;
1829    (void) mode;
1830
1831    if (!save->prim_store)
1832       save->prim_store = alloc_prim_store(0);
1833
1834    if (!save->vertex_store)
1835       save->vertex_store = alloc_vertex_store(ctx, 0);
1836
1837    save->buffer_ptr = vbo_save_map_vertex_store(ctx, save->vertex_store);
1838
1839    reset_vertex(ctx);
1840    reset_counters(ctx);
1841    ctx->Driver.SaveNeedFlush = GL_FALSE;
1842 }
1843
1844
1845 /**
1846  * Called from glEndList when we're finished compiling a display list.
1847  */
1848 void
1849 vbo_save_EndList(struct gl_context *ctx)
1850 {
1851    struct vbo_save_context *save = &vbo_context(ctx)->save;
1852
1853    /* EndList called inside a (saved) Begin/End pair?
1854     */
1855    if (_mesa_inside_dlist_begin_end(ctx)) {
1856       if (save->prim_count > 0) {
1857          GLint i = save->prim_count - 1;
1858          ctx->Driver.CurrentSavePrimitive = PRIM_OUTSIDE_BEGIN_END;
1859          save->prims[i].end = 0;
1860          save->prims[i].count = save->vert_count - save->prims[i].start;
1861       }
1862
1863       /* Make sure this vertex list gets replayed by the "loopback"
1864        * mechanism:
1865        */
1866       save->dangling_attr_ref = GL_TRUE;
1867       vbo_save_SaveFlushVertices(ctx);
1868
1869       /* Swap out this vertex format while outside begin/end.  Any color,
1870        * etc. received between here and the next begin will be compiled
1871        * as opcodes.
1872        */
1873       _mesa_install_save_vtxfmt(ctx, &ctx->ListState.ListVtxfmt);
1874    }
1875
1876    vbo_save_unmap_vertex_store(ctx, save->vertex_store);
1877
1878    assert(save->vertex_size == 0);
1879 }
1880
1881
1882 /**
1883  * Called from the display list code when we're about to execute a
1884  * display list.
1885  */
1886 void
1887 vbo_save_BeginCallList(struct gl_context *ctx, struct gl_display_list *dlist)
1888 {
1889    struct vbo_save_context *save = &vbo_context(ctx)->save;
1890    save->replay_flags |= dlist->Flags;
1891 }
1892
1893
1894 /**
1895  * Called from the display list code when we're finished executing a
1896  * display list.
1897  */
1898 void
1899 vbo_save_EndCallList(struct gl_context *ctx)
1900 {
1901    struct vbo_save_context *save = &vbo_context(ctx)->save;
1902
1903    if (ctx->ListState.CallDepth == 1)
1904       save->replay_flags = 0;
1905 }
1906
1907
1908 /**
1909  * Called by display list code when a display list is being deleted.
1910  */
1911 static void
1912 vbo_destroy_vertex_list(struct gl_context *ctx, void *data)
1913 {
1914    struct vbo_save_vertex_list *node = (struct vbo_save_vertex_list *) data;
1915
1916    for (gl_vertex_processing_mode vpm = VP_MODE_FF; vpm < VP_MODE_MAX; ++vpm)
1917       _mesa_reference_vao(ctx, &node->VAO[vpm], NULL);
1918
1919    if (--node->prim_store->refcount == 0) {
1920       free(node->prim_store->prims);
1921       free(node->prim_store);
1922    }
1923
1924    free(node->merged.prims);
1925
1926    _mesa_reference_buffer_object(ctx, &node->merged.ib.obj, NULL);
1927    free(node->current_data);
1928    node->current_data = NULL;
1929 }
1930
1931
1932 static void
1933 vbo_print_vertex_list(struct gl_context *ctx, void *data, FILE *f)
1934 {
1935    struct vbo_save_vertex_list *node = (struct vbo_save_vertex_list *) data;
1936    GLuint i;
1937    struct gl_buffer_object *buffer = node->VAO[0]->BufferBinding[0].BufferObj;
1938    const GLuint vertex_size = _vbo_save_get_stride(node)/sizeof(GLfloat);
1939    (void) ctx;
1940
1941    fprintf(f, "VBO-VERTEX-LIST, %u vertices, %d primitives, %d vertsize, "
1942            "buffer %p\n",
1943            node->vertex_count, node->prim_count, vertex_size,
1944            buffer);
1945
1946    for (i = 0; i < node->prim_count; i++) {
1947       struct _mesa_prim *prim = &node->prims[i];
1948       fprintf(f, "   prim %d: %s %d..%d %s %s\n",
1949              i,
1950              _mesa_lookup_prim_by_nr(prim->mode),
1951              prim->start,
1952              prim->start + prim->count,
1953              (prim->begin) ? "BEGIN" : "(wrap)",
1954              (prim->end) ? "END" : "(wrap)");
1955    }
1956 }
1957
1958
1959 /**
1960  * Called during context creation/init.
1961  */
1962 static void
1963 current_init(struct gl_context *ctx)
1964 {
1965    struct vbo_save_context *save = &vbo_context(ctx)->save;
1966    GLint i;
1967
1968    for (i = VBO_ATTRIB_POS; i <= VBO_ATTRIB_GENERIC15; i++) {
1969       const GLuint j = i - VBO_ATTRIB_POS;
1970       assert(j < VERT_ATTRIB_MAX);
1971       save->currentsz[i] = &ctx->ListState.ActiveAttribSize[j];
1972       save->current[i] = (fi_type *) ctx->ListState.CurrentAttrib[j];
1973    }
1974
1975    for (i = VBO_ATTRIB_FIRST_MATERIAL; i <= VBO_ATTRIB_LAST_MATERIAL; i++) {
1976       const GLuint j = i - VBO_ATTRIB_FIRST_MATERIAL;
1977       assert(j < MAT_ATTRIB_MAX);
1978       save->currentsz[i] = &ctx->ListState.ActiveMaterialSize[j];
1979       save->current[i] = (fi_type *) ctx->ListState.CurrentMaterial[j];
1980    }
1981 }
1982
1983
1984 /**
1985  * Initialize the display list compiler.  Called during context creation.
1986  */
1987 void
1988 vbo_save_api_init(struct vbo_save_context *save)
1989 {
1990    struct gl_context *ctx = gl_context_from_vbo_save(save);
1991
1992    save->opcode_vertex_list =
1993       _mesa_dlist_alloc_opcode(ctx,
1994                                sizeof(struct vbo_save_vertex_list),
1995                                vbo_save_playback_vertex_list,
1996                                vbo_destroy_vertex_list,
1997                                vbo_print_vertex_list);
1998
1999    vtxfmt_init(ctx);
2000    current_init(ctx);
2001    _mesa_noop_vtxfmt_init(ctx, &save->vtxfmt_noop);
2002 }