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