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.
70 #include "main/glheader.h"
71 #include "main/bufferobj.h"
72 #include "main/context.h"
73 #include "main/dlist.h"
74 #include "main/enums.h"
75 #include "main/eval.h"
76 #include "main/macros.h"
77 #include "main/api_validate.h"
78 #include "main/api_arrayelt.h"
79 #include "main/vtxfmt.h"
80 #include "main/dispatch.h"
81 #include "main/state.h"
82 #include "util/bitscan.h"
84 #include "vbo_context.h"
93 /* An interesting VBO number/name to help with debugging */
94 #define VBO_BUF_ID 12345
98 * NOTE: Old 'parity' issue is gone, but copying can still be
99 * wrong-footed on replay.
102 _save_copy_vertices(struct gl_context
*ctx
,
103 const struct vbo_save_vertex_list
*node
,
104 const fi_type
* src_buffer
)
106 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
107 const struct _mesa_prim
*prim
= &node
->prim
[node
->prim_count
- 1];
108 GLuint nr
= prim
->count
;
109 GLuint sz
= save
->vertex_size
;
110 const fi_type
*src
= src_buffer
+ prim
->start
* sz
;
111 fi_type
*dst
= save
->copied
.buffer
;
117 switch (prim
->mode
) {
122 for (i
= 0; i
< ovf
; i
++)
123 memcpy(dst
+ i
* sz
, src
+ (nr
- ovf
+ i
) * sz
,
124 sz
* sizeof(GLfloat
));
128 for (i
= 0; i
< ovf
; i
++)
129 memcpy(dst
+ i
* sz
, src
+ (nr
- ovf
+ i
) * sz
,
130 sz
* sizeof(GLfloat
));
134 for (i
= 0; i
< ovf
; i
++)
135 memcpy(dst
+ i
* sz
, src
+ (nr
- ovf
+ i
) * sz
,
136 sz
* sizeof(GLfloat
));
142 memcpy(dst
, src
+ (nr
- 1) * sz
, sz
* sizeof(GLfloat
));
146 case GL_TRIANGLE_FAN
:
151 memcpy(dst
, src
+ 0, sz
* sizeof(GLfloat
));
155 memcpy(dst
, src
+ 0, sz
* sizeof(GLfloat
));
156 memcpy(dst
+ sz
, src
+ (nr
- 1) * sz
, sz
* sizeof(GLfloat
));
159 case GL_TRIANGLE_STRIP
:
172 for (i
= 0; i
< ovf
; i
++)
173 memcpy(dst
+ i
* sz
, src
+ (nr
- ovf
+ i
) * sz
,
174 sz
* sizeof(GLfloat
));
183 static struct vbo_save_vertex_store
*
184 alloc_vertex_store(struct gl_context
*ctx
)
186 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
187 struct vbo_save_vertex_store
*vertex_store
=
188 CALLOC_STRUCT(vbo_save_vertex_store
);
190 /* obj->Name needs to be non-zero, but won't ever be examined more
191 * closely than that. In particular these buffers won't be entered
192 * into the hash and can never be confused with ones visible to the
193 * user. Perhaps there could be a special number for internal
196 vertex_store
->bufferobj
= ctx
->Driver
.NewBufferObject(ctx
, VBO_BUF_ID
);
197 if (vertex_store
->bufferobj
) {
198 save
->out_of_memory
=
199 !ctx
->Driver
.BufferData(ctx
,
201 VBO_SAVE_BUFFER_SIZE
* sizeof(GLfloat
),
202 NULL
, GL_STATIC_DRAW_ARB
,
204 GL_DYNAMIC_STORAGE_BIT
,
205 vertex_store
->bufferobj
);
208 save
->out_of_memory
= GL_TRUE
;
211 if (save
->out_of_memory
) {
212 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "internal VBO allocation");
213 _mesa_install_save_vtxfmt(ctx
, &save
->vtxfmt_noop
);
216 vertex_store
->buffer
= NULL
;
217 vertex_store
->used
= 0;
218 vertex_store
->refcount
= 1;
225 free_vertex_store(struct gl_context
*ctx
,
226 struct vbo_save_vertex_store
*vertex_store
)
228 assert(!vertex_store
->buffer
);
230 if (vertex_store
->bufferobj
) {
231 _mesa_reference_buffer_object(ctx
, &vertex_store
->bufferobj
, NULL
);
239 vbo_save_map_vertex_store(struct gl_context
*ctx
,
240 struct vbo_save_vertex_store
*vertex_store
)
242 const GLbitfield access
= (GL_MAP_WRITE_BIT
|
243 GL_MAP_INVALIDATE_RANGE_BIT
|
244 GL_MAP_UNSYNCHRONIZED_BIT
|
245 GL_MAP_FLUSH_EXPLICIT_BIT
);
247 assert(vertex_store
->bufferobj
);
248 assert(!vertex_store
->buffer
); /* the buffer should not be mapped */
250 if (vertex_store
->bufferobj
->Size
> 0) {
251 /* Map the remaining free space in the VBO */
252 GLintptr offset
= vertex_store
->used
* sizeof(GLfloat
);
253 GLsizeiptr size
= vertex_store
->bufferobj
->Size
- offset
;
254 fi_type
*range
= (fi_type
*)
255 ctx
->Driver
.MapBufferRange(ctx
, offset
, size
, access
,
256 vertex_store
->bufferobj
,
259 /* compute address of start of whole buffer (needed elsewhere) */
260 vertex_store
->buffer
= range
- vertex_store
->used
;
261 assert(vertex_store
->buffer
);
265 vertex_store
->buffer
= NULL
;
270 /* probably ran out of memory for buffers */
277 vbo_save_unmap_vertex_store(struct gl_context
*ctx
,
278 struct vbo_save_vertex_store
*vertex_store
)
280 if (vertex_store
->bufferobj
->Size
> 0) {
282 GLsizeiptr length
= vertex_store
->used
* sizeof(GLfloat
)
283 - vertex_store
->bufferobj
->Mappings
[MAP_INTERNAL
].Offset
;
285 /* Explicitly flush the region we wrote to */
286 ctx
->Driver
.FlushMappedBufferRange(ctx
, offset
, length
,
287 vertex_store
->bufferobj
,
290 ctx
->Driver
.UnmapBuffer(ctx
, vertex_store
->bufferobj
, MAP_INTERNAL
);
292 vertex_store
->buffer
= NULL
;
296 static struct vbo_save_primitive_store
*
297 alloc_prim_store(struct gl_context
*ctx
)
299 struct vbo_save_primitive_store
*store
=
300 CALLOC_STRUCT(vbo_save_primitive_store
);
309 _save_reset_counters(struct gl_context
*ctx
)
311 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
313 save
->prim
= save
->prim_store
->buffer
+ save
->prim_store
->used
;
314 save
->buffer
= save
->vertex_store
->buffer
+ save
->vertex_store
->used
;
316 assert(save
->buffer
== save
->buffer_ptr
);
318 if (save
->vertex_size
)
319 save
->max_vert
= (VBO_SAVE_BUFFER_SIZE
- save
->vertex_store
->used
) /
324 save
->vert_count
= 0;
325 save
->prim_count
= 0;
326 save
->prim_max
= VBO_SAVE_PRIM_SIZE
- save
->prim_store
->used
;
327 save
->dangling_attr_ref
= GL_FALSE
;
331 * For a list of prims, try merging prims that can just be extensions of the
335 merge_prims(struct _mesa_prim
*prim_list
,
339 struct _mesa_prim
*prev_prim
= prim_list
;
341 for (i
= 1; i
< *prim_count
; i
++) {
342 struct _mesa_prim
*this_prim
= prim_list
+ i
;
344 vbo_try_prim_conversion(this_prim
);
346 if (vbo_can_merge_prims(prev_prim
, this_prim
)) {
347 /* We've found a prim that just extend the previous one. Tack it
348 * onto the previous one, and let this primitive struct get dropped.
350 vbo_merge_prims(prev_prim
, this_prim
);
354 /* If any previous primitives have been dropped, then we need to copy
355 * this later one into the next available slot.
358 if (prev_prim
!= this_prim
)
359 *prev_prim
= *this_prim
;
362 *prim_count
= prev_prim
- prim_list
+ 1;
367 * Convert GL_LINE_LOOP primitive into GL_LINE_STRIP so that drivers
368 * don't have to worry about handling the _mesa_prim::begin/end flags.
369 * See https://bugs.freedesktop.org/show_bug.cgi?id=81174
372 convert_line_loop_to_strip(struct vbo_save_context
*save
,
373 struct vbo_save_vertex_list
*node
)
375 struct _mesa_prim
*prim
= &node
->prim
[node
->prim_count
- 1];
377 assert(prim
->mode
== GL_LINE_LOOP
);
380 /* Copy the 0th vertex to end of the buffer and extend the
381 * vertex count by one to finish the line loop.
383 const GLuint sz
= save
->vertex_size
;
385 const fi_type
*src
= save
->buffer
+ prim
->start
* sz
;
387 fi_type
*dst
= save
->buffer
+ (prim
->start
+ prim
->count
) * sz
;
389 memcpy(dst
, src
, sz
* sizeof(float));
394 save
->buffer_ptr
+= sz
;
395 save
->vertex_store
->used
+= sz
;
399 /* Drawing the second or later section of a long line loop.
400 * Skip the 0th vertex.
406 prim
->mode
= GL_LINE_STRIP
;
411 * Insert the active immediate struct onto the display list currently
415 _save_compile_vertex_list(struct gl_context
*ctx
)
417 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
418 struct vbo_save_vertex_list
*node
;
420 /* Allocate space for this structure in the display list currently
423 node
= (struct vbo_save_vertex_list
*)
424 _mesa_dlist_alloc_aligned(ctx
, save
->opcode_vertex_list
, sizeof(*node
));
429 /* Make sure the pointer is aligned to the size of a pointer */
430 assert((GLintptr
) node
% sizeof(void *) == 0);
432 /* Duplicate our template, increment refcounts to the storage structs:
434 node
->enabled
= save
->enabled
;
435 memcpy(node
->attrsz
, save
->attrsz
, sizeof(node
->attrsz
));
436 memcpy(node
->attrtype
, save
->attrtype
, sizeof(node
->attrtype
));
437 node
->vertex_size
= save
->vertex_size
;
438 node
->buffer_offset
=
439 (save
->buffer
- save
->vertex_store
->buffer
) * sizeof(GLfloat
);
440 node
->count
= save
->vert_count
;
441 node
->wrap_count
= save
->copied
.nr
;
442 node
->dangling_attr_ref
= save
->dangling_attr_ref
;
443 node
->prim
= save
->prim
;
444 node
->prim_count
= save
->prim_count
;
445 node
->vertex_store
= save
->vertex_store
;
446 node
->prim_store
= save
->prim_store
;
448 node
->vertex_store
->refcount
++;
449 node
->prim_store
->refcount
++;
451 if (node
->prim
[0].no_current_update
) {
452 node
->current_size
= 0;
453 node
->current_data
= NULL
;
456 node
->current_size
= node
->vertex_size
- node
->attrsz
[0];
457 node
->current_data
= NULL
;
459 if (node
->current_size
) {
460 /* If the malloc fails, we just pull the data out of the VBO
463 node
->current_data
= malloc(node
->current_size
* sizeof(GLfloat
));
464 if (node
->current_data
) {
465 const char *buffer
= (const char *) save
->vertex_store
->buffer
;
466 unsigned attr_offset
= node
->attrsz
[0] * sizeof(GLfloat
);
467 unsigned vertex_offset
= 0;
471 (node
->count
- 1) * node
->vertex_size
* sizeof(GLfloat
);
473 memcpy(node
->current_data
,
474 buffer
+ node
->buffer_offset
+ vertex_offset
+ attr_offset
,
475 node
->current_size
* sizeof(GLfloat
));
480 assert(node
->attrsz
[VBO_ATTRIB_POS
] != 0 || node
->count
== 0);
482 if (save
->dangling_attr_ref
)
483 ctx
->ListState
.CurrentList
->Flags
|= DLIST_DANGLING_REFS
;
485 save
->vertex_store
->used
+= save
->vertex_size
* node
->count
;
486 save
->prim_store
->used
+= node
->prim_count
;
488 /* Copy duplicated vertices
490 save
->copied
.nr
= _save_copy_vertices(ctx
, node
, save
->buffer
);
492 if (node
->prim
[node
->prim_count
- 1].mode
== GL_LINE_LOOP
) {
493 convert_line_loop_to_strip(save
, node
);
496 merge_prims(node
->prim
, &node
->prim_count
);
498 /* Deal with GL_COMPILE_AND_EXECUTE:
500 if (ctx
->ExecuteFlag
) {
501 struct _glapi_table
*dispatch
= GET_DISPATCH();
503 _glapi_set_dispatch(ctx
->Exec
);
505 vbo_loopback_vertex_list(ctx
,
506 (const GLfloat
*) ((const char *) save
->
507 vertex_store
->buffer
+
508 node
->buffer_offset
),
509 node
->attrsz
, node
->prim
, node
->prim_count
,
510 node
->wrap_count
, node
->vertex_size
);
512 _glapi_set_dispatch(dispatch
);
515 /* Decide whether the storage structs are full, or can be used for
516 * the next vertex lists as well.
518 if (save
->vertex_store
->used
>
519 VBO_SAVE_BUFFER_SIZE
- 16 * (save
->vertex_size
+ 4)) {
523 vbo_save_unmap_vertex_store(ctx
, save
->vertex_store
);
525 /* Release old reference:
527 save
->vertex_store
->refcount
--;
528 assert(save
->vertex_store
->refcount
!= 0);
529 save
->vertex_store
= NULL
;
531 /* Allocate and map new store:
533 save
->vertex_store
= alloc_vertex_store(ctx
);
534 save
->buffer_ptr
= vbo_save_map_vertex_store(ctx
, save
->vertex_store
);
535 save
->out_of_memory
= save
->buffer_ptr
== NULL
;
538 /* update buffer_ptr for next vertex */
539 save
->buffer_ptr
= save
->vertex_store
->buffer
+ save
->vertex_store
->used
;
542 if (save
->prim_store
->used
> VBO_SAVE_PRIM_SIZE
- 6) {
543 save
->prim_store
->refcount
--;
544 assert(save
->prim_store
->refcount
!= 0);
545 save
->prim_store
= alloc_prim_store(ctx
);
548 /* Reset our structures for the next run of vertices:
550 _save_reset_counters(ctx
);
555 * This is called when we fill a vertex buffer before we hit a glEnd().
557 * TODO -- If no new vertices have been stored, don't bother saving it.
560 _save_wrap_buffers(struct gl_context
*ctx
)
562 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
563 GLint i
= save
->prim_count
- 1;
566 GLboolean no_current_update
;
568 assert(i
< (GLint
) save
->prim_max
);
571 /* Close off in-progress primitive.
573 save
->prim
[i
].count
= (save
->vert_count
- save
->prim
[i
].start
);
574 mode
= save
->prim
[i
].mode
;
575 weak
= save
->prim
[i
].weak
;
576 no_current_update
= save
->prim
[i
].no_current_update
;
578 /* store the copied vertices, and allocate a new list.
580 _save_compile_vertex_list(ctx
);
582 /* Restart interrupted primitive
584 save
->prim
[0].mode
= mode
;
585 save
->prim
[0].weak
= weak
;
586 save
->prim
[0].no_current_update
= no_current_update
;
587 save
->prim
[0].begin
= 0;
588 save
->prim
[0].end
= 0;
589 save
->prim
[0].pad
= 0;
590 save
->prim
[0].start
= 0;
591 save
->prim
[0].count
= 0;
592 save
->prim
[0].num_instances
= 1;
593 save
->prim
[0].base_instance
= 0;
594 save
->prim
[0].is_indirect
= 0;
595 save
->prim_count
= 1;
600 * Called only when buffers are wrapped as the result of filling the
601 * vertex_store struct.
604 _save_wrap_filled_vertex(struct gl_context
*ctx
)
606 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
607 unsigned numComponents
;
609 /* Emit a glEnd to close off the last vertex list.
611 _save_wrap_buffers(ctx
);
613 /* Copy stored stored vertices to start of new list.
615 assert(save
->max_vert
- save
->vert_count
> save
->copied
.nr
);
617 numComponents
= save
->copied
.nr
* save
->vertex_size
;
618 memcpy(save
->buffer_ptr
,
620 numComponents
* sizeof(fi_type
));
621 save
->buffer_ptr
+= numComponents
;
622 save
->vert_count
+= save
->copied
.nr
;
627 _save_copy_to_current(struct gl_context
*ctx
)
629 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
630 GLbitfield64 enabled
= save
->enabled
& (~BITFIELD64_BIT(VBO_ATTRIB_POS
));
633 const int i
= u_bit_scan64(&enabled
);
634 assert(save
->attrsz
[i
]);
636 save
->currentsz
[i
][0] = save
->attrsz
[i
];
637 COPY_CLEAN_4V_TYPE_AS_UNION(save
->current
[i
], save
->attrsz
[i
],
638 save
->attrptr
[i
], save
->attrtype
[i
]);
644 _save_copy_from_current(struct gl_context
*ctx
)
646 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
647 GLbitfield64 enabled
= save
->enabled
& (~BITFIELD64_BIT(VBO_ATTRIB_POS
));
650 const int i
= u_bit_scan64(&enabled
);
652 switch (save
->attrsz
[i
]) {
654 save
->attrptr
[i
][3] = save
->current
[i
][3];
656 save
->attrptr
[i
][2] = save
->current
[i
][2];
658 save
->attrptr
[i
][1] = save
->current
[i
][1];
660 save
->attrptr
[i
][0] = save
->current
[i
][0];
671 * Called when we increase the size of a vertex attribute. For example,
672 * if we've seen one or more glTexCoord2f() calls and now we get a
673 * glTexCoord3f() call.
674 * Flush existing data, set new attrib size, replay copied vertices.
677 _save_upgrade_vertex(struct gl_context
*ctx
, GLuint attr
, GLuint newsz
)
679 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
684 /* Store the current run of vertices, and emit a GL_END. Emit a
685 * BEGIN in the new buffer.
687 if (save
->vert_count
)
688 _save_wrap_buffers(ctx
);
690 assert(save
->copied
.nr
== 0);
692 /* Do a COPY_TO_CURRENT to ensure back-copying works for the case
693 * when the attribute already exists in the vertex and is having
694 * its size increased.
696 _save_copy_to_current(ctx
);
700 oldsz
= save
->attrsz
[attr
];
701 save
->attrsz
[attr
] = newsz
;
702 save
->enabled
|= BITFIELD64_BIT(attr
);
704 save
->vertex_size
+= newsz
- oldsz
;
705 save
->max_vert
= ((VBO_SAVE_BUFFER_SIZE
- save
->vertex_store
->used
) /
707 save
->vert_count
= 0;
709 /* Recalculate all the attrptr[] values:
712 for (i
= 0; i
< VBO_ATTRIB_MAX
; i
++) {
713 if (save
->attrsz
[i
]) {
714 save
->attrptr
[i
] = tmp
;
715 tmp
+= save
->attrsz
[i
];
718 save
->attrptr
[i
] = NULL
; /* will not be dereferenced. */
722 /* Copy from current to repopulate the vertex with correct values.
724 _save_copy_from_current(ctx
);
726 /* Replay stored vertices to translate them to new format here.
728 * If there are copied vertices and the new (upgraded) attribute
729 * has not been defined before, this list is somewhat degenerate,
730 * and will need fixup at runtime.
732 if (save
->copied
.nr
) {
733 const fi_type
*data
= save
->copied
.buffer
;
734 fi_type
*dest
= save
->buffer
;
736 /* Need to note this and fix up at runtime (or loopback):
738 if (attr
!= VBO_ATTRIB_POS
&& save
->currentsz
[attr
][0] == 0) {
740 save
->dangling_attr_ref
= GL_TRUE
;
743 for (i
= 0; i
< save
->copied
.nr
; i
++) {
744 GLbitfield64 enabled
= save
->enabled
;
746 const int j
= u_bit_scan64(&enabled
);
747 assert(save
->attrsz
[j
]);
750 COPY_CLEAN_4V_TYPE_AS_UNION(dest
, oldsz
, data
,
756 COPY_SZ_4V(dest
, newsz
, save
->current
[attr
]);
761 GLint sz
= save
->attrsz
[j
];
762 COPY_SZ_4V(dest
, sz
, data
);
769 save
->buffer_ptr
= dest
;
770 save
->vert_count
+= save
->copied
.nr
;
776 * This is called when the size of a vertex attribute changes.
777 * For example, after seeing one or more glTexCoord2f() calls we
778 * get a glTexCoord4f() or glTexCoord1f() call.
781 save_fixup_vertex(struct gl_context
*ctx
, GLuint attr
, GLuint sz
)
783 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
785 if (sz
> save
->attrsz
[attr
]) {
786 /* New size is larger. Need to flush existing vertices and get
787 * an enlarged vertex format.
789 _save_upgrade_vertex(ctx
, attr
, sz
);
791 else if (sz
< save
->active_sz
[attr
]) {
793 const fi_type
*id
= vbo_get_default_vals_as_union(save
->attrtype
[attr
]);
795 /* New size is equal or smaller - just need to fill in some
798 for (i
= sz
; i
<= save
->attrsz
[attr
]; i
++)
799 save
->attrptr
[attr
][i
- 1] = id
[i
- 1];
802 save
->active_sz
[attr
] = sz
;
807 * Reset the current size of all vertex attributes to the default
808 * value of 0. This signals that we haven't yet seen any per-vertex
809 * commands such as glNormal3f() or glTexCoord2f().
812 _save_reset_vertex(struct gl_context
*ctx
)
814 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
816 while (save
->enabled
) {
817 const int i
= u_bit_scan64(&save
->enabled
);
818 assert(save
->attrsz
[i
]);
820 save
->active_sz
[i
] = 0;
823 save
->vertex_size
= 0;
828 #define ERROR(err) _mesa_compile_error(ctx, err, __func__);
831 /* Only one size for each attribute may be active at once. Eg. if
832 * Color3f is installed/active, then Color4f may not be, even if the
833 * vertex actually contains 4 color coordinates. This is because the
834 * 3f version won't otherwise set color[3] to 1.0 -- this is the job
835 * of the chooser function when switching between Color4f and Color3f.
837 #define ATTR_UNION(A, N, T, C, V0, V1, V2, V3) \
839 struct vbo_save_context *save = &vbo_context(ctx)->save; \
841 if (save->active_sz[A] != N) \
842 save_fixup_vertex(ctx, A, N); \
845 C *dest = (C *)save->attrptr[A]; \
846 if (N>0) dest[0] = V0; \
847 if (N>1) dest[1] = V1; \
848 if (N>2) dest[2] = V2; \
849 if (N>3) dest[3] = V3; \
850 save->attrtype[A] = T; \
856 for (i = 0; i < save->vertex_size; i++) \
857 save->buffer_ptr[i] = save->vertex[i]; \
859 save->buffer_ptr += save->vertex_size; \
861 if (++save->vert_count >= save->max_vert) \
862 _save_wrap_filled_vertex(ctx); \
866 #define TAG(x) _save_##x
868 #include "vbo_attrib_tmp.h"
872 #define MAT( ATTR, N, face, params ) \
874 if (face != GL_BACK) \
875 MAT_ATTR( ATTR, N, params ); /* front */ \
876 if (face != GL_FRONT) \
877 MAT_ATTR( ATTR + 1, N, params ); /* back */ \
882 * Save a glMaterial call found between glBegin/End.
883 * glMaterial calls outside Begin/End are handled in dlist.c.
885 static void GLAPIENTRY
886 _save_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
888 GET_CURRENT_CONTEXT(ctx
);
890 if (face
!= GL_FRONT
&& face
!= GL_BACK
&& face
!= GL_FRONT_AND_BACK
) {
891 _mesa_compile_error(ctx
, GL_INVALID_ENUM
, "glMaterial(face)");
897 MAT(VBO_ATTRIB_MAT_FRONT_EMISSION
, 4, face
, params
);
900 MAT(VBO_ATTRIB_MAT_FRONT_AMBIENT
, 4, face
, params
);
903 MAT(VBO_ATTRIB_MAT_FRONT_DIFFUSE
, 4, face
, params
);
906 MAT(VBO_ATTRIB_MAT_FRONT_SPECULAR
, 4, face
, params
);
909 if (*params
< 0 || *params
> ctx
->Const
.MaxShininess
) {
910 _mesa_compile_error(ctx
, GL_INVALID_VALUE
, "glMaterial(shininess)");
913 MAT(VBO_ATTRIB_MAT_FRONT_SHININESS
, 1, face
, params
);
916 case GL_COLOR_INDEXES
:
917 MAT(VBO_ATTRIB_MAT_FRONT_INDEXES
, 3, face
, params
);
919 case GL_AMBIENT_AND_DIFFUSE
:
920 MAT(VBO_ATTRIB_MAT_FRONT_AMBIENT
, 4, face
, params
);
921 MAT(VBO_ATTRIB_MAT_FRONT_DIFFUSE
, 4, face
, params
);
924 _mesa_compile_error(ctx
, GL_INVALID_ENUM
, "glMaterial(pname)");
930 /* Cope with EvalCoord/CallList called within a begin/end object:
931 * -- Flush current buffer
932 * -- Fallback to opcodes for the rest of the begin/end object.
935 dlist_fallback(struct gl_context
*ctx
)
937 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
939 if (save
->vert_count
|| save
->prim_count
) {
940 if (save
->prim_count
> 0) {
941 /* Close off in-progress primitive. */
942 GLint i
= save
->prim_count
- 1;
943 save
->prim
[i
].count
= save
->vert_count
- save
->prim
[i
].start
;
946 /* Need to replay this display list with loopback,
947 * unfortunately, otherwise this primitive won't be handled
950 save
->dangling_attr_ref
= GL_TRUE
;
952 _save_compile_vertex_list(ctx
);
955 _save_copy_to_current(ctx
);
956 _save_reset_vertex(ctx
);
957 _save_reset_counters(ctx
);
958 if (save
->out_of_memory
) {
959 _mesa_install_save_vtxfmt(ctx
, &save
->vtxfmt_noop
);
962 _mesa_install_save_vtxfmt(ctx
, &ctx
->ListState
.ListVtxfmt
);
964 ctx
->Driver
.SaveNeedFlush
= GL_FALSE
;
968 static void GLAPIENTRY
969 _save_EvalCoord1f(GLfloat u
)
971 GET_CURRENT_CONTEXT(ctx
);
973 CALL_EvalCoord1f(ctx
->Save
, (u
));
976 static void GLAPIENTRY
977 _save_EvalCoord1fv(const GLfloat
* v
)
979 GET_CURRENT_CONTEXT(ctx
);
981 CALL_EvalCoord1fv(ctx
->Save
, (v
));
984 static void GLAPIENTRY
985 _save_EvalCoord2f(GLfloat u
, GLfloat v
)
987 GET_CURRENT_CONTEXT(ctx
);
989 CALL_EvalCoord2f(ctx
->Save
, (u
, v
));
992 static void GLAPIENTRY
993 _save_EvalCoord2fv(const GLfloat
* v
)
995 GET_CURRENT_CONTEXT(ctx
);
997 CALL_EvalCoord2fv(ctx
->Save
, (v
));
1000 static void GLAPIENTRY
1001 _save_EvalPoint1(GLint i
)
1003 GET_CURRENT_CONTEXT(ctx
);
1004 dlist_fallback(ctx
);
1005 CALL_EvalPoint1(ctx
->Save
, (i
));
1008 static void GLAPIENTRY
1009 _save_EvalPoint2(GLint i
, GLint j
)
1011 GET_CURRENT_CONTEXT(ctx
);
1012 dlist_fallback(ctx
);
1013 CALL_EvalPoint2(ctx
->Save
, (i
, j
));
1016 static void GLAPIENTRY
1017 _save_CallList(GLuint l
)
1019 GET_CURRENT_CONTEXT(ctx
);
1020 dlist_fallback(ctx
);
1021 CALL_CallList(ctx
->Save
, (l
));
1024 static void GLAPIENTRY
1025 _save_CallLists(GLsizei n
, GLenum type
, const GLvoid
* v
)
1027 GET_CURRENT_CONTEXT(ctx
);
1028 dlist_fallback(ctx
);
1029 CALL_CallLists(ctx
->Save
, (n
, type
, v
));
1035 * Called when a glBegin is getting compiled into a display list.
1036 * Updating of ctx->Driver.CurrentSavePrimitive is already taken care of.
1039 vbo_save_NotifyBegin(struct gl_context
*ctx
, GLenum mode
)
1041 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
1042 const GLuint i
= save
->prim_count
++;
1044 assert(i
< save
->prim_max
);
1045 save
->prim
[i
].mode
= mode
& VBO_SAVE_PRIM_MODE_MASK
;
1046 save
->prim
[i
].begin
= 1;
1047 save
->prim
[i
].end
= 0;
1048 save
->prim
[i
].weak
= (mode
& VBO_SAVE_PRIM_WEAK
) ? 1 : 0;
1049 save
->prim
[i
].no_current_update
=
1050 (mode
& VBO_SAVE_PRIM_NO_CURRENT_UPDATE
) ? 1 : 0;
1051 save
->prim
[i
].pad
= 0;
1052 save
->prim
[i
].start
= save
->vert_count
;
1053 save
->prim
[i
].count
= 0;
1054 save
->prim
[i
].num_instances
= 1;
1055 save
->prim
[i
].base_instance
= 0;
1056 save
->prim
[i
].is_indirect
= 0;
1058 if (save
->out_of_memory
) {
1059 _mesa_install_save_vtxfmt(ctx
, &save
->vtxfmt_noop
);
1062 _mesa_install_save_vtxfmt(ctx
, &save
->vtxfmt
);
1065 /* We need to call vbo_save_SaveFlushVertices() if there's state change */
1066 ctx
->Driver
.SaveNeedFlush
= GL_TRUE
;
1068 /* GL_TRUE means we've handled this glBegin here; don't compile a BEGIN
1069 * opcode into the display list.
1075 static void GLAPIENTRY
1078 GET_CURRENT_CONTEXT(ctx
);
1079 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
1080 const GLint i
= save
->prim_count
- 1;
1082 ctx
->Driver
.CurrentSavePrimitive
= PRIM_OUTSIDE_BEGIN_END
;
1083 save
->prim
[i
].end
= 1;
1084 save
->prim
[i
].count
= (save
->vert_count
- save
->prim
[i
].start
);
1086 if (i
== (GLint
) save
->prim_max
- 1) {
1087 _save_compile_vertex_list(ctx
);
1088 assert(save
->copied
.nr
== 0);
1091 /* Swap out this vertex format while outside begin/end. Any color,
1092 * etc. received between here and the next begin will be compiled
1095 if (save
->out_of_memory
) {
1096 _mesa_install_save_vtxfmt(ctx
, &save
->vtxfmt_noop
);
1099 _mesa_install_save_vtxfmt(ctx
, &ctx
->ListState
.ListVtxfmt
);
1104 static void GLAPIENTRY
1105 _save_Begin(GLenum mode
)
1107 GET_CURRENT_CONTEXT(ctx
);
1109 _mesa_compile_error(ctx
, GL_INVALID_OPERATION
, "Recursive glBegin");
1113 static void GLAPIENTRY
1114 _save_PrimitiveRestartNV(void)
1117 GET_CURRENT_CONTEXT(ctx
);
1119 curPrim
= ctx
->Driver
.CurrentSavePrimitive
;
1122 _save_Begin(curPrim
);
1126 /* Unlike the functions above, these are to be hooked into the vtxfmt
1127 * maintained in ctx->ListState, active when the list is known or
1128 * suspected to be outside any begin/end primitive.
1129 * Note: OBE = Outside Begin/End
1131 static void GLAPIENTRY
1132 _save_OBE_Rectf(GLfloat x1
, GLfloat y1
, GLfloat x2
, GLfloat y2
)
1134 GET_CURRENT_CONTEXT(ctx
);
1135 vbo_save_NotifyBegin(ctx
, GL_QUADS
| VBO_SAVE_PRIM_WEAK
);
1136 CALL_Vertex2f(GET_DISPATCH(), (x1
, y1
));
1137 CALL_Vertex2f(GET_DISPATCH(), (x2
, y1
));
1138 CALL_Vertex2f(GET_DISPATCH(), (x2
, y2
));
1139 CALL_Vertex2f(GET_DISPATCH(), (x1
, y2
));
1140 CALL_End(GET_DISPATCH(), ());
1144 static void GLAPIENTRY
1145 _save_OBE_DrawArrays(GLenum mode
, GLint start
, GLsizei count
)
1147 GET_CURRENT_CONTEXT(ctx
);
1148 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
1151 if (!_mesa_is_valid_prim_mode(ctx
, mode
)) {
1152 _mesa_compile_error(ctx
, GL_INVALID_ENUM
, "glDrawArrays(mode)");
1156 _mesa_compile_error(ctx
, GL_INVALID_VALUE
, "glDrawArrays(count<0)");
1160 if (save
->out_of_memory
)
1163 /* Make sure to process any VBO binding changes */
1164 _mesa_update_state(ctx
);
1168 vbo_save_NotifyBegin(ctx
, (mode
| VBO_SAVE_PRIM_WEAK
1169 | VBO_SAVE_PRIM_NO_CURRENT_UPDATE
));
1171 for (i
= 0; i
< count
; i
++)
1172 CALL_ArrayElement(GET_DISPATCH(), (start
+ i
));
1173 CALL_End(GET_DISPATCH(), ());
1175 _ae_unmap_vbos(ctx
);
1179 static void GLAPIENTRY
1180 _save_OBE_MultiDrawArrays(GLenum mode
, const GLint
*first
,
1181 const GLsizei
*count
, GLsizei primcount
)
1183 GET_CURRENT_CONTEXT(ctx
);
1186 if (!_mesa_is_valid_prim_mode(ctx
, mode
)) {
1187 _mesa_compile_error(ctx
, GL_INVALID_ENUM
, "glMultiDrawArrays(mode)");
1191 if (primcount
< 0) {
1192 _mesa_compile_error(ctx
, GL_INVALID_VALUE
,
1193 "glMultiDrawArrays(primcount<0)");
1197 for (i
= 0; i
< primcount
; i
++) {
1199 _mesa_compile_error(ctx
, GL_INVALID_VALUE
,
1200 "glMultiDrawArrays(count[i]<0)");
1205 for (i
= 0; i
< primcount
; i
++) {
1207 _save_OBE_DrawArrays(mode
, first
[i
], count
[i
]);
1213 /* Could do better by copying the arrays and element list intact and
1214 * then emitting an indexed prim at runtime.
1216 static void GLAPIENTRY
1217 _save_OBE_DrawElementsBaseVertex(GLenum mode
, GLsizei count
, GLenum type
,
1218 const GLvoid
* indices
, GLint basevertex
)
1220 GET_CURRENT_CONTEXT(ctx
);
1221 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
1222 struct gl_buffer_object
*indexbuf
= ctx
->Array
.VAO
->IndexBufferObj
;
1225 if (!_mesa_is_valid_prim_mode(ctx
, mode
)) {
1226 _mesa_compile_error(ctx
, GL_INVALID_ENUM
, "glDrawElements(mode)");
1230 _mesa_compile_error(ctx
, GL_INVALID_VALUE
, "glDrawElements(count<0)");
1233 if (type
!= GL_UNSIGNED_BYTE
&&
1234 type
!= GL_UNSIGNED_SHORT
&&
1235 type
!= GL_UNSIGNED_INT
) {
1236 _mesa_compile_error(ctx
, GL_INVALID_VALUE
, "glDrawElements(count<0)");
1240 if (save
->out_of_memory
)
1243 /* Make sure to process any VBO binding changes */
1244 _mesa_update_state(ctx
);
1248 if (_mesa_is_bufferobj(indexbuf
))
1250 ADD_POINTERS(indexbuf
->Mappings
[MAP_INTERNAL
].Pointer
, indices
);
1252 vbo_save_NotifyBegin(ctx
, (mode
| VBO_SAVE_PRIM_WEAK
|
1253 VBO_SAVE_PRIM_NO_CURRENT_UPDATE
));
1256 case GL_UNSIGNED_BYTE
:
1257 for (i
= 0; i
< count
; i
++)
1258 CALL_ArrayElement(GET_DISPATCH(), (basevertex
+ ((GLubyte
*) indices
)[i
]));
1260 case GL_UNSIGNED_SHORT
:
1261 for (i
= 0; i
< count
; i
++)
1262 CALL_ArrayElement(GET_DISPATCH(), (basevertex
+ ((GLushort
*) indices
)[i
]));
1264 case GL_UNSIGNED_INT
:
1265 for (i
= 0; i
< count
; i
++)
1266 CALL_ArrayElement(GET_DISPATCH(), (basevertex
+ ((GLuint
*) indices
)[i
]));
1269 _mesa_error(ctx
, GL_INVALID_ENUM
, "glDrawElements(type)");
1273 CALL_End(GET_DISPATCH(), ());
1275 _ae_unmap_vbos(ctx
);
1278 static void GLAPIENTRY
1279 _save_OBE_DrawElements(GLenum mode
, GLsizei count
, GLenum type
,
1280 const GLvoid
* indices
)
1282 _save_OBE_DrawElementsBaseVertex(mode
, count
, type
, indices
, 0);
1286 static void GLAPIENTRY
1287 _save_OBE_DrawRangeElements(GLenum mode
, GLuint start
, GLuint end
,
1288 GLsizei count
, GLenum type
,
1289 const GLvoid
* indices
)
1291 GET_CURRENT_CONTEXT(ctx
);
1292 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
1294 if (!_mesa_is_valid_prim_mode(ctx
, mode
)) {
1295 _mesa_compile_error(ctx
, GL_INVALID_ENUM
, "glDrawRangeElements(mode)");
1299 _mesa_compile_error(ctx
, GL_INVALID_VALUE
,
1300 "glDrawRangeElements(count<0)");
1303 if (type
!= GL_UNSIGNED_BYTE
&&
1304 type
!= GL_UNSIGNED_SHORT
&&
1305 type
!= GL_UNSIGNED_INT
) {
1306 _mesa_compile_error(ctx
, GL_INVALID_ENUM
, "glDrawRangeElements(type)");
1310 _mesa_compile_error(ctx
, GL_INVALID_VALUE
,
1311 "glDrawRangeElements(end < start)");
1315 if (save
->out_of_memory
)
1318 _save_OBE_DrawElements(mode
, count
, type
, indices
);
1322 static void GLAPIENTRY
1323 _save_OBE_MultiDrawElements(GLenum mode
, const GLsizei
*count
, GLenum type
,
1324 const GLvoid
* const *indices
, GLsizei primcount
)
1328 for (i
= 0; i
< primcount
; i
++) {
1330 CALL_DrawElements(GET_DISPATCH(), (mode
, count
[i
], type
, indices
[i
]));
1336 static void GLAPIENTRY
1337 _save_OBE_MultiDrawElementsBaseVertex(GLenum mode
, const GLsizei
*count
,
1339 const GLvoid
* const *indices
,
1341 const GLint
*basevertex
)
1345 for (i
= 0; i
< primcount
; i
++) {
1347 CALL_DrawElementsBaseVertex(GET_DISPATCH(), (mode
, count
[i
], type
,
1356 _save_vtxfmt_init(struct gl_context
*ctx
)
1358 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
1359 GLvertexformat
*vfmt
= &save
->vtxfmt
;
1361 vfmt
->ArrayElement
= _ae_ArrayElement
;
1363 vfmt
->Color3f
= _save_Color3f
;
1364 vfmt
->Color3fv
= _save_Color3fv
;
1365 vfmt
->Color4f
= _save_Color4f
;
1366 vfmt
->Color4fv
= _save_Color4fv
;
1367 vfmt
->EdgeFlag
= _save_EdgeFlag
;
1368 vfmt
->End
= _save_End
;
1369 vfmt
->PrimitiveRestartNV
= _save_PrimitiveRestartNV
;
1370 vfmt
->FogCoordfEXT
= _save_FogCoordfEXT
;
1371 vfmt
->FogCoordfvEXT
= _save_FogCoordfvEXT
;
1372 vfmt
->Indexf
= _save_Indexf
;
1373 vfmt
->Indexfv
= _save_Indexfv
;
1374 vfmt
->Materialfv
= _save_Materialfv
;
1375 vfmt
->MultiTexCoord1fARB
= _save_MultiTexCoord1f
;
1376 vfmt
->MultiTexCoord1fvARB
= _save_MultiTexCoord1fv
;
1377 vfmt
->MultiTexCoord2fARB
= _save_MultiTexCoord2f
;
1378 vfmt
->MultiTexCoord2fvARB
= _save_MultiTexCoord2fv
;
1379 vfmt
->MultiTexCoord3fARB
= _save_MultiTexCoord3f
;
1380 vfmt
->MultiTexCoord3fvARB
= _save_MultiTexCoord3fv
;
1381 vfmt
->MultiTexCoord4fARB
= _save_MultiTexCoord4f
;
1382 vfmt
->MultiTexCoord4fvARB
= _save_MultiTexCoord4fv
;
1383 vfmt
->Normal3f
= _save_Normal3f
;
1384 vfmt
->Normal3fv
= _save_Normal3fv
;
1385 vfmt
->SecondaryColor3fEXT
= _save_SecondaryColor3fEXT
;
1386 vfmt
->SecondaryColor3fvEXT
= _save_SecondaryColor3fvEXT
;
1387 vfmt
->TexCoord1f
= _save_TexCoord1f
;
1388 vfmt
->TexCoord1fv
= _save_TexCoord1fv
;
1389 vfmt
->TexCoord2f
= _save_TexCoord2f
;
1390 vfmt
->TexCoord2fv
= _save_TexCoord2fv
;
1391 vfmt
->TexCoord3f
= _save_TexCoord3f
;
1392 vfmt
->TexCoord3fv
= _save_TexCoord3fv
;
1393 vfmt
->TexCoord4f
= _save_TexCoord4f
;
1394 vfmt
->TexCoord4fv
= _save_TexCoord4fv
;
1395 vfmt
->Vertex2f
= _save_Vertex2f
;
1396 vfmt
->Vertex2fv
= _save_Vertex2fv
;
1397 vfmt
->Vertex3f
= _save_Vertex3f
;
1398 vfmt
->Vertex3fv
= _save_Vertex3fv
;
1399 vfmt
->Vertex4f
= _save_Vertex4f
;
1400 vfmt
->Vertex4fv
= _save_Vertex4fv
;
1401 vfmt
->VertexAttrib1fARB
= _save_VertexAttrib1fARB
;
1402 vfmt
->VertexAttrib1fvARB
= _save_VertexAttrib1fvARB
;
1403 vfmt
->VertexAttrib2fARB
= _save_VertexAttrib2fARB
;
1404 vfmt
->VertexAttrib2fvARB
= _save_VertexAttrib2fvARB
;
1405 vfmt
->VertexAttrib3fARB
= _save_VertexAttrib3fARB
;
1406 vfmt
->VertexAttrib3fvARB
= _save_VertexAttrib3fvARB
;
1407 vfmt
->VertexAttrib4fARB
= _save_VertexAttrib4fARB
;
1408 vfmt
->VertexAttrib4fvARB
= _save_VertexAttrib4fvARB
;
1410 vfmt
->VertexAttrib1fNV
= _save_VertexAttrib1fNV
;
1411 vfmt
->VertexAttrib1fvNV
= _save_VertexAttrib1fvNV
;
1412 vfmt
->VertexAttrib2fNV
= _save_VertexAttrib2fNV
;
1413 vfmt
->VertexAttrib2fvNV
= _save_VertexAttrib2fvNV
;
1414 vfmt
->VertexAttrib3fNV
= _save_VertexAttrib3fNV
;
1415 vfmt
->VertexAttrib3fvNV
= _save_VertexAttrib3fvNV
;
1416 vfmt
->VertexAttrib4fNV
= _save_VertexAttrib4fNV
;
1417 vfmt
->VertexAttrib4fvNV
= _save_VertexAttrib4fvNV
;
1419 /* integer-valued */
1420 vfmt
->VertexAttribI1i
= _save_VertexAttribI1i
;
1421 vfmt
->VertexAttribI2i
= _save_VertexAttribI2i
;
1422 vfmt
->VertexAttribI3i
= _save_VertexAttribI3i
;
1423 vfmt
->VertexAttribI4i
= _save_VertexAttribI4i
;
1424 vfmt
->VertexAttribI2iv
= _save_VertexAttribI2iv
;
1425 vfmt
->VertexAttribI3iv
= _save_VertexAttribI3iv
;
1426 vfmt
->VertexAttribI4iv
= _save_VertexAttribI4iv
;
1428 /* unsigned integer-valued */
1429 vfmt
->VertexAttribI1ui
= _save_VertexAttribI1ui
;
1430 vfmt
->VertexAttribI2ui
= _save_VertexAttribI2ui
;
1431 vfmt
->VertexAttribI3ui
= _save_VertexAttribI3ui
;
1432 vfmt
->VertexAttribI4ui
= _save_VertexAttribI4ui
;
1433 vfmt
->VertexAttribI2uiv
= _save_VertexAttribI2uiv
;
1434 vfmt
->VertexAttribI3uiv
= _save_VertexAttribI3uiv
;
1435 vfmt
->VertexAttribI4uiv
= _save_VertexAttribI4uiv
;
1437 vfmt
->VertexP2ui
= _save_VertexP2ui
;
1438 vfmt
->VertexP3ui
= _save_VertexP3ui
;
1439 vfmt
->VertexP4ui
= _save_VertexP4ui
;
1440 vfmt
->VertexP2uiv
= _save_VertexP2uiv
;
1441 vfmt
->VertexP3uiv
= _save_VertexP3uiv
;
1442 vfmt
->VertexP4uiv
= _save_VertexP4uiv
;
1444 vfmt
->TexCoordP1ui
= _save_TexCoordP1ui
;
1445 vfmt
->TexCoordP2ui
= _save_TexCoordP2ui
;
1446 vfmt
->TexCoordP3ui
= _save_TexCoordP3ui
;
1447 vfmt
->TexCoordP4ui
= _save_TexCoordP4ui
;
1448 vfmt
->TexCoordP1uiv
= _save_TexCoordP1uiv
;
1449 vfmt
->TexCoordP2uiv
= _save_TexCoordP2uiv
;
1450 vfmt
->TexCoordP3uiv
= _save_TexCoordP3uiv
;
1451 vfmt
->TexCoordP4uiv
= _save_TexCoordP4uiv
;
1453 vfmt
->MultiTexCoordP1ui
= _save_MultiTexCoordP1ui
;
1454 vfmt
->MultiTexCoordP2ui
= _save_MultiTexCoordP2ui
;
1455 vfmt
->MultiTexCoordP3ui
= _save_MultiTexCoordP3ui
;
1456 vfmt
->MultiTexCoordP4ui
= _save_MultiTexCoordP4ui
;
1457 vfmt
->MultiTexCoordP1uiv
= _save_MultiTexCoordP1uiv
;
1458 vfmt
->MultiTexCoordP2uiv
= _save_MultiTexCoordP2uiv
;
1459 vfmt
->MultiTexCoordP3uiv
= _save_MultiTexCoordP3uiv
;
1460 vfmt
->MultiTexCoordP4uiv
= _save_MultiTexCoordP4uiv
;
1462 vfmt
->NormalP3ui
= _save_NormalP3ui
;
1463 vfmt
->NormalP3uiv
= _save_NormalP3uiv
;
1465 vfmt
->ColorP3ui
= _save_ColorP3ui
;
1466 vfmt
->ColorP4ui
= _save_ColorP4ui
;
1467 vfmt
->ColorP3uiv
= _save_ColorP3uiv
;
1468 vfmt
->ColorP4uiv
= _save_ColorP4uiv
;
1470 vfmt
->SecondaryColorP3ui
= _save_SecondaryColorP3ui
;
1471 vfmt
->SecondaryColorP3uiv
= _save_SecondaryColorP3uiv
;
1473 vfmt
->VertexAttribP1ui
= _save_VertexAttribP1ui
;
1474 vfmt
->VertexAttribP2ui
= _save_VertexAttribP2ui
;
1475 vfmt
->VertexAttribP3ui
= _save_VertexAttribP3ui
;
1476 vfmt
->VertexAttribP4ui
= _save_VertexAttribP4ui
;
1478 vfmt
->VertexAttribP1uiv
= _save_VertexAttribP1uiv
;
1479 vfmt
->VertexAttribP2uiv
= _save_VertexAttribP2uiv
;
1480 vfmt
->VertexAttribP3uiv
= _save_VertexAttribP3uiv
;
1481 vfmt
->VertexAttribP4uiv
= _save_VertexAttribP4uiv
;
1483 vfmt
->VertexAttribL1d
= _save_VertexAttribL1d
;
1484 vfmt
->VertexAttribL2d
= _save_VertexAttribL2d
;
1485 vfmt
->VertexAttribL3d
= _save_VertexAttribL3d
;
1486 vfmt
->VertexAttribL4d
= _save_VertexAttribL4d
;
1488 vfmt
->VertexAttribL1dv
= _save_VertexAttribL1dv
;
1489 vfmt
->VertexAttribL2dv
= _save_VertexAttribL2dv
;
1490 vfmt
->VertexAttribL3dv
= _save_VertexAttribL3dv
;
1491 vfmt
->VertexAttribL4dv
= _save_VertexAttribL4dv
;
1493 vfmt
->VertexAttribL1ui64ARB
= _save_VertexAttribL1ui64ARB
;
1494 vfmt
->VertexAttribL1ui64vARB
= _save_VertexAttribL1ui64vARB
;
1496 /* This will all require us to fallback to saving the list as opcodes:
1498 vfmt
->CallList
= _save_CallList
;
1499 vfmt
->CallLists
= _save_CallLists
;
1501 vfmt
->EvalCoord1f
= _save_EvalCoord1f
;
1502 vfmt
->EvalCoord1fv
= _save_EvalCoord1fv
;
1503 vfmt
->EvalCoord2f
= _save_EvalCoord2f
;
1504 vfmt
->EvalCoord2fv
= _save_EvalCoord2fv
;
1505 vfmt
->EvalPoint1
= _save_EvalPoint1
;
1506 vfmt
->EvalPoint2
= _save_EvalPoint2
;
1508 /* These calls all generate GL_INVALID_OPERATION since this vtxfmt is
1509 * only used when we're inside a glBegin/End pair.
1511 vfmt
->Begin
= _save_Begin
;
1516 * Initialize the dispatch table with the VBO functions for display
1520 vbo_initialize_save_dispatch(const struct gl_context
*ctx
,
1521 struct _glapi_table
*exec
)
1523 SET_DrawArrays(exec
, _save_OBE_DrawArrays
);
1524 SET_MultiDrawArrays(exec
, _save_OBE_MultiDrawArrays
);
1525 SET_DrawElements(exec
, _save_OBE_DrawElements
);
1526 SET_DrawElementsBaseVertex(exec
, _save_OBE_DrawElementsBaseVertex
);
1527 SET_DrawRangeElements(exec
, _save_OBE_DrawRangeElements
);
1528 SET_MultiDrawElementsEXT(exec
, _save_OBE_MultiDrawElements
);
1529 SET_MultiDrawElementsBaseVertex(exec
, _save_OBE_MultiDrawElementsBaseVertex
);
1530 SET_Rectf(exec
, _save_OBE_Rectf
);
1531 /* Note: other glDraw functins aren't compiled into display lists */
1537 vbo_save_SaveFlushVertices(struct gl_context
*ctx
)
1539 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
1541 /* Noop when we are actually active:
1543 if (ctx
->Driver
.CurrentSavePrimitive
<= PRIM_MAX
)
1546 if (save
->vert_count
|| save
->prim_count
)
1547 _save_compile_vertex_list(ctx
);
1549 _save_copy_to_current(ctx
);
1550 _save_reset_vertex(ctx
);
1551 _save_reset_counters(ctx
);
1552 ctx
->Driver
.SaveNeedFlush
= GL_FALSE
;
1557 vbo_save_NewList(struct gl_context
*ctx
, GLuint list
, GLenum mode
)
1559 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
1564 if (!save
->prim_store
)
1565 save
->prim_store
= alloc_prim_store(ctx
);
1567 if (!save
->vertex_store
)
1568 save
->vertex_store
= alloc_vertex_store(ctx
);
1570 save
->buffer_ptr
= vbo_save_map_vertex_store(ctx
, save
->vertex_store
);
1572 _save_reset_vertex(ctx
);
1573 _save_reset_counters(ctx
);
1574 ctx
->Driver
.SaveNeedFlush
= GL_FALSE
;
1579 vbo_save_EndList(struct gl_context
*ctx
)
1581 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
1583 /* EndList called inside a (saved) Begin/End pair?
1585 if (_mesa_inside_dlist_begin_end(ctx
)) {
1586 if (save
->prim_count
> 0) {
1587 GLint i
= save
->prim_count
- 1;
1588 ctx
->Driver
.CurrentSavePrimitive
= PRIM_OUTSIDE_BEGIN_END
;
1589 save
->prim
[i
].end
= 0;
1590 save
->prim
[i
].count
= save
->vert_count
- save
->prim
[i
].start
;
1593 /* Make sure this vertex list gets replayed by the "loopback"
1596 save
->dangling_attr_ref
= GL_TRUE
;
1597 vbo_save_SaveFlushVertices(ctx
);
1599 /* Swap out this vertex format while outside begin/end. Any color,
1600 * etc. received between here and the next begin will be compiled
1603 _mesa_install_save_vtxfmt(ctx
, &ctx
->ListState
.ListVtxfmt
);
1606 vbo_save_unmap_vertex_store(ctx
, save
->vertex_store
);
1608 assert(save
->vertex_size
== 0);
1613 vbo_save_BeginCallList(struct gl_context
*ctx
, struct gl_display_list
*dlist
)
1615 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
1616 save
->replay_flags
|= dlist
->Flags
;
1621 vbo_save_EndCallList(struct gl_context
*ctx
)
1623 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
1625 if (ctx
->ListState
.CallDepth
== 1) {
1626 /* This is correct: want to keep only the VBO_SAVE_FALLBACK
1627 * flag, if it is set:
1629 save
->replay_flags
&= VBO_SAVE_FALLBACK
;
1635 vbo_destroy_vertex_list(struct gl_context
*ctx
, void *data
)
1637 struct vbo_save_vertex_list
*node
= (struct vbo_save_vertex_list
*) data
;
1640 if (--node
->vertex_store
->refcount
== 0)
1641 free_vertex_store(ctx
, node
->vertex_store
);
1643 if (--node
->prim_store
->refcount
== 0)
1644 free(node
->prim_store
);
1646 free(node
->current_data
);
1647 node
->current_data
= NULL
;
1652 vbo_print_vertex_list(struct gl_context
*ctx
, void *data
, FILE *f
)
1654 struct vbo_save_vertex_list
*node
= (struct vbo_save_vertex_list
*) data
;
1656 struct gl_buffer_object
*buffer
= node
->vertex_store
?
1657 node
->vertex_store
->bufferobj
: NULL
;
1660 fprintf(f
, "VBO-VERTEX-LIST, %u vertices, %d primitives, %d vertsize, "
1662 node
->count
, node
->prim_count
, node
->vertex_size
,
1665 for (i
= 0; i
< node
->prim_count
; i
++) {
1666 struct _mesa_prim
*prim
= &node
->prim
[i
];
1667 fprintf(f
, " prim %d: %s%s %d..%d %s %s\n",
1669 _mesa_lookup_prim_by_nr(prim
->mode
),
1670 prim
->weak
? " (weak)" : "",
1672 prim
->start
+ prim
->count
,
1673 (prim
->begin
) ? "BEGIN" : "(wrap)",
1674 (prim
->end
) ? "END" : "(wrap)");
1680 * Called during context creation/init.
1683 _save_current_init(struct gl_context
*ctx
)
1685 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
1688 for (i
= VBO_ATTRIB_POS
; i
<= VBO_ATTRIB_GENERIC15
; i
++) {
1689 const GLuint j
= i
- VBO_ATTRIB_POS
;
1690 assert(j
< VERT_ATTRIB_MAX
);
1691 save
->currentsz
[i
] = &ctx
->ListState
.ActiveAttribSize
[j
];
1692 save
->current
[i
] = (fi_type
*) ctx
->ListState
.CurrentAttrib
[j
];
1695 for (i
= VBO_ATTRIB_FIRST_MATERIAL
; i
<= VBO_ATTRIB_LAST_MATERIAL
; i
++) {
1696 const GLuint j
= i
- VBO_ATTRIB_FIRST_MATERIAL
;
1697 assert(j
< MAT_ATTRIB_MAX
);
1698 save
->currentsz
[i
] = &ctx
->ListState
.ActiveMaterialSize
[j
];
1699 save
->current
[i
] = (fi_type
*) ctx
->ListState
.CurrentMaterial
[j
];
1705 * Initialize the display list compiler. Called during context creation.
1708 vbo_save_api_init(struct vbo_save_context
*save
)
1710 struct gl_context
*ctx
= save
->ctx
;
1713 save
->opcode_vertex_list
=
1714 _mesa_dlist_alloc_opcode(ctx
,
1715 sizeof(struct vbo_save_vertex_list
),
1716 vbo_save_playback_vertex_list
,
1717 vbo_destroy_vertex_list
,
1718 vbo_print_vertex_list
);
1720 _save_vtxfmt_init(ctx
);
1721 _save_current_init(ctx
);
1722 _mesa_noop_vtxfmt_init(&save
->vtxfmt_noop
);
1724 /* These will actually get set again when binding/drawing */
1725 for (i
= 0; i
< VBO_ATTRIB_MAX
; i
++)
1726 save
->inputs
[i
] = &save
->arrays
[i
];