1 /**************************************************************************
3 Copyright 2002-2008 VMware, Inc.
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:
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
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.
26 **************************************************************************/
30 * Keith Whitwell <keithw@vmware.com>
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
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,
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.
50 * The other case where fixup is required is when a vertex attribute
51 * is introduced in the middle of a primitive. Eg:
53 * TexCoord1f() Vertex2f()
54 * TexCoord1f() Color3f() Vertex2f()
57 * If the current value of Color isn't known at compile-time, this
58 * primitive will require fixup.
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.
65 * This could be improved to fallback only when a mix of EvalCoord and
66 * Vertex commands are issued within a single primitive.
68 * The compilation process works as follows. All vertex attributes
69 * except position are copied to vbo_save_context::attrptr (see ATTR_UNION).
70 * 'attrptr' are pointers to vbo_save_context::vertex ordered according to the enabled
71 * attributes (se upgrade_vertex).
72 * When the position attribute is received, all the attributes are then
73 * copied to the vertex_store (see the end of ATTR_UNION).
74 * The vertex_store is simply an extensible float array.
75 * When the vertex list needs to be compiled (see compile_vertex_list),
76 * several transformations are performed:
77 * - some primitives are merged together (eg: two consecutive GL_TRIANGLES
78 * with 3 vertices can be merged in a single GL_TRIANGLES with 6 vertices).
79 * - an index buffer is built.
80 * - identical vertices are detected and only one is kept.
81 * At the end of this transformation, the index buffer and the vertex buffer
82 * are uploaded in vRAM in the same buffer object.
83 * This buffer object is shared between multiple display list to allow
84 * draw calls merging later.
86 * The layout of this buffer for two display lists is:
87 * V0A0|V0A1|V1A0|V1A1|P0I0|P0I1|V0A0V0A1V0A2|V1A1V1A1V1A2|...
89 * - VxAy: vertex x, attributes y
90 * - PxIy: draw x, index y
92 * To allow draw call merging, display list must use the same VAO, including
93 * the same Offset in the buffer object. To achieve this, the start values of
94 * the primitive are shifted and the indices adjusted (see offset_diff and
95 * start_offset in compile_vertex_list).
97 * Display list using the loopback code (see vbo_save_playback_vertex_list_loopback),
98 * can't be drawn with an index buffer so this transformation is disabled
103 #include "main/glheader.h"
104 #include "main/arrayobj.h"
105 #include "main/bufferobj.h"
106 #include "main/context.h"
107 #include "main/dlist.h"
108 #include "main/enums.h"
109 #include "main/eval.h"
110 #include "main/macros.h"
111 #include "main/draw_validate.h"
112 #include "main/api_arrayelt.h"
113 #include "main/vtxfmt.h"
114 #include "main/dispatch.h"
115 #include "main/state.h"
116 #include "main/varray.h"
117 #include "util/bitscan.h"
118 #include "util/u_memory.h"
119 #include "util/hash_table.h"
120 #include "util/indices/u_indices.h"
122 #include "gallium/include/pipe/p_state.h"
124 #include "vbo_noop.h"
125 #include "vbo_private.h"
132 /* An interesting VBO number/name to help with debugging */
133 #define VBO_BUF_ID 12345
135 static void GLAPIENTRY
136 _save_Materialfv(GLenum face, GLenum pname, const GLfloat *params);
138 static void GLAPIENTRY
139 _save_EvalCoord1f(GLfloat u);
141 static void GLAPIENTRY
142 _save_EvalCoord2f(GLfloat u, GLfloat v);
145 handle_out_of_memory(struct gl_context *ctx)
147 struct vbo_save_context *save = &vbo_context(ctx)->save;
148 _mesa_noop_vtxfmt_init(ctx, &save->vtxfmt);
149 save->out_of_memory = true;
153 * NOTE: Old 'parity' issue is gone, but copying can still be
154 * wrong-footed on replay.
157 copy_vertices(struct gl_context *ctx,
158 const struct vbo_save_vertex_list *node,
159 const fi_type * src_buffer)
161 struct vbo_save_context *save = &vbo_context(ctx)->save;
162 struct _mesa_prim *prim = &node->cold->prims[node->cold->prim_count - 1];
163 GLuint sz = save->vertex_size;
165 if (prim->end || !prim->count || !sz)
168 const fi_type *src = src_buffer + prim->start * sz;
169 assert(save->copied.buffer == NULL);
170 save->copied.buffer = malloc(sizeof(fi_type) * sz * prim->count);
172 unsigned r = vbo_copy_vertices(ctx, prim->mode, prim->start, &prim->count,
173 prim->begin, sz, true, save->copied.buffer, src);
175 free(save->copied.buffer);
176 save->copied.buffer = NULL;
182 static struct vbo_save_primitive_store *
183 realloc_prim_store(struct vbo_save_primitive_store *store, int prim_count)
186 store = CALLOC_STRUCT(vbo_save_primitive_store);
188 uint32_t old_size = store->size;
189 store->size = prim_count;
190 assert (old_size < store->size);
191 store->prims = realloc(store->prims, store->size * sizeof(struct _mesa_prim));
192 memset(&store->prims[old_size], 0, (store->size - old_size) * sizeof(struct _mesa_prim));
199 reset_counters(struct gl_context *ctx)
201 struct vbo_save_context *save = &vbo_context(ctx)->save;
203 save->vertex_store->used = 0;
204 save->prim_store->used = 0;
205 save->dangling_attr_ref = GL_FALSE;
209 * For a list of prims, try merging prims that can just be extensions of the
213 merge_prims(struct gl_context *ctx, struct _mesa_prim *prim_list,
217 struct _mesa_prim *prev_prim = prim_list;
219 for (i = 1; i < *prim_count; i++) {
220 struct _mesa_prim *this_prim = prim_list + i;
222 vbo_try_prim_conversion(&this_prim->mode, &this_prim->count);
224 if (vbo_merge_draws(ctx, true,
225 prev_prim->mode, this_prim->mode,
226 prev_prim->start, this_prim->start,
227 &prev_prim->count, this_prim->count,
228 prev_prim->basevertex, this_prim->basevertex,
230 this_prim->begin, this_prim->end)) {
231 /* We've found a prim that just extend the previous one. Tack it
232 * onto the previous one, and let this primitive struct get dropped.
237 /* If any previous primitives have been dropped, then we need to copy
238 * this later one into the next available slot.
241 if (prev_prim != this_prim)
242 *prev_prim = *this_prim;
245 *prim_count = prev_prim - prim_list + 1;
250 * Convert GL_LINE_LOOP primitive into GL_LINE_STRIP so that drivers
251 * don't have to worry about handling the _mesa_prim::begin/end flags.
252 * See https://bugs.freedesktop.org/show_bug.cgi?id=81174
255 convert_line_loop_to_strip(struct vbo_save_context *save,
256 struct vbo_save_vertex_list *node)
258 struct _mesa_prim *prim = &node->cold->prims[node->cold->prim_count - 1];
260 assert(prim->mode == GL_LINE_LOOP);
263 /* Copy the 0th vertex to end of the buffer and extend the
264 * vertex count by one to finish the line loop.
266 const GLuint sz = save->vertex_size;
268 const fi_type *src = save->vertex_store->buffer_in_ram + prim->start * sz;
270 fi_type *dst = save->vertex_store->buffer_in_ram + (prim->start + prim->count) * sz;
272 memcpy(dst, src, sz * sizeof(float));
275 node->cold->vertex_count++;
276 save->vertex_store->used += sz;
280 /* Drawing the second or later section of a long line loop.
281 * Skip the 0th vertex.
287 prim->mode = GL_LINE_STRIP;
291 /* Compare the present vao if it has the same setup. */
293 compare_vao(gl_vertex_processing_mode mode,
294 const struct gl_vertex_array_object *vao,
295 const struct gl_buffer_object *bo, GLintptr buffer_offset,
296 GLuint stride, GLbitfield64 vao_enabled,
297 const GLubyte size[VBO_ATTRIB_MAX],
298 const GLenum16 type[VBO_ATTRIB_MAX],
299 const GLuint offset[VBO_ATTRIB_MAX])
304 /* If the enabled arrays are not the same we are not equal. */
305 if (vao_enabled != vao->Enabled)
308 /* Check the buffer binding at 0 */
309 if (vao->BufferBinding[0].BufferObj != bo)
311 /* BufferBinding[0].Offset != buffer_offset is checked per attribute */
312 if (vao->BufferBinding[0].Stride != stride)
314 assert(vao->BufferBinding[0].InstanceDivisor == 0);
316 /* Retrieve the mapping from VBO_ATTRIB to VERT_ATTRIB space */
317 const GLubyte *const vao_to_vbo_map = _vbo_attribute_alias_map[mode];
319 /* Now check the enabled arrays */
320 GLbitfield mask = vao_enabled;
322 const int attr = u_bit_scan(&mask);
323 const unsigned char vbo_attr = vao_to_vbo_map[attr];
324 const GLenum16 tp = type[vbo_attr];
325 const GLintptr off = offset[vbo_attr] + buffer_offset;
326 const struct gl_array_attributes *attrib = &vao->VertexAttrib[attr];
327 if (attrib->RelativeOffset + vao->BufferBinding[0].Offset != off)
329 if (attrib->Format.Type != tp)
331 if (attrib->Format.Size != size[vbo_attr])
333 assert(attrib->Format.Format == GL_RGBA);
334 assert(attrib->Format.Normalized == GL_FALSE);
335 assert(attrib->Format.Integer == vbo_attrtype_to_integer_flag(tp));
336 assert(attrib->Format.Doubles == vbo_attrtype_to_double_flag(tp));
337 assert(attrib->BufferBindingIndex == 0);
344 /* Create or reuse the vao for the vertex processing mode. */
346 update_vao(struct gl_context *ctx,
347 gl_vertex_processing_mode mode,
348 struct gl_vertex_array_object **vao,
349 struct gl_buffer_object *bo, GLintptr buffer_offset,
350 GLuint stride, GLbitfield64 vbo_enabled,
351 const GLubyte size[VBO_ATTRIB_MAX],
352 const GLenum16 type[VBO_ATTRIB_MAX],
353 const GLuint offset[VBO_ATTRIB_MAX])
355 /* Compute the bitmasks of vao_enabled arrays */
356 GLbitfield vao_enabled = _vbo_get_vao_enabled_from_vbo(mode, vbo_enabled);
359 * Check if we can possibly reuse the exisiting one.
360 * In the long term we should reset them when something changes.
362 if (compare_vao(mode, *vao, bo, buffer_offset, stride,
363 vao_enabled, size, type, offset))
366 /* The initial refcount is 1 */
367 _mesa_reference_vao(ctx, vao, NULL);
368 *vao = _mesa_new_vao(ctx, ~((GLuint)0));
371 * assert(stride <= ctx->Const.MaxVertexAttribStride);
372 * MaxVertexAttribStride is not set for drivers that does not
373 * expose GL 44 or GLES 31.
376 /* Bind the buffer object at binding point 0 */
377 _mesa_bind_vertex_buffer(ctx, *vao, 0, bo, buffer_offset, stride, false,
380 /* Retrieve the mapping from VBO_ATTRIB to VERT_ATTRIB space
381 * Note that the position/generic0 aliasing is done in the VAO.
383 const GLubyte *const vao_to_vbo_map = _vbo_attribute_alias_map[mode];
384 /* Now set the enable arrays */
385 GLbitfield mask = vao_enabled;
387 const int vao_attr = u_bit_scan(&mask);
388 const GLubyte vbo_attr = vao_to_vbo_map[vao_attr];
389 assert(offset[vbo_attr] <= ctx->Const.MaxVertexAttribRelativeOffset);
391 _vbo_set_attrib_format(ctx, *vao, vao_attr, buffer_offset,
392 size[vbo_attr], type[vbo_attr], offset[vbo_attr]);
393 _mesa_vertex_attrib_binding(ctx, *vao, vao_attr, 0);
395 _mesa_enable_vertex_array_attribs(ctx, *vao, vao_enabled);
396 assert(vao_enabled == (*vao)->Enabled);
397 assert((vao_enabled & ~(*vao)->VertexAttribBufferMask) == 0);
399 /* Finalize and freeze the VAO */
400 _mesa_set_vao_immutable(ctx, *vao);
403 static void wrap_filled_vertex(struct gl_context *ctx);
405 /* Grow the vertex storage to accomodate for vertex_count new vertices */
407 grow_vertex_storage(struct gl_context *ctx, int vertex_count)
409 struct vbo_save_context *save = &vbo_context(ctx)->save;
410 assert (save->vertex_store);
412 int new_size = (save->vertex_store->used +
413 vertex_count * save->vertex_size) * sizeof(GLfloat);
415 /* Limit how much memory we allocate. */
416 if (save->prim_store->used > 0 &&
418 new_size > VBO_SAVE_BUFFER_SIZE) {
419 wrap_filled_vertex(ctx);
420 new_size = VBO_SAVE_BUFFER_SIZE;
423 if (new_size > save->vertex_store->buffer_in_ram_size) {
424 save->vertex_store->buffer_in_ram_size = new_size;
425 save->vertex_store->buffer_in_ram = realloc(save->vertex_store->buffer_in_ram,
426 save->vertex_store->buffer_in_ram_size);
427 if (save->vertex_store->buffer_in_ram == NULL)
428 handle_out_of_memory(ctx);
434 unsigned vertex_size;
435 fi_type *vertex_attributes;
438 static uint32_t _hash_vertex_key(const void *key)
440 struct vertex_key *k = (struct vertex_key*)key;
441 unsigned sz = k->vertex_size;
443 return _mesa_hash_data(k->vertex_attributes, sz * sizeof(float));
446 static bool _compare_vertex_key(const void *key1, const void *key2)
448 struct vertex_key *k1 = (struct vertex_key*)key1;
449 struct vertex_key *k2 = (struct vertex_key*)key2;
450 /* All the compared vertices are going to be drawn with the same VAO,
451 * so we can compare the attributes. */
452 assert (k1->vertex_size == k2->vertex_size);
453 return memcmp(k1->vertex_attributes,
454 k2->vertex_attributes,
455 k1->vertex_size * sizeof(float)) == 0;
458 static void _free_entry(struct hash_entry *entry)
460 free((void*)entry->key);
463 /* Add vertex to the vertex buffer and return its index. If this vertex is a duplicate
464 * of an existing vertex, return the original index instead.
467 add_vertex(struct vbo_save_context *save, struct hash_table *hash_to_index,
468 uint32_t index, fi_type *new_buffer, uint32_t *max_index)
470 /* If vertex deduplication is disabled return the original index. */
474 fi_type *vert = save->vertex_store->buffer_in_ram + save->vertex_size * index;
476 struct vertex_key *key = malloc(sizeof(struct vertex_key));
477 key->vertex_size = save->vertex_size;
478 key->vertex_attributes = vert;
480 struct hash_entry *entry = _mesa_hash_table_search(hash_to_index, key);
483 /* We found an existing vertex with the same hash, return its index. */
484 return (uintptr_t) entry->data;
486 /* This is a new vertex. Determine a new index and copy its attributes to the vertex
487 * buffer. Note that 'new_buffer' is created at each list compilation so we write vertices
488 * starting at index 0.
490 uint32_t n = _mesa_hash_table_num_entries(hash_to_index);
491 *max_index = MAX2(n, *max_index);
493 memcpy(&new_buffer[save->vertex_size * n],
495 save->vertex_size * sizeof(fi_type));
497 _mesa_hash_table_insert(hash_to_index, key, (void*)(uintptr_t)(n));
499 /* The index buffer is shared between list compilations, so add the base index to get
508 get_vertex_count(struct vbo_save_context *save)
510 if (!save->vertex_size)
512 return save->vertex_store->used / save->vertex_size;
517 * Insert the active immediate struct onto the display list currently
521 compile_vertex_list(struct gl_context *ctx)
523 struct vbo_save_context *save = &vbo_context(ctx)->save;
524 struct vbo_save_vertex_list *node;
526 /* Allocate space for this structure in the display list currently
529 node = (struct vbo_save_vertex_list *)
530 _mesa_dlist_alloc_vertex_list(ctx, !save->dangling_attr_ref && !save->no_current_update);
535 node->cold = calloc(1, sizeof(*node->cold));
537 /* Make sure the pointer is aligned to the size of a pointer */
538 assert((GLintptr) node % sizeof(void *) == 0);
540 const GLsizei stride = save->vertex_size*sizeof(GLfloat);
542 node->cold->vertex_count = get_vertex_count(save);
543 node->cold->wrap_count = save->copied.nr;
544 node->cold->prims = malloc(sizeof(struct _mesa_prim) * save->prim_store->used);
545 memcpy(node->cold->prims, save->prim_store->prims, sizeof(struct _mesa_prim) * save->prim_store->used);
546 node->cold->ib.obj = NULL;
547 node->cold->prim_count = save->prim_store->used;
549 if (save->no_current_update) {
550 node->cold->current_data = NULL;
553 GLuint current_size = save->vertex_size - save->attrsz[0];
554 node->cold->current_data = NULL;
557 node->cold->current_data = malloc(current_size * sizeof(GLfloat));
558 if (node->cold->current_data) {
559 const char *buffer = (const char *)save->vertex_store->buffer_in_ram;
560 unsigned attr_offset = save->attrsz[0] * sizeof(GLfloat);
561 unsigned vertex_offset = 0;
563 if (node->cold->vertex_count)
564 vertex_offset = (node->cold->vertex_count - 1) * stride;
566 memcpy(node->cold->current_data, buffer + vertex_offset + attr_offset,
567 current_size * sizeof(GLfloat));
569 _mesa_error(ctx, GL_OUT_OF_MEMORY, "Current value allocation");
570 handle_out_of_memory(ctx);
575 assert(save->attrsz[VBO_ATTRIB_POS] != 0 || node->cold->vertex_count == 0);
577 if (save->dangling_attr_ref)
578 ctx->ListState.Current.UseLoopback = true;
580 /* Copy duplicated vertices
582 save->copied.nr = copy_vertices(ctx, node, save->vertex_store->buffer_in_ram);
584 if (node->cold->prims[node->cold->prim_count - 1].mode == GL_LINE_LOOP) {
585 convert_line_loop_to_strip(save, node);
588 merge_prims(ctx, node->cold->prims, &node->cold->prim_count);
590 GLintptr buffer_offset = 0;
591 GLuint start_offset = 0;
593 /* Create an index buffer. */
594 node->cold->min_index = node->cold->max_index = 0;
595 if (node->cold->vertex_count == 0 || node->cold->prim_count == 0)
598 /* We won't modify node->prims, so use a const alias to avoid unintended
600 const struct _mesa_prim *original_prims = node->cold->prims;
602 int end = original_prims[node->cold->prim_count - 1].start +
603 original_prims[node->cold->prim_count - 1].count;
604 int total_vert_count = end - original_prims[0].start;
606 node->cold->min_index = node->cold->prims[0].start;
607 node->cold->max_index = end - 1;
609 /* converting primitive types may result in many more indices */
610 bool all_prims_supported = (ctx->Const.DriverSupportedPrimMask & BITFIELD_MASK(PIPE_PRIM_MAX)) == BITFIELD_MASK(PIPE_PRIM_MAX);
611 int max_index_count = total_vert_count * (all_prims_supported ? 2 : 3);
613 int size = max_index_count * sizeof(uint32_t);
614 uint32_t* indices = (uint32_t*) malloc(size);
615 void *tmp_indices = all_prims_supported ? NULL : malloc(size);
616 struct _mesa_prim *merged_prims = NULL;
619 struct hash_table *vertex_to_index = NULL;
620 fi_type *temp_vertices_buffer = NULL;
622 /* The loopback replay code doesn't use the index buffer, so we can't
623 * dedup vertices in this case.
625 if (!ctx->ListState.Current.UseLoopback) {
626 vertex_to_index = _mesa_hash_table_create(NULL, _hash_vertex_key, _compare_vertex_key);
627 temp_vertices_buffer = malloc(save->vertex_store->buffer_in_ram_size);
630 uint32_t max_index = 0;
632 int last_valid_prim = -1;
633 /* Construct indices array. */
634 for (unsigned i = 0; i < node->cold->prim_count; i++) {
635 assert(original_prims[i].basevertex == 0);
636 GLubyte mode = original_prims[i].mode;
637 bool converted_prim = false;
640 int vertex_count = original_prims[i].count;
645 /* Line strips may get converted to lines */
646 if (mode == GL_LINE_STRIP)
649 if (!(ctx->Const.DriverSupportedPrimMask & BITFIELD_BIT(mode))) {
651 u_generate_func trans_func;
652 enum pipe_prim_type pmode = (enum pipe_prim_type)mode;
653 u_index_generator(ctx->Const.DriverSupportedPrimMask,
654 pmode, original_prims[i].start, vertex_count,
656 &pmode, &index_size, &new_count,
659 trans_func(original_prims[i].start, new_count, tmp_indices);
660 vertex_count = new_count;
661 mode = (GLubyte)pmode;
662 converted_prim = true;
666 /* If 2 consecutive prims use the same mode => merge them. */
667 bool merge_prims = last_valid_prim >= 0 &&
668 mode == merged_prims[last_valid_prim].mode &&
669 mode != GL_LINE_LOOP && mode != GL_TRIANGLE_FAN &&
670 mode != GL_QUAD_STRIP && mode != GL_POLYGON &&
673 /* index generation uses uint16_t if the index count is small enough */
674 #define CAST_INDEX(BASE, SIZE, IDX) ((SIZE == 2 ? (uint32_t)(((uint16_t*)BASE)[IDX]) : ((uint32_t*)BASE)[IDX]))
675 /* To be able to merge consecutive triangle strips we need to insert
676 * a degenerate triangle.
679 mode == GL_TRIANGLE_STRIP) {
680 /* Insert a degenerate triangle */
681 assert(merged_prims[last_valid_prim].mode == GL_TRIANGLE_STRIP);
682 unsigned tri_count = merged_prims[last_valid_prim].count - 2;
684 indices[idx] = indices[idx - 1];
685 indices[idx + 1] = add_vertex(save, vertex_to_index,
686 converted_prim ? CAST_INDEX(tmp_indices, index_size, 0) : original_prims[i].start,
687 temp_vertices_buffer, &max_index);
689 merged_prims[last_valid_prim].count += 2;
692 /* Add another index to preserve winding order */
693 indices[idx++] = add_vertex(save, vertex_to_index,
694 converted_prim ? CAST_INDEX(tmp_indices, index_size, 0) : original_prims[i].start,
695 temp_vertices_buffer, &max_index);
696 merged_prims[last_valid_prim].count++;
702 /* Convert line strips to lines if it'll allow if the previous
703 * prim mode is GL_LINES (so merge_prims is true) or if the next
704 * primitive mode is GL_LINES or GL_LINE_LOOP.
706 if (original_prims[i].mode == GL_LINE_STRIP &&
708 (i < node->cold->prim_count - 1 &&
709 (original_prims[i + 1].mode == GL_LINE_STRIP ||
710 original_prims[i + 1].mode == GL_LINES)))) {
711 for (unsigned j = 0; j < vertex_count; j++) {
712 indices[idx++] = add_vertex(save, vertex_to_index,
713 converted_prim ? CAST_INDEX(tmp_indices, index_size, j) : original_prims[i].start + j,
714 temp_vertices_buffer, &max_index);
715 /* Repeat all but the first/last indices. */
716 if (j && j != vertex_count - 1) {
717 indices[idx++] = add_vertex(save, vertex_to_index,
718 converted_prim ? CAST_INDEX(tmp_indices, index_size, j) : original_prims[i].start + j,
719 temp_vertices_buffer, &max_index);
723 /* We didn't convert to LINES, so restore the original mode */
725 mode = original_prims[i].mode;
727 for (unsigned j = 0; j < vertex_count; j++) {
728 indices[idx++] = add_vertex(save, vertex_to_index,
729 converted_prim ? CAST_INDEX(tmp_indices, index_size, j) : original_prims[i].start + j,
730 temp_vertices_buffer, &max_index);
735 /* Update vertex count. */
736 merged_prims[last_valid_prim].count += idx - start;
738 /* Keep this primitive */
739 last_valid_prim += 1;
740 assert(last_valid_prim <= i);
741 merged_prims = realloc(merged_prims, (1 + last_valid_prim) * sizeof(struct _mesa_prim));
742 merged_prims[last_valid_prim] = original_prims[i];
743 merged_prims[last_valid_prim].start = start;
744 merged_prims[last_valid_prim].count = idx - start;
746 merged_prims[last_valid_prim].mode = mode;
749 assert(idx > 0 && idx <= max_index_count);
751 unsigned merged_prim_count = last_valid_prim + 1;
752 node->cold->ib.ptr = NULL;
753 node->cold->ib.count = idx;
754 node->cold->ib.index_size_shift = (GL_UNSIGNED_INT - GL_UNSIGNED_BYTE) >> 1;
756 /* How many bytes do we need to store the indices and the vertices */
757 total_vert_count = vertex_to_index ? (max_index + 1) : idx;
758 unsigned total_bytes_needed = idx * sizeof(uint32_t) +
759 total_vert_count * save->vertex_size * sizeof(fi_type);
761 const GLintptr old_offset = save->VAO[0] ?
762 save->VAO[0]->BufferBinding[0].Offset + save->VAO[0]->VertexAttrib[VERT_ATTRIB_POS].RelativeOffset : 0;
763 if (old_offset != save->current_bo_bytes_used && stride > 0) {
764 GLintptr offset_diff = save->current_bo_bytes_used - old_offset;
765 while (offset_diff > 0 &&
766 save->current_bo_bytes_used < save->current_bo->Size &&
767 offset_diff % stride != 0) {
768 save->current_bo_bytes_used++;
769 offset_diff = save->current_bo_bytes_used - old_offset;
772 buffer_offset = save->current_bo_bytes_used;
774 /* Can we reuse the previous bo or should we allocate a new one? */
775 int available_bytes = save->current_bo ? save->current_bo->Size - save->current_bo_bytes_used : 0;
776 if (total_bytes_needed > available_bytes) {
777 if (save->current_bo)
778 _mesa_reference_buffer_object(ctx, &save->current_bo, NULL);
779 save->current_bo = ctx->Driver.NewBufferObject(ctx, VBO_BUF_ID + 1);
780 bool success = ctx->Driver.BufferData(ctx,
781 GL_ELEMENT_ARRAY_BUFFER_ARB,
782 MAX2(total_bytes_needed, VBO_SAVE_BUFFER_SIZE),
784 GL_STATIC_DRAW_ARB, GL_MAP_WRITE_BIT |
785 MESA_GALLIUM_VERTEX_STATE_STORAGE,
788 _mesa_reference_buffer_object(ctx, &save->current_bo, NULL);
789 _mesa_error(ctx, GL_OUT_OF_MEMORY, "IB allocation");
790 handle_out_of_memory(ctx);
792 save->current_bo_bytes_used = 0;
793 available_bytes = save->current_bo->Size;
797 assert(old_offset <= buffer_offset);
798 const GLintptr offset_diff = buffer_offset - old_offset;
799 if (offset_diff > 0 && stride > 0 && offset_diff % stride == 0) {
800 /* The vertex size is an exact multiple of the buffer offset.
801 * This means that we can use zero-based vertex attribute pointers
802 * and specify the start of the primitive with the _mesa_prim::start
803 * field. This results in issuing several draw calls with identical
804 * vertex attribute information. This can result in fewer state
805 * changes in drivers. In particular, the Gallium CSO module will
806 * filter out redundant vertex buffer changes.
808 /* We cannot immediately update the primitives as some methods below
809 * still need the uncorrected start vertices
811 start_offset = offset_diff/stride;
812 assert(old_offset == buffer_offset - offset_diff);
813 buffer_offset = old_offset;
816 /* Correct the primitive starts, we can only do this here as copy_vertices
817 * and convert_line_loop_to_strip above consume the uncorrected starts.
818 * On the other hand the _vbo_loopback_vertex_list call below needs the
819 * primitives to be corrected already.
821 for (unsigned i = 0; i < node->cold->prim_count; i++) {
822 node->cold->prims[i].start += start_offset;
824 /* start_offset shifts vertices (so v[0] becomes v[start_offset]), so we have
825 * to apply this transformation to all indices and max_index.
827 for (unsigned i = 0; i < idx; i++)
828 indices[i] += start_offset;
829 max_index += start_offset;
832 _mesa_reference_buffer_object(ctx, &node->cold->ib.obj, save->current_bo);
834 /* Upload the vertices first (see buffer_offset) */
835 ctx->Driver.BufferSubData(ctx,
836 save->current_bo_bytes_used,
837 total_vert_count * save->vertex_size * sizeof(fi_type),
838 vertex_to_index ? temp_vertices_buffer : save->vertex_store->buffer_in_ram,
840 save->current_bo_bytes_used += total_vert_count * save->vertex_size * sizeof(fi_type);
842 if (vertex_to_index) {
843 _mesa_hash_table_destroy(vertex_to_index, _free_entry);
844 free(temp_vertices_buffer);
847 /* Since we're append the indices to an existing buffer, we need to adjust the start value of each
848 * primitive (not the indices themselves). */
849 save->current_bo_bytes_used += align(save->current_bo_bytes_used, 4) - save->current_bo_bytes_used;
850 int indices_offset = save->current_bo_bytes_used / 4;
851 for (int i = 0; i < merged_prim_count; i++) {
852 merged_prims[i].start += indices_offset;
855 /* Then upload the indices. */
856 if (node->cold->ib.obj) {
857 ctx->Driver.BufferSubData(ctx,
858 save->current_bo_bytes_used,
859 idx * sizeof(uint32_t),
862 save->current_bo_bytes_used += idx * sizeof(uint32_t);
864 node->cold->vertex_count = 0;
865 node->cold->prim_count = 0;
868 /* Prepare for DrawGallium */
869 memset(&node->cold->info, 0, sizeof(struct pipe_draw_info));
870 /* The other info fields will be updated in vbo_save_playback_vertex_list */
871 node->cold->info.index_size = 4;
872 node->cold->info.instance_count = 1;
873 node->cold->info.index.gl_bo = node->cold->ib.obj;
874 if (merged_prim_count == 1) {
875 node->cold->info.mode = merged_prims[0].mode;
876 node->start_count.start = merged_prims[0].start;
877 node->start_count.count = merged_prims[0].count;
878 node->start_count.index_bias = 0;
881 node->modes = malloc(merged_prim_count * sizeof(unsigned char));
882 node->start_counts = malloc(merged_prim_count * sizeof(struct pipe_draw_start_count_bias));
883 for (unsigned i = 0; i < merged_prim_count; i++) {
884 node->start_counts[i].start = merged_prims[i].start;
885 node->start_counts[i].count = merged_prims[i].count;
886 node->start_counts[i].index_bias = 0;
887 node->modes[i] = merged_prims[i].mode;
890 node->num_draws = merged_prim_count;
891 if (node->num_draws > 1) {
892 bool same_mode = true;
893 for (unsigned i = 1; i < node->num_draws && same_mode; i++) {
894 same_mode = node->modes[i] == node->modes[0];
897 /* All primitives use the same mode, so we can simplify a bit */
898 node->cold->info.mode = node->modes[0];
909 node->draw_begins = node->cold->prims[0].begin;
911 if (!save->current_bo) {
912 save->current_bo = ctx->Driver.NewBufferObject(ctx, VBO_BUF_ID + 1);
913 bool success = ctx->Driver.BufferData(ctx,
914 GL_ELEMENT_ARRAY_BUFFER_ARB,
915 VBO_SAVE_BUFFER_SIZE,
917 GL_STATIC_DRAW_ARB, GL_MAP_WRITE_BIT |
918 MESA_GALLIUM_VERTEX_STATE_STORAGE,
921 handle_out_of_memory(ctx);
924 GLuint offsets[VBO_ATTRIB_MAX];
925 for (unsigned i = 0, offset = 0; i < VBO_ATTRIB_MAX; ++i) {
927 offset += save->attrsz[i] * sizeof(GLfloat);
929 /* Create a pair of VAOs for the possible VERTEX_PROCESSING_MODEs
930 * Note that this may reuse the previous one of possible.
932 for (gl_vertex_processing_mode vpm = VP_MODE_FF; vpm < VP_MODE_MAX; ++vpm) {
933 /* create or reuse the vao */
934 update_vao(ctx, vpm, &save->VAO[vpm],
935 save->current_bo, buffer_offset, stride,
936 save->enabled, save->attrsz, save->attrtype, offsets);
937 /* Reference the vao in the dlist */
938 node->cold->VAO[vpm] = NULL;
939 _mesa_reference_vao(ctx, &node->cold->VAO[vpm], save->VAO[vpm]);
942 /* Prepare for DrawGalliumVertexState */
943 if (node->num_draws && ctx->Driver.DrawGalliumVertexState) {
944 for (unsigned i = 0; i < VP_MODE_MAX; i++) {
945 uint32_t enabled_attribs = _vbo_get_vao_filter(i) &
946 node->cold->VAO[i]->_EnabledWithMapMode;
949 ctx->Driver.CreateGalliumVertexState(ctx, node->cold->VAO[i],
952 node->private_refcount[i] = 0;
953 node->enabled_attribs[i] = enabled_attribs;
957 node->mode = node->cold->info.mode;
958 assert(node->cold->info.index_size == 4);
961 /* Deal with GL_COMPILE_AND_EXECUTE:
963 if (ctx->ExecuteFlag) {
964 struct _glapi_table *dispatch = GET_DISPATCH();
966 _glapi_set_dispatch(ctx->Exec);
968 /* _vbo_loopback_vertex_list doesn't use the index buffer, so we have to
969 * use buffer_in_ram instead of current_bo which contains all vertices instead
970 * of the deduplicated vertices only in the !UseLoopback case.
972 * The problem is that the VAO offset is based on current_bo's layout,
973 * so we have to use a temp value.
975 struct gl_vertex_array_object *vao = node->cold->VAO[VP_MODE_SHADER];
976 GLintptr original = vao->BufferBinding[0].Offset;
977 if (!ctx->ListState.Current.UseLoopback) {
978 GLintptr new_offset = 0;
979 /* 'start_offset' has been added to all primitives 'start', so undo it here. */
980 new_offset -= start_offset * stride;
981 vao->BufferBinding[0].Offset = new_offset;
983 _vbo_loopback_vertex_list(ctx, node, save->vertex_store->buffer_in_ram);
984 vao->BufferBinding[0].Offset = original;
986 _glapi_set_dispatch(dispatch);
989 /* Reset our structures for the next run of vertices:
996 * This is called when we fill a vertex buffer before we hit a glEnd().
998 * TODO -- If no new vertices have been stored, don't bother saving it.
1001 wrap_buffers(struct gl_context *ctx)
1003 struct vbo_save_context *save = &vbo_context(ctx)->save;
1004 GLint i = save->prim_store->used - 1;
1007 assert(i < (GLint) save->prim_store->size);
1010 /* Close off in-progress primitive.
1012 save->prim_store->prims[i].count = (get_vertex_count(save) - save->prim_store->prims[i].start);
1013 mode = save->prim_store->prims[i].mode;
1015 /* store the copied vertices, and allocate a new list.
1017 compile_vertex_list(ctx);
1019 /* Restart interrupted primitive
1021 save->prim_store->prims[0].mode = mode;
1022 save->prim_store->prims[0].begin = 0;
1023 save->prim_store->prims[0].end = 0;
1024 save->prim_store->prims[0].start = 0;
1025 save->prim_store->prims[0].count = 0;
1026 save->prim_store->used = 1;
1031 * Called only when buffers are wrapped as the result of filling the
1032 * vertex_store struct.
1035 wrap_filled_vertex(struct gl_context *ctx)
1037 struct vbo_save_context *save = &vbo_context(ctx)->save;
1038 unsigned numComponents;
1040 /* Emit a glEnd to close off the last vertex list.
1044 assert(save->vertex_store->used == 0 && save->vertex_store->used == 0);
1046 /* Copy stored stored vertices to start of new list.
1048 numComponents = save->copied.nr * save->vertex_size;
1050 fi_type *buffer_ptr = save->vertex_store->buffer_in_ram;
1051 if (numComponents) {
1052 assert(save->copied.buffer);
1054 save->copied.buffer,
1055 numComponents * sizeof(fi_type));
1056 free(save->copied.buffer);
1057 save->copied.buffer = NULL;
1059 save->vertex_store->used = numComponents;
1064 copy_to_current(struct gl_context *ctx)
1066 struct vbo_save_context *save = &vbo_context(ctx)->save;
1067 GLbitfield64 enabled = save->enabled & (~BITFIELD64_BIT(VBO_ATTRIB_POS));
1070 const int i = u_bit_scan64(&enabled);
1071 assert(save->attrsz[i]);
1073 if (save->attrtype[i] == GL_DOUBLE ||
1074 save->attrtype[i] == GL_UNSIGNED_INT64_ARB)
1075 memcpy(save->current[i], save->attrptr[i], save->attrsz[i] * sizeof(GLfloat));
1077 COPY_CLEAN_4V_TYPE_AS_UNION(save->current[i], save->attrsz[i],
1078 save->attrptr[i], save->attrtype[i]);
1084 copy_from_current(struct gl_context *ctx)
1086 struct vbo_save_context *save = &vbo_context(ctx)->save;
1087 GLbitfield64 enabled = save->enabled & (~BITFIELD64_BIT(VBO_ATTRIB_POS));
1090 const int i = u_bit_scan64(&enabled);
1092 switch (save->attrsz[i]) {
1094 save->attrptr[i][3] = save->current[i][3];
1097 save->attrptr[i][2] = save->current[i][2];
1100 save->attrptr[i][1] = save->current[i][1];
1103 save->attrptr[i][0] = save->current[i][0];
1106 unreachable("Unexpected vertex attribute size");
1113 * Called when we increase the size of a vertex attribute. For example,
1114 * if we've seen one or more glTexCoord2f() calls and now we get a
1115 * glTexCoord3f() call.
1116 * Flush existing data, set new attrib size, replay copied vertices.
1119 upgrade_vertex(struct gl_context *ctx, GLuint attr, GLuint newsz)
1121 struct vbo_save_context *save = &vbo_context(ctx)->save;
1126 /* Store the current run of vertices, and emit a GL_END. Emit a
1127 * BEGIN in the new buffer.
1129 if (save->vertex_store->used)
1132 assert(save->copied.nr == 0);
1134 /* Do a COPY_TO_CURRENT to ensure back-copying works for the case
1135 * when the attribute already exists in the vertex and is having
1136 * its size increased.
1138 copy_to_current(ctx);
1142 oldsz = save->attrsz[attr];
1143 save->attrsz[attr] = newsz;
1144 save->enabled |= BITFIELD64_BIT(attr);
1146 save->vertex_size += newsz - oldsz;
1148 /* Recalculate all the attrptr[] values:
1151 for (i = 0; i < VBO_ATTRIB_MAX; i++) {
1152 if (save->attrsz[i]) {
1153 save->attrptr[i] = tmp;
1154 tmp += save->attrsz[i];
1157 save->attrptr[i] = NULL; /* will not be dereferenced. */
1161 /* Copy from current to repopulate the vertex with correct values.
1163 copy_from_current(ctx);
1165 /* Replay stored vertices to translate them to new format here.
1167 * If there are copied vertices and the new (upgraded) attribute
1168 * has not been defined before, this list is somewhat degenerate,
1169 * and will need fixup at runtime.
1171 if (save->copied.nr) {
1172 assert(save->copied.buffer);
1173 const fi_type *data = save->copied.buffer;
1174 grow_vertex_storage(ctx, save->copied.nr);
1175 fi_type *dest = save->vertex_store->buffer_in_ram;
1177 /* Need to note this and fix up at runtime (or loopback):
1179 if (attr != VBO_ATTRIB_POS && save->currentsz[attr][0] == 0) {
1181 save->dangling_attr_ref = GL_TRUE;
1184 for (i = 0; i < save->copied.nr; i++) {
1185 GLbitfield64 enabled = save->enabled;
1187 const int j = u_bit_scan64(&enabled);
1188 assert(save->attrsz[j]);
1191 const fi_type *src = oldsz ? data : save->current[attr];
1192 int copy = oldsz ? oldsz : newsz;
1193 for (k = 0; k < copy; k++)
1195 for (; k < newsz; k++) {
1196 switch (save->attrtype[j]) {
1198 dest[k] = FLOAT_AS_UNION(k == 3);
1201 dest[k] = INT_AS_UNION(k == 3);
1203 case GL_UNSIGNED_INT:
1204 dest[k] = UINT_AS_UNION(k == 3);
1207 dest[k] = FLOAT_AS_UNION(k == 3);
1208 assert(!"Unexpected type in upgrade_vertex");
1215 GLint sz = save->attrsz[j];
1216 for (int k = 0; k < sz; k++)
1224 save->vertex_store->used += save->vertex_size * save->copied.nr;
1225 free(save->copied.buffer);
1226 save->copied.buffer = NULL;
1232 * This is called when the size of a vertex attribute changes.
1233 * For example, after seeing one or more glTexCoord2f() calls we
1234 * get a glTexCoord4f() or glTexCoord1f() call.
1237 fixup_vertex(struct gl_context *ctx, GLuint attr,
1238 GLuint sz, GLenum newType)
1240 struct vbo_save_context *save = &vbo_context(ctx)->save;
1242 if (sz > save->attrsz[attr] ||
1243 newType != save->attrtype[attr]) {
1244 /* New size is larger. Need to flush existing vertices and get
1245 * an enlarged vertex format.
1247 upgrade_vertex(ctx, attr, sz);
1249 else if (sz < save->active_sz[attr]) {
1251 const fi_type *id = vbo_get_default_vals_as_union(save->attrtype[attr]);
1253 /* New size is equal or smaller - just need to fill in some
1256 for (i = sz; i <= save->attrsz[attr]; i++)
1257 save->attrptr[attr][i - 1] = id[i - 1];
1260 save->active_sz[attr] = sz;
1262 grow_vertex_storage(ctx, 1);
1267 * Reset the current size of all vertex attributes to the default
1268 * value of 0. This signals that we haven't yet seen any per-vertex
1269 * commands such as glNormal3f() or glTexCoord2f().
1272 reset_vertex(struct gl_context *ctx)
1274 struct vbo_save_context *save = &vbo_context(ctx)->save;
1276 while (save->enabled) {
1277 const int i = u_bit_scan64(&save->enabled);
1278 assert(save->attrsz[i]);
1279 save->attrsz[i] = 0;
1280 save->active_sz[i] = 0;
1283 save->vertex_size = 0;
1288 * If index=0, does glVertexAttrib*() alias glVertex() to emit a vertex?
1289 * It depends on a few things, including whether we're inside or outside
1293 is_vertex_position(const struct gl_context *ctx, GLuint index)
1295 return (index == 0 &&
1296 _mesa_attr_zero_aliases_vertex(ctx) &&
1297 _mesa_inside_dlist_begin_end(ctx));
1302 #define ERROR(err) _mesa_compile_error(ctx, err, __func__);
1305 /* Only one size for each attribute may be active at once. Eg. if
1306 * Color3f is installed/active, then Color4f may not be, even if the
1307 * vertex actually contains 4 color coordinates. This is because the
1308 * 3f version won't otherwise set color[3] to 1.0 -- this is the job
1309 * of the chooser function when switching between Color4f and Color3f.
1311 #define ATTR_UNION(A, N, T, C, V0, V1, V2, V3) \
1313 struct vbo_save_context *save = &vbo_context(ctx)->save; \
1314 int sz = (sizeof(C) / sizeof(GLfloat)); \
1316 if (save->active_sz[A] != N) \
1317 fixup_vertex(ctx, A, N * sz, T); \
1320 C *dest = (C *)save->attrptr[A]; \
1321 if (N>0) dest[0] = V0; \
1322 if (N>1) dest[1] = V1; \
1323 if (N>2) dest[2] = V2; \
1324 if (N>3) dest[3] = V3; \
1325 save->attrtype[A] = T; \
1328 if ((A) == VBO_ATTRIB_POS) { \
1329 fi_type *buffer_ptr = save->vertex_store->buffer_in_ram + \
1330 save->vertex_store->used; \
1332 for (int i = 0; i < save->vertex_size; i++) \
1333 buffer_ptr[i] = save->vertex[i]; \
1335 save->vertex_store->used += save->vertex_size; \
1336 unsigned used_next = (save->vertex_store->used + \
1337 save->vertex_size) * sizeof(float); \
1338 if (used_next > save->vertex_store->buffer_in_ram_size) { \
1339 grow_vertex_storage(ctx, get_vertex_count(save)); \
1340 assert(used_next <= \
1341 save->vertex_store->buffer_in_ram_size); \
1346 #define TAG(x) _save_##x
1348 #include "vbo_attrib_tmp.h"
1351 #define MAT( ATTR, N, face, params ) \
1353 if (face != GL_BACK) \
1354 MAT_ATTR( ATTR, N, params ); /* front */ \
1355 if (face != GL_FRONT) \
1356 MAT_ATTR( ATTR + 1, N, params ); /* back */ \
1361 * Save a glMaterial call found between glBegin/End.
1362 * glMaterial calls outside Begin/End are handled in dlist.c.
1364 static void GLAPIENTRY
1365 _save_Materialfv(GLenum face, GLenum pname, const GLfloat *params)
1367 GET_CURRENT_CONTEXT(ctx);
1369 if (face != GL_FRONT && face != GL_BACK && face != GL_FRONT_AND_BACK) {
1370 _mesa_compile_error(ctx, GL_INVALID_ENUM, "glMaterial(face)");
1376 MAT(VBO_ATTRIB_MAT_FRONT_EMISSION, 4, face, params);
1379 MAT(VBO_ATTRIB_MAT_FRONT_AMBIENT, 4, face, params);
1382 MAT(VBO_ATTRIB_MAT_FRONT_DIFFUSE, 4, face, params);
1385 MAT(VBO_ATTRIB_MAT_FRONT_SPECULAR, 4, face, params);
1388 if (*params < 0 || *params > ctx->Const.MaxShininess) {
1389 _mesa_compile_error(ctx, GL_INVALID_VALUE, "glMaterial(shininess)");
1392 MAT(VBO_ATTRIB_MAT_FRONT_SHININESS, 1, face, params);
1395 case GL_COLOR_INDEXES:
1396 MAT(VBO_ATTRIB_MAT_FRONT_INDEXES, 3, face, params);
1398 case GL_AMBIENT_AND_DIFFUSE:
1399 MAT(VBO_ATTRIB_MAT_FRONT_AMBIENT, 4, face, params);
1400 MAT(VBO_ATTRIB_MAT_FRONT_DIFFUSE, 4, face, params);
1403 _mesa_compile_error(ctx, GL_INVALID_ENUM, "glMaterial(pname)");
1409 /* Cope with EvalCoord/CallList called within a begin/end object:
1410 * -- Flush current buffer
1411 * -- Fallback to opcodes for the rest of the begin/end object.
1414 dlist_fallback(struct gl_context *ctx)
1416 struct vbo_save_context *save = &vbo_context(ctx)->save;
1418 if (save->vertex_store->used || save->prim_store->used) {
1419 if (save->prim_store->used > 0 && save->vertex_store->used > 0) {
1420 assert(save->vertex_size);
1421 /* Close off in-progress primitive. */
1422 GLint i = save->prim_store->used - 1;
1423 save->prim_store->prims[i].count =
1424 get_vertex_count(save) -
1425 save->prim_store->prims[i].start;
1428 /* Need to replay this display list with loopback,
1429 * unfortunately, otherwise this primitive won't be handled
1432 save->dangling_attr_ref = GL_TRUE;
1434 compile_vertex_list(ctx);
1437 copy_to_current(ctx);
1439 if (save->out_of_memory) {
1440 _mesa_install_save_vtxfmt(ctx, &save->vtxfmt);
1443 _mesa_install_save_vtxfmt(ctx, &ctx->ListState.ListVtxfmt);
1445 ctx->Driver.SaveNeedFlush = GL_FALSE;
1449 static void GLAPIENTRY
1450 _save_EvalCoord1f(GLfloat u)
1452 GET_CURRENT_CONTEXT(ctx);
1453 dlist_fallback(ctx);
1454 CALL_EvalCoord1f(ctx->Save, (u));
1457 static void GLAPIENTRY
1458 _save_EvalCoord1fv(const GLfloat * v)
1460 GET_CURRENT_CONTEXT(ctx);
1461 dlist_fallback(ctx);
1462 CALL_EvalCoord1fv(ctx->Save, (v));
1465 static void GLAPIENTRY
1466 _save_EvalCoord2f(GLfloat u, GLfloat v)
1468 GET_CURRENT_CONTEXT(ctx);
1469 dlist_fallback(ctx);
1470 CALL_EvalCoord2f(ctx->Save, (u, v));
1473 static void GLAPIENTRY
1474 _save_EvalCoord2fv(const GLfloat * v)
1476 GET_CURRENT_CONTEXT(ctx);
1477 dlist_fallback(ctx);
1478 CALL_EvalCoord2fv(ctx->Save, (v));
1481 static void GLAPIENTRY
1482 _save_EvalPoint1(GLint i)
1484 GET_CURRENT_CONTEXT(ctx);
1485 dlist_fallback(ctx);
1486 CALL_EvalPoint1(ctx->Save, (i));
1489 static void GLAPIENTRY
1490 _save_EvalPoint2(GLint i, GLint j)
1492 GET_CURRENT_CONTEXT(ctx);
1493 dlist_fallback(ctx);
1494 CALL_EvalPoint2(ctx->Save, (i, j));
1497 static void GLAPIENTRY
1498 _save_CallList(GLuint l)
1500 GET_CURRENT_CONTEXT(ctx);
1501 dlist_fallback(ctx);
1502 CALL_CallList(ctx->Save, (l));
1505 static void GLAPIENTRY
1506 _save_CallLists(GLsizei n, GLenum type, const GLvoid * v)
1508 GET_CURRENT_CONTEXT(ctx);
1509 dlist_fallback(ctx);
1510 CALL_CallLists(ctx->Save, (n, type, v));
1516 * Called when a glBegin is getting compiled into a display list.
1517 * Updating of ctx->Driver.CurrentSavePrimitive is already taken care of.
1520 vbo_save_NotifyBegin(struct gl_context *ctx, GLenum mode,
1521 bool no_current_update)
1523 struct vbo_save_context *save = &vbo_context(ctx)->save;
1524 const GLuint i = save->prim_store->used++;
1526 ctx->Driver.CurrentSavePrimitive = mode;
1528 if (!save->prim_store || i >= save->prim_store->size) {
1529 save->prim_store = realloc_prim_store(save->prim_store, i * 2);
1531 save->prim_store->prims[i].mode = mode & VBO_SAVE_PRIM_MODE_MASK;
1532 save->prim_store->prims[i].begin = 1;
1533 save->prim_store->prims[i].end = 0;
1534 save->prim_store->prims[i].start = get_vertex_count(save);
1535 save->prim_store->prims[i].count = 0;
1537 save->no_current_update = no_current_update;
1539 _mesa_install_save_vtxfmt(ctx, &save->vtxfmt);
1541 /* We need to call vbo_save_SaveFlushVertices() if there's state change */
1542 ctx->Driver.SaveNeedFlush = GL_TRUE;
1546 static void GLAPIENTRY
1549 GET_CURRENT_CONTEXT(ctx);
1550 struct vbo_save_context *save = &vbo_context(ctx)->save;
1551 const GLint i = save->prim_store->used - 1;
1553 ctx->Driver.CurrentSavePrimitive = PRIM_OUTSIDE_BEGIN_END;
1554 save->prim_store->prims[i].end = 1;
1555 save->prim_store->prims[i].count = (get_vertex_count(save) - save->prim_store->prims[i].start);
1557 /* Swap out this vertex format while outside begin/end. Any color,
1558 * etc. received between here and the next begin will be compiled
1561 if (save->out_of_memory) {
1562 _mesa_install_save_vtxfmt(ctx, &save->vtxfmt);
1565 _mesa_install_save_vtxfmt(ctx, &ctx->ListState.ListVtxfmt);
1570 static void GLAPIENTRY
1571 _save_Begin(GLenum mode)
1573 GET_CURRENT_CONTEXT(ctx);
1575 _mesa_compile_error(ctx, GL_INVALID_OPERATION, "Recursive glBegin");
1579 static void GLAPIENTRY
1580 _save_PrimitiveRestartNV(void)
1582 GET_CURRENT_CONTEXT(ctx);
1583 struct vbo_save_context *save = &vbo_context(ctx)->save;
1585 if (save->prim_store->used == 0) {
1586 /* We're not inside a glBegin/End pair, so calling glPrimitiverRestartNV
1589 _mesa_compile_error(ctx, GL_INVALID_OPERATION,
1590 "glPrimitiveRestartNV called outside glBegin/End");
1592 /* get current primitive mode */
1593 GLenum curPrim = save->prim_store->prims[save->prim_store->used - 1].mode;
1594 bool no_current_update = save->no_current_update;
1596 /* restart primitive */
1597 CALL_End(ctx->CurrentServerDispatch, ());
1598 vbo_save_NotifyBegin(ctx, curPrim, no_current_update);
1603 /* Unlike the functions above, these are to be hooked into the vtxfmt
1604 * maintained in ctx->ListState, active when the list is known or
1605 * suspected to be outside any begin/end primitive.
1606 * Note: OBE = Outside Begin/End
1608 static void GLAPIENTRY
1609 _save_OBE_Rectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
1611 GET_CURRENT_CONTEXT(ctx);
1612 struct _glapi_table *dispatch = ctx->CurrentServerDispatch;
1614 vbo_save_NotifyBegin(ctx, GL_QUADS, false);
1615 CALL_Vertex2f(dispatch, (x1, y1));
1616 CALL_Vertex2f(dispatch, (x2, y1));
1617 CALL_Vertex2f(dispatch, (x2, y2));
1618 CALL_Vertex2f(dispatch, (x1, y2));
1619 CALL_End(dispatch, ());
1623 static void GLAPIENTRY
1624 _save_OBE_Rectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
1626 _save_OBE_Rectf((GLfloat) x1, (GLfloat) y1, (GLfloat) x2, (GLfloat) y2);
1629 static void GLAPIENTRY
1630 _save_OBE_Rectdv(const GLdouble *v1, const GLdouble *v2)
1632 _save_OBE_Rectf((GLfloat) v1[0], (GLfloat) v1[1], (GLfloat) v2[0], (GLfloat) v2[1]);
1635 static void GLAPIENTRY
1636 _save_OBE_Rectfv(const GLfloat *v1, const GLfloat *v2)
1638 _save_OBE_Rectf(v1[0], v1[1], v2[0], v2[1]);
1641 static void GLAPIENTRY
1642 _save_OBE_Recti(GLint x1, GLint y1, GLint x2, GLint y2)
1644 _save_OBE_Rectf((GLfloat) x1, (GLfloat) y1, (GLfloat) x2, (GLfloat) y2);
1647 static void GLAPIENTRY
1648 _save_OBE_Rectiv(const GLint *v1, const GLint *v2)
1650 _save_OBE_Rectf((GLfloat) v1[0], (GLfloat) v1[1], (GLfloat) v2[0], (GLfloat) v2[1]);
1653 static void GLAPIENTRY
1654 _save_OBE_Rects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
1656 _save_OBE_Rectf((GLfloat) x1, (GLfloat) y1, (GLfloat) x2, (GLfloat) y2);
1659 static void GLAPIENTRY
1660 _save_OBE_Rectsv(const GLshort *v1, const GLshort *v2)
1662 _save_OBE_Rectf((GLfloat) v1[0], (GLfloat) v1[1], (GLfloat) v2[0], (GLfloat) v2[1]);
1665 static void GLAPIENTRY
1666 _save_OBE_DrawArrays(GLenum mode, GLint start, GLsizei count)
1668 GET_CURRENT_CONTEXT(ctx);
1669 struct gl_vertex_array_object *vao = ctx->Array.VAO;
1670 struct vbo_save_context *save = &vbo_context(ctx)->save;
1673 if (!_mesa_is_valid_prim_mode(ctx, mode)) {
1674 _mesa_compile_error(ctx, GL_INVALID_ENUM, "glDrawArrays(mode)");
1678 _mesa_compile_error(ctx, GL_INVALID_VALUE, "glDrawArrays(count<0)");
1682 if (save->out_of_memory)
1685 grow_vertex_storage(ctx, count);
1687 /* Make sure to process any VBO binding changes */
1688 _mesa_update_state(ctx);
1690 _mesa_vao_map_arrays(ctx, vao, GL_MAP_READ_BIT);
1692 vbo_save_NotifyBegin(ctx, mode, true);
1694 for (i = 0; i < count; i++)
1695 _mesa_array_element(ctx, start + i);
1696 CALL_End(ctx->CurrentServerDispatch, ());
1698 _mesa_vao_unmap_arrays(ctx, vao);
1702 static void GLAPIENTRY
1703 _save_OBE_MultiDrawArrays(GLenum mode, const GLint *first,
1704 const GLsizei *count, GLsizei primcount)
1706 GET_CURRENT_CONTEXT(ctx);
1709 if (!_mesa_is_valid_prim_mode(ctx, mode)) {
1710 _mesa_compile_error(ctx, GL_INVALID_ENUM, "glMultiDrawArrays(mode)");
1714 if (primcount < 0) {
1715 _mesa_compile_error(ctx, GL_INVALID_VALUE,
1716 "glMultiDrawArrays(primcount<0)");
1720 unsigned vertcount = 0;
1721 for (i = 0; i < primcount; i++) {
1723 _mesa_compile_error(ctx, GL_INVALID_VALUE,
1724 "glMultiDrawArrays(count[i]<0)");
1727 vertcount += count[i];
1730 grow_vertex_storage(ctx, vertcount);
1732 for (i = 0; i < primcount; i++) {
1734 _save_OBE_DrawArrays(mode, first[i], count[i]);
1741 array_element(struct gl_context *ctx,
1742 GLint basevertex, GLuint elt, unsigned index_size_shift)
1744 /* Section 10.3.5 Primitive Restart:
1746 * When one of the *BaseVertex drawing commands specified in section 10.5
1747 * is used, the primitive restart comparison occurs before the basevertex
1748 * offset is added to the array index.
1750 /* If PrimitiveRestart is enabled and the index is the RestartIndex
1751 * then we call PrimitiveRestartNV and return.
1753 if (ctx->Array._PrimitiveRestart[index_size_shift] &&
1754 elt == ctx->Array._RestartIndex[index_size_shift]) {
1755 CALL_PrimitiveRestartNV(ctx->CurrentServerDispatch, ());
1759 _mesa_array_element(ctx, basevertex + elt);
1763 /* Could do better by copying the arrays and element list intact and
1764 * then emitting an indexed prim at runtime.
1766 static void GLAPIENTRY
1767 _save_OBE_DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type,
1768 const GLvoid * indices, GLint basevertex)
1770 GET_CURRENT_CONTEXT(ctx);
1771 struct vbo_save_context *save = &vbo_context(ctx)->save;
1772 struct gl_vertex_array_object *vao = ctx->Array.VAO;
1773 struct gl_buffer_object *indexbuf = vao->IndexBufferObj;
1776 if (!_mesa_is_valid_prim_mode(ctx, mode)) {
1777 _mesa_compile_error(ctx, GL_INVALID_ENUM, "glDrawElements(mode)");
1781 _mesa_compile_error(ctx, GL_INVALID_VALUE, "glDrawElements(count<0)");
1784 if (type != GL_UNSIGNED_BYTE &&
1785 type != GL_UNSIGNED_SHORT &&
1786 type != GL_UNSIGNED_INT) {
1787 _mesa_compile_error(ctx, GL_INVALID_VALUE, "glDrawElements(count<0)");
1791 if (save->out_of_memory)
1794 grow_vertex_storage(ctx, count);
1796 /* Make sure to process any VBO binding changes */
1797 _mesa_update_state(ctx);
1799 _mesa_vao_map(ctx, vao, GL_MAP_READ_BIT);
1803 ADD_POINTERS(indexbuf->Mappings[MAP_INTERNAL].Pointer, indices);
1805 vbo_save_NotifyBegin(ctx, mode, true);
1808 case GL_UNSIGNED_BYTE:
1809 for (i = 0; i < count; i++)
1810 array_element(ctx, basevertex, ((GLubyte *) indices)[i], 0);
1812 case GL_UNSIGNED_SHORT:
1813 for (i = 0; i < count; i++)
1814 array_element(ctx, basevertex, ((GLushort *) indices)[i], 1);
1816 case GL_UNSIGNED_INT:
1817 for (i = 0; i < count; i++)
1818 array_element(ctx, basevertex, ((GLuint *) indices)[i], 2);
1821 _mesa_error(ctx, GL_INVALID_ENUM, "glDrawElements(type)");
1825 CALL_End(ctx->CurrentServerDispatch, ());
1827 _mesa_vao_unmap(ctx, vao);
1830 static void GLAPIENTRY
1831 _save_OBE_DrawElements(GLenum mode, GLsizei count, GLenum type,
1832 const GLvoid * indices)
1834 _save_OBE_DrawElementsBaseVertex(mode, count, type, indices, 0);
1838 static void GLAPIENTRY
1839 _save_OBE_DrawRangeElements(GLenum mode, GLuint start, GLuint end,
1840 GLsizei count, GLenum type,
1841 const GLvoid * indices)
1843 GET_CURRENT_CONTEXT(ctx);
1844 struct vbo_save_context *save = &vbo_context(ctx)->save;
1846 if (!_mesa_is_valid_prim_mode(ctx, mode)) {
1847 _mesa_compile_error(ctx, GL_INVALID_ENUM, "glDrawRangeElements(mode)");
1851 _mesa_compile_error(ctx, GL_INVALID_VALUE,
1852 "glDrawRangeElements(count<0)");
1855 if (type != GL_UNSIGNED_BYTE &&
1856 type != GL_UNSIGNED_SHORT &&
1857 type != GL_UNSIGNED_INT) {
1858 _mesa_compile_error(ctx, GL_INVALID_ENUM, "glDrawRangeElements(type)");
1862 _mesa_compile_error(ctx, GL_INVALID_VALUE,
1863 "glDrawRangeElements(end < start)");
1867 if (save->out_of_memory)
1870 _save_OBE_DrawElements(mode, count, type, indices);
1874 static void GLAPIENTRY
1875 _save_OBE_MultiDrawElements(GLenum mode, const GLsizei *count, GLenum type,
1876 const GLvoid * const *indices, GLsizei primcount)
1878 GET_CURRENT_CONTEXT(ctx);
1879 struct _glapi_table *dispatch = ctx->CurrentServerDispatch;
1883 for (i = 0; i < primcount; i++) {
1884 vertcount += count[i];
1886 grow_vertex_storage(ctx, vertcount);
1888 for (i = 0; i < primcount; i++) {
1890 CALL_DrawElements(dispatch, (mode, count[i], type, indices[i]));
1896 static void GLAPIENTRY
1897 _save_OBE_MultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count,
1899 const GLvoid * const *indices,
1901 const GLint *basevertex)
1903 GET_CURRENT_CONTEXT(ctx);
1904 struct _glapi_table *dispatch = ctx->CurrentServerDispatch;
1908 for (i = 0; i < primcount; i++) {
1909 vertcount += count[i];
1911 grow_vertex_storage(ctx, vertcount);
1913 for (i = 0; i < primcount; i++) {
1915 CALL_DrawElementsBaseVertex(dispatch, (mode, count[i], type,
1924 vtxfmt_init(struct gl_context *ctx)
1926 struct vbo_save_context *save = &vbo_context(ctx)->save;
1927 GLvertexformat *vfmt = &save->vtxfmt;
1929 #define NAME_AE(x) _ae_##x
1930 #define NAME_CALLLIST(x) _save_##x
1931 #define NAME(x) _save_##x
1932 #define NAME_ES(x) _save_##x##ARB
1934 #include "vbo_init_tmp.h"
1939 * Initialize the dispatch table with the VBO functions for display
1943 vbo_initialize_save_dispatch(const struct gl_context *ctx,
1944 struct _glapi_table *exec)
1946 SET_DrawArrays(exec, _save_OBE_DrawArrays);
1947 SET_MultiDrawArrays(exec, _save_OBE_MultiDrawArrays);
1948 SET_DrawElements(exec, _save_OBE_DrawElements);
1949 SET_DrawElementsBaseVertex(exec, _save_OBE_DrawElementsBaseVertex);
1950 SET_DrawRangeElements(exec, _save_OBE_DrawRangeElements);
1951 SET_MultiDrawElementsEXT(exec, _save_OBE_MultiDrawElements);
1952 SET_MultiDrawElementsBaseVertex(exec, _save_OBE_MultiDrawElementsBaseVertex);
1953 SET_Rectf(exec, _save_OBE_Rectf);
1954 SET_Rectd(exec, _save_OBE_Rectd);
1955 SET_Rectdv(exec, _save_OBE_Rectdv);
1956 SET_Rectfv(exec, _save_OBE_Rectfv);
1957 SET_Recti(exec, _save_OBE_Recti);
1958 SET_Rectiv(exec, _save_OBE_Rectiv);
1959 SET_Rects(exec, _save_OBE_Rects);
1960 SET_Rectsv(exec, _save_OBE_Rectsv);
1962 /* Note: other glDraw functins aren't compiled into display lists */
1968 vbo_save_SaveFlushVertices(struct gl_context *ctx)
1970 struct vbo_save_context *save = &vbo_context(ctx)->save;
1972 /* Noop when we are actually active:
1974 if (ctx->Driver.CurrentSavePrimitive <= PRIM_MAX)
1977 if (save->vertex_store->used || save->prim_store->used)
1978 compile_vertex_list(ctx);
1980 copy_to_current(ctx);
1982 ctx->Driver.SaveNeedFlush = GL_FALSE;
1987 * Called from glNewList when we're starting to compile a display list.
1990 vbo_save_NewList(struct gl_context *ctx, GLuint list, GLenum mode)
1992 struct vbo_save_context *save = &vbo_context(ctx)->save;
1997 if (!save->prim_store)
1998 save->prim_store = realloc_prim_store(NULL, 8);
2000 if (!save->vertex_store)
2001 save->vertex_store = CALLOC_STRUCT(vbo_save_vertex_store);
2004 ctx->Driver.SaveNeedFlush = GL_FALSE;
2009 * Called from glEndList when we're finished compiling a display list.
2012 vbo_save_EndList(struct gl_context *ctx)
2014 struct vbo_save_context *save = &vbo_context(ctx)->save;
2016 /* EndList called inside a (saved) Begin/End pair?
2018 if (_mesa_inside_dlist_begin_end(ctx)) {
2019 if (save->prim_store->used > 0) {
2020 GLint i = save->prim_store->used - 1;
2021 ctx->Driver.CurrentSavePrimitive = PRIM_OUTSIDE_BEGIN_END;
2022 save->prim_store->prims[i].end = 0;
2023 save->prim_store->prims[i].count = get_vertex_count(save) - save->prim_store->prims[i].start;
2026 /* Make sure this vertex list gets replayed by the "loopback"
2029 save->dangling_attr_ref = GL_TRUE;
2030 vbo_save_SaveFlushVertices(ctx);
2032 /* Swap out this vertex format while outside begin/end. Any color,
2033 * etc. received between here and the next begin will be compiled
2036 _mesa_install_save_vtxfmt(ctx, &ctx->ListState.ListVtxfmt);
2039 assert(save->vertex_size == 0);
2043 * Called during context creation/init.
2046 current_init(struct gl_context *ctx)
2048 struct vbo_save_context *save = &vbo_context(ctx)->save;
2051 for (i = VBO_ATTRIB_POS; i <= VBO_ATTRIB_EDGEFLAG; i++) {
2052 const GLuint j = i - VBO_ATTRIB_POS;
2053 assert(j < VERT_ATTRIB_MAX);
2054 save->currentsz[i] = &ctx->ListState.ActiveAttribSize[j];
2055 save->current[i] = (fi_type *) ctx->ListState.CurrentAttrib[j];
2058 for (i = VBO_ATTRIB_FIRST_MATERIAL; i <= VBO_ATTRIB_LAST_MATERIAL; i++) {
2059 const GLuint j = i - VBO_ATTRIB_FIRST_MATERIAL;
2060 assert(j < MAT_ATTRIB_MAX);
2061 save->currentsz[i] = &ctx->ListState.ActiveMaterialSize[j];
2062 save->current[i] = (fi_type *) ctx->ListState.CurrentMaterial[j];
2068 * Initialize the display list compiler. Called during context creation.
2071 vbo_save_api_init(struct vbo_save_context *save)
2073 struct gl_context *ctx = gl_context_from_vbo_save(save);