1 /**************************************************************************
3 Copyright 2002-2008 Tungsten Graphics Inc., Cedar Park, Texas.
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 TUNGSTEN GRAPHICS 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 <keith@tungstengraphics.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"
82 #include "vbo_context.h"
91 /* An interesting VBO number/name to help with debugging */
92 #define VBO_BUF_ID 12345
96 * NOTE: Old 'parity' issue is gone, but copying can still be
97 * wrong-footed on replay.
100 _save_copy_vertices(struct gl_context
*ctx
,
101 const struct vbo_save_vertex_list
*node
,
102 const GLfloat
* src_buffer
)
104 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
105 const struct _mesa_prim
*prim
= &node
->prim
[node
->prim_count
- 1];
106 GLuint nr
= prim
->count
;
107 GLuint sz
= save
->vertex_size
;
108 const GLfloat
*src
= src_buffer
+ prim
->start
* sz
;
109 GLfloat
*dst
= save
->copied
.buffer
;
115 switch (prim
->mode
) {
120 for (i
= 0; i
< ovf
; i
++)
121 memcpy(dst
+ i
* sz
, src
+ (nr
- ovf
+ i
) * sz
,
122 sz
* sizeof(GLfloat
));
126 for (i
= 0; i
< ovf
; i
++)
127 memcpy(dst
+ i
* sz
, src
+ (nr
- ovf
+ i
) * sz
,
128 sz
* sizeof(GLfloat
));
132 for (i
= 0; i
< ovf
; i
++)
133 memcpy(dst
+ i
* sz
, src
+ (nr
- ovf
+ i
) * sz
,
134 sz
* sizeof(GLfloat
));
140 memcpy(dst
, src
+ (nr
- 1) * sz
, sz
* sizeof(GLfloat
));
144 case GL_TRIANGLE_FAN
:
149 memcpy(dst
, src
+ 0, sz
* sizeof(GLfloat
));
153 memcpy(dst
, src
+ 0, sz
* sizeof(GLfloat
));
154 memcpy(dst
+ sz
, src
+ (nr
- 1) * sz
, sz
* sizeof(GLfloat
));
157 case GL_TRIANGLE_STRIP
:
170 for (i
= 0; i
< ovf
; i
++)
171 memcpy(dst
+ i
* sz
, src
+ (nr
- ovf
+ i
) * sz
,
172 sz
* sizeof(GLfloat
));
181 static struct vbo_save_vertex_store
*
182 alloc_vertex_store(struct gl_context
*ctx
)
184 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
185 struct vbo_save_vertex_store
*vertex_store
=
186 CALLOC_STRUCT(vbo_save_vertex_store
);
188 /* obj->Name needs to be non-zero, but won't ever be examined more
189 * closely than that. In particular these buffers won't be entered
190 * into the hash and can never be confused with ones visible to the
191 * user. Perhaps there could be a special number for internal
194 vertex_store
->bufferobj
= ctx
->Driver
.NewBufferObject(ctx
,
196 GL_ARRAY_BUFFER_ARB
);
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
,
203 vertex_store
->bufferobj
);
206 save
->out_of_memory
= GL_TRUE
;
209 if (save
->out_of_memory
) {
210 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "internal VBO allocation");
211 _mesa_install_save_vtxfmt(ctx
, &save
->vtxfmt_noop
);
214 vertex_store
->buffer
= NULL
;
215 vertex_store
->used
= 0;
216 vertex_store
->refcount
= 1;
223 free_vertex_store(struct gl_context
*ctx
,
224 struct vbo_save_vertex_store
*vertex_store
)
226 assert(!vertex_store
->buffer
);
228 if (vertex_store
->bufferobj
) {
229 _mesa_reference_buffer_object(ctx
, &vertex_store
->bufferobj
, NULL
);
237 vbo_save_map_vertex_store(struct gl_context
*ctx
,
238 struct vbo_save_vertex_store
*vertex_store
)
240 assert(vertex_store
->bufferobj
);
241 assert(!vertex_store
->buffer
);
242 if (vertex_store
->bufferobj
->Size
> 0) {
243 vertex_store
->buffer
=
244 (GLfloat
*) ctx
->Driver
.MapBufferRange(ctx
, 0,
245 vertex_store
->bufferobj
->Size
,
246 GL_MAP_WRITE_BIT
, /* not used */
247 vertex_store
->bufferobj
);
248 assert(vertex_store
->buffer
);
249 return vertex_store
->buffer
+ vertex_store
->used
;
252 /* probably ran out of memory for buffers */
259 vbo_save_unmap_vertex_store(struct gl_context
*ctx
,
260 struct vbo_save_vertex_store
*vertex_store
)
262 if (vertex_store
->bufferobj
->Size
> 0) {
263 ctx
->Driver
.UnmapBuffer(ctx
, vertex_store
->bufferobj
);
265 vertex_store
->buffer
= NULL
;
269 static struct vbo_save_primitive_store
*
270 alloc_prim_store(struct gl_context
*ctx
)
272 struct vbo_save_primitive_store
*store
=
273 CALLOC_STRUCT(vbo_save_primitive_store
);
282 _save_reset_counters(struct gl_context
*ctx
)
284 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
286 save
->prim
= save
->prim_store
->buffer
+ save
->prim_store
->used
;
287 save
->buffer
= save
->vertex_store
->buffer
+ save
->vertex_store
->used
;
289 assert(save
->buffer
== save
->buffer_ptr
);
291 if (save
->vertex_size
)
292 save
->max_vert
= ((VBO_SAVE_BUFFER_SIZE
- save
->vertex_store
->used
) /
297 save
->vert_count
= 0;
298 save
->prim_count
= 0;
299 save
->prim_max
= VBO_SAVE_PRIM_SIZE
- save
->prim_store
->used
;
300 save
->dangling_attr_ref
= 0;
304 * For a list of prims, try merging prims that can just be extensions of the
308 vbo_merge_prims(struct gl_context
*ctx
,
309 struct _mesa_prim
*prim_list
,
313 struct _mesa_prim
*prev_prim
= prim_list
;
315 for (i
= 1; i
< *prim_count
; i
++) {
316 struct _mesa_prim
*this_prim
= prim_list
+ i
;
318 if (this_prim
->mode
== prev_prim
->mode
&&
319 this_prim
->mode
== GL_QUADS
&&
320 this_prim
->count
% 4 == 0 &&
321 prev_prim
->count
% 4 == 0 &&
322 this_prim
->start
== prev_prim
->start
+ prev_prim
->count
&&
323 this_prim
->basevertex
== prev_prim
->basevertex
&&
324 this_prim
->num_instances
== prev_prim
->num_instances
&&
325 this_prim
->base_instance
== prev_prim
->base_instance
) {
326 /* We've found a prim that just extend the previous one. Tack it
327 * onto the previous one, and let this primitive struct get dropped.
329 prev_prim
->count
+= this_prim
->count
;
330 prev_prim
->end
= this_prim
->end
;
334 /* If any previous primitives have been dropped, then we need to copy
335 * this later one into the next available slot.
338 if (prev_prim
!= this_prim
)
339 *prev_prim
= *this_prim
;
342 *prim_count
= prev_prim
- prim_list
+ 1;
346 * Insert the active immediate struct onto the display list currently
350 _save_compile_vertex_list(struct gl_context
*ctx
)
352 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
353 struct vbo_save_vertex_list
*node
;
355 /* Allocate space for this structure in the display list currently
358 node
= (struct vbo_save_vertex_list
*)
359 _mesa_dlist_alloc(ctx
, save
->opcode_vertex_list
, sizeof(*node
));
364 /* Duplicate our template, increment refcounts to the storage structs:
366 memcpy(node
->attrsz
, save
->attrsz
, sizeof(node
->attrsz
));
367 memcpy(node
->attrtype
, save
->attrtype
, sizeof(node
->attrtype
));
368 node
->vertex_size
= save
->vertex_size
;
369 node
->buffer_offset
=
370 (save
->buffer
- save
->vertex_store
->buffer
) * sizeof(GLfloat
);
371 node
->count
= save
->vert_count
;
372 node
->wrap_count
= save
->copied
.nr
;
373 node
->dangling_attr_ref
= save
->dangling_attr_ref
;
374 node
->prim
= save
->prim
;
375 node
->prim_count
= save
->prim_count
;
376 node
->vertex_store
= save
->vertex_store
;
377 node
->prim_store
= save
->prim_store
;
379 node
->vertex_store
->refcount
++;
380 node
->prim_store
->refcount
++;
382 if (node
->prim
[0].no_current_update
) {
383 node
->current_size
= 0;
384 node
->current_data
= NULL
;
387 node
->current_size
= node
->vertex_size
- node
->attrsz
[0];
388 node
->current_data
= NULL
;
390 if (node
->current_size
) {
391 /* If the malloc fails, we just pull the data out of the VBO
394 node
->current_data
= malloc(node
->current_size
* sizeof(GLfloat
));
395 if (node
->current_data
) {
396 const char *buffer
= (const char *) save
->vertex_store
->buffer
;
397 unsigned attr_offset
= node
->attrsz
[0] * sizeof(GLfloat
);
398 unsigned vertex_offset
= 0;
402 (node
->count
- 1) * node
->vertex_size
* sizeof(GLfloat
);
404 memcpy(node
->current_data
,
405 buffer
+ node
->buffer_offset
+ vertex_offset
+ attr_offset
,
406 node
->current_size
* sizeof(GLfloat
));
411 assert(node
->attrsz
[VBO_ATTRIB_POS
] != 0 || node
->count
== 0);
413 if (save
->dangling_attr_ref
)
414 ctx
->ListState
.CurrentList
->Flags
|= DLIST_DANGLING_REFS
;
416 save
->vertex_store
->used
+= save
->vertex_size
* node
->count
;
417 save
->prim_store
->used
+= node
->prim_count
;
419 /* Copy duplicated vertices
421 save
->copied
.nr
= _save_copy_vertices(ctx
, node
, save
->buffer
);
423 vbo_merge_prims(ctx
, node
->prim
, &node
->prim_count
);
425 /* Deal with GL_COMPILE_AND_EXECUTE:
427 if (ctx
->ExecuteFlag
) {
428 struct _glapi_table
*dispatch
= GET_DISPATCH();
430 _glapi_set_dispatch(ctx
->Exec
);
432 vbo_loopback_vertex_list(ctx
,
433 (const GLfloat
*) ((const char *) save
->
434 vertex_store
->buffer
+
435 node
->buffer_offset
),
436 node
->attrsz
, node
->prim
, node
->prim_count
,
437 node
->wrap_count
, node
->vertex_size
);
439 _glapi_set_dispatch(dispatch
);
442 /* Decide whether the storage structs are full, or can be used for
443 * the next vertex lists as well.
445 if (save
->vertex_store
->used
>
446 VBO_SAVE_BUFFER_SIZE
- 16 * (save
->vertex_size
+ 4)) {
450 vbo_save_unmap_vertex_store(ctx
, save
->vertex_store
);
452 /* Release old reference:
454 save
->vertex_store
->refcount
--;
455 assert(save
->vertex_store
->refcount
!= 0);
456 save
->vertex_store
= NULL
;
458 /* Allocate and map new store:
460 save
->vertex_store
= alloc_vertex_store(ctx
);
461 save
->buffer_ptr
= vbo_save_map_vertex_store(ctx
, save
->vertex_store
);
462 save
->out_of_memory
= save
->buffer_ptr
== NULL
;
465 if (save
->prim_store
->used
> VBO_SAVE_PRIM_SIZE
- 6) {
466 save
->prim_store
->refcount
--;
467 assert(save
->prim_store
->refcount
!= 0);
468 save
->prim_store
= alloc_prim_store(ctx
);
471 /* Reset our structures for the next run of vertices:
473 _save_reset_counters(ctx
);
478 * TODO -- If no new vertices have been stored, don't bother saving it.
481 _save_wrap_buffers(struct gl_context
*ctx
)
483 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
484 GLint i
= save
->prim_count
- 1;
487 GLboolean no_current_update
;
489 assert(i
< (GLint
) save
->prim_max
);
492 /* Close off in-progress primitive.
494 save
->prim
[i
].count
= (save
->vert_count
- save
->prim
[i
].start
);
495 mode
= save
->prim
[i
].mode
;
496 weak
= save
->prim
[i
].weak
;
497 no_current_update
= save
->prim
[i
].no_current_update
;
499 /* store the copied vertices, and allocate a new list.
501 _save_compile_vertex_list(ctx
);
503 /* Restart interrupted primitive
505 save
->prim
[0].mode
= mode
;
506 save
->prim
[0].weak
= weak
;
507 save
->prim
[0].no_current_update
= no_current_update
;
508 save
->prim
[0].begin
= 0;
509 save
->prim
[0].end
= 0;
510 save
->prim
[0].pad
= 0;
511 save
->prim
[0].start
= 0;
512 save
->prim
[0].count
= 0;
513 save
->prim
[0].num_instances
= 1;
514 save
->prim
[0].base_instance
= 0;
515 save
->prim_count
= 1;
520 * Called only when buffers are wrapped as the result of filling the
521 * vertex_store struct.
524 _save_wrap_filled_vertex(struct gl_context
*ctx
)
526 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
527 GLfloat
*data
= save
->copied
.buffer
;
530 /* Emit a glEnd to close off the last vertex list.
532 _save_wrap_buffers(ctx
);
534 /* Copy stored stored vertices to start of new list.
536 assert(save
->max_vert
- save
->vert_count
> save
->copied
.nr
);
538 for (i
= 0; i
< save
->copied
.nr
; i
++) {
539 memcpy(save
->buffer_ptr
, data
, save
->vertex_size
* sizeof(GLfloat
));
540 data
+= save
->vertex_size
;
541 save
->buffer_ptr
+= save
->vertex_size
;
548 _save_copy_to_current(struct gl_context
*ctx
)
550 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
553 for (i
= VBO_ATTRIB_POS
+ 1; i
< VBO_ATTRIB_MAX
; i
++) {
554 if (save
->attrsz
[i
]) {
555 save
->currentsz
[i
][0] = save
->attrsz
[i
];
556 COPY_CLEAN_4V_TYPE_AS_FLOAT(save
->current
[i
], save
->attrsz
[i
],
557 save
->attrptr
[i
], save
->attrtype
[i
]);
564 _save_copy_from_current(struct gl_context
*ctx
)
566 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
569 for (i
= VBO_ATTRIB_POS
+ 1; i
< VBO_ATTRIB_MAX
; i
++) {
570 switch (save
->attrsz
[i
]) {
572 save
->attrptr
[i
][3] = save
->current
[i
][3];
574 save
->attrptr
[i
][2] = save
->current
[i
][2];
576 save
->attrptr
[i
][1] = save
->current
[i
][1];
578 save
->attrptr
[i
][0] = save
->current
[i
][0];
586 /* Flush existing data, set new attrib size, replay copied vertices.
589 _save_upgrade_vertex(struct gl_context
*ctx
, GLuint attr
, GLuint newsz
)
591 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
596 /* Store the current run of vertices, and emit a GL_END. Emit a
597 * BEGIN in the new buffer.
599 if (save
->vert_count
)
600 _save_wrap_buffers(ctx
);
602 assert(save
->copied
.nr
== 0);
604 /* Do a COPY_TO_CURRENT to ensure back-copying works for the case
605 * when the attribute already exists in the vertex and is having
606 * its size increased.
608 _save_copy_to_current(ctx
);
612 oldsz
= save
->attrsz
[attr
];
613 save
->attrsz
[attr
] = newsz
;
615 save
->vertex_size
+= newsz
- oldsz
;
616 save
->max_vert
= ((VBO_SAVE_BUFFER_SIZE
- save
->vertex_store
->used
) /
618 save
->vert_count
= 0;
620 /* Recalculate all the attrptr[] values:
622 for (i
= 0, tmp
= save
->vertex
; i
< VBO_ATTRIB_MAX
; i
++) {
623 if (save
->attrsz
[i
]) {
624 save
->attrptr
[i
] = tmp
;
625 tmp
+= save
->attrsz
[i
];
628 save
->attrptr
[i
] = NULL
; /* will not be dereferenced. */
632 /* Copy from current to repopulate the vertex with correct values.
634 _save_copy_from_current(ctx
);
636 /* Replay stored vertices to translate them to new format here.
638 * If there are copied vertices and the new (upgraded) attribute
639 * has not been defined before, this list is somewhat degenerate,
640 * and will need fixup at runtime.
642 if (save
->copied
.nr
) {
643 GLfloat
*data
= save
->copied
.buffer
;
644 GLfloat
*dest
= save
->buffer
;
647 /* Need to note this and fix up at runtime (or loopback):
649 if (attr
!= VBO_ATTRIB_POS
&& save
->currentsz
[attr
][0] == 0) {
651 save
->dangling_attr_ref
= GL_TRUE
;
654 for (i
= 0; i
< save
->copied
.nr
; i
++) {
655 for (j
= 0; j
< VBO_ATTRIB_MAX
; j
++) {
656 if (save
->attrsz
[j
]) {
659 COPY_CLEAN_4V_TYPE_AS_FLOAT(dest
, oldsz
, data
,
665 COPY_SZ_4V(dest
, newsz
, save
->current
[attr
]);
670 GLint sz
= save
->attrsz
[j
];
671 COPY_SZ_4V(dest
, sz
, data
);
679 save
->buffer_ptr
= dest
;
680 save
->vert_count
+= save
->copied
.nr
;
686 save_fixup_vertex(struct gl_context
*ctx
, GLuint attr
, GLuint sz
)
688 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
690 if (sz
> save
->attrsz
[attr
]) {
691 /* New size is larger. Need to flush existing vertices and get
692 * an enlarged vertex format.
694 _save_upgrade_vertex(ctx
, attr
, sz
);
696 else if (sz
< save
->active_sz
[attr
]) {
698 const GLfloat
*id
= vbo_get_default_vals_as_float(save
->attrtype
[attr
]);
700 /* New size is equal or smaller - just need to fill in some
703 for (i
= sz
; i
<= save
->attrsz
[attr
]; i
++)
704 save
->attrptr
[attr
][i
- 1] = id
[i
- 1];
707 save
->active_sz
[attr
] = sz
;
712 _save_reset_vertex(struct gl_context
*ctx
)
714 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
717 for (i
= 0; i
< VBO_ATTRIB_MAX
; i
++) {
719 save
->active_sz
[i
] = 0;
722 save
->vertex_size
= 0;
727 #define ERROR(err) _mesa_compile_error(ctx, err, __FUNCTION__);
730 /* Only one size for each attribute may be active at once. Eg. if
731 * Color3f is installed/active, then Color4f may not be, even if the
732 * vertex actually contains 4 color coordinates. This is because the
733 * 3f version won't otherwise set color[3] to 1.0 -- this is the job
734 * of the chooser function when switching between Color4f and Color3f.
736 #define ATTR(A, N, T, V0, V1, V2, V3) \
738 struct vbo_save_context *save = &vbo_context(ctx)->save; \
740 if (save->active_sz[A] != N) \
741 save_fixup_vertex(ctx, A, N); \
744 GLfloat *dest = save->attrptr[A]; \
745 if (N>0) dest[0] = V0; \
746 if (N>1) dest[1] = V1; \
747 if (N>2) dest[2] = V2; \
748 if (N>3) dest[3] = V3; \
749 save->attrtype[A] = T; \
755 for (i = 0; i < save->vertex_size; i++) \
756 save->buffer_ptr[i] = save->vertex[i]; \
758 save->buffer_ptr += save->vertex_size; \
760 if (++save->vert_count >= save->max_vert) \
761 _save_wrap_filled_vertex(ctx); \
765 #define TAG(x) _save_##x
767 #include "vbo_attrib_tmp.h"
771 #define MAT( ATTR, N, face, params ) \
773 if (face != GL_BACK) \
774 MAT_ATTR( ATTR, N, params ); /* front */ \
775 if (face != GL_FRONT) \
776 MAT_ATTR( ATTR + 1, N, params ); /* back */ \
781 * Save a glMaterial call found between glBegin/End.
782 * glMaterial calls outside Begin/End are handled in dlist.c.
784 static void GLAPIENTRY
785 _save_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
787 GET_CURRENT_CONTEXT(ctx
);
789 if (face
!= GL_FRONT
&& face
!= GL_BACK
&& face
!= GL_FRONT_AND_BACK
) {
790 _mesa_compile_error(ctx
, GL_INVALID_ENUM
, "glMaterial(face)");
796 MAT(VBO_ATTRIB_MAT_FRONT_EMISSION
, 4, face
, params
);
799 MAT(VBO_ATTRIB_MAT_FRONT_AMBIENT
, 4, face
, params
);
802 MAT(VBO_ATTRIB_MAT_FRONT_DIFFUSE
, 4, face
, params
);
805 MAT(VBO_ATTRIB_MAT_FRONT_SPECULAR
, 4, face
, params
);
808 if (*params
< 0 || *params
> ctx
->Const
.MaxShininess
) {
809 _mesa_compile_error(ctx
, GL_INVALID_VALUE
, "glMaterial(shininess)");
812 MAT(VBO_ATTRIB_MAT_FRONT_SHININESS
, 1, face
, params
);
815 case GL_COLOR_INDEXES
:
816 MAT(VBO_ATTRIB_MAT_FRONT_INDEXES
, 3, face
, params
);
818 case GL_AMBIENT_AND_DIFFUSE
:
819 MAT(VBO_ATTRIB_MAT_FRONT_AMBIENT
, 4, face
, params
);
820 MAT(VBO_ATTRIB_MAT_FRONT_DIFFUSE
, 4, face
, params
);
823 _mesa_compile_error(ctx
, GL_INVALID_ENUM
, "glMaterial(pname)");
829 /* Cope with EvalCoord/CallList called within a begin/end object:
830 * -- Flush current buffer
831 * -- Fallback to opcodes for the rest of the begin/end object.
834 dlist_fallback(struct gl_context
*ctx
)
836 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
838 if (save
->vert_count
|| save
->prim_count
) {
839 if (save
->prim_count
> 0) {
840 /* Close off in-progress primitive. */
841 GLint i
= save
->prim_count
- 1;
842 save
->prim
[i
].count
= save
->vert_count
- save
->prim
[i
].start
;
845 /* Need to replay this display list with loopback,
846 * unfortunately, otherwise this primitive won't be handled
849 save
->dangling_attr_ref
= 1;
851 _save_compile_vertex_list(ctx
);
854 _save_copy_to_current(ctx
);
855 _save_reset_vertex(ctx
);
856 _save_reset_counters(ctx
);
857 if (save
->out_of_memory
) {
858 _mesa_install_save_vtxfmt(ctx
, &save
->vtxfmt_noop
);
861 _mesa_install_save_vtxfmt(ctx
, &ctx
->ListState
.ListVtxfmt
);
863 ctx
->Driver
.SaveNeedFlush
= 0;
867 static void GLAPIENTRY
868 _save_EvalCoord1f(GLfloat u
)
870 GET_CURRENT_CONTEXT(ctx
);
872 CALL_EvalCoord1f(ctx
->Save
, (u
));
875 static void GLAPIENTRY
876 _save_EvalCoord1fv(const GLfloat
* v
)
878 GET_CURRENT_CONTEXT(ctx
);
880 CALL_EvalCoord1fv(ctx
->Save
, (v
));
883 static void GLAPIENTRY
884 _save_EvalCoord2f(GLfloat u
, GLfloat v
)
886 GET_CURRENT_CONTEXT(ctx
);
888 CALL_EvalCoord2f(ctx
->Save
, (u
, v
));
891 static void GLAPIENTRY
892 _save_EvalCoord2fv(const GLfloat
* v
)
894 GET_CURRENT_CONTEXT(ctx
);
896 CALL_EvalCoord2fv(ctx
->Save
, (v
));
899 static void GLAPIENTRY
900 _save_EvalPoint1(GLint i
)
902 GET_CURRENT_CONTEXT(ctx
);
904 CALL_EvalPoint1(ctx
->Save
, (i
));
907 static void GLAPIENTRY
908 _save_EvalPoint2(GLint i
, GLint j
)
910 GET_CURRENT_CONTEXT(ctx
);
912 CALL_EvalPoint2(ctx
->Save
, (i
, j
));
915 static void GLAPIENTRY
916 _save_CallList(GLuint l
)
918 GET_CURRENT_CONTEXT(ctx
);
920 CALL_CallList(ctx
->Save
, (l
));
923 static void GLAPIENTRY
924 _save_CallLists(GLsizei n
, GLenum type
, const GLvoid
* v
)
926 GET_CURRENT_CONTEXT(ctx
);
928 CALL_CallLists(ctx
->Save
, (n
, type
, v
));
933 /* This begin is hooked into ... Updating of
934 * ctx->Driver.CurrentSavePrimitive is already taken care of.
937 vbo_save_NotifyBegin(struct gl_context
*ctx
, GLenum mode
)
939 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
941 GLuint i
= save
->prim_count
++;
943 assert(i
< save
->prim_max
);
944 save
->prim
[i
].mode
= mode
& VBO_SAVE_PRIM_MODE_MASK
;
945 save
->prim
[i
].begin
= 1;
946 save
->prim
[i
].end
= 0;
947 save
->prim
[i
].weak
= (mode
& VBO_SAVE_PRIM_WEAK
) ? 1 : 0;
948 save
->prim
[i
].no_current_update
=
949 (mode
& VBO_SAVE_PRIM_NO_CURRENT_UPDATE
) ? 1 : 0;
950 save
->prim
[i
].pad
= 0;
951 save
->prim
[i
].start
= save
->vert_count
;
952 save
->prim
[i
].count
= 0;
953 save
->prim
[i
].num_instances
= 1;
954 save
->prim
[i
].base_instance
= 0;
956 if (save
->out_of_memory
) {
957 _mesa_install_save_vtxfmt(ctx
, &save
->vtxfmt_noop
);
960 _mesa_install_save_vtxfmt(ctx
, &save
->vtxfmt
);
962 ctx
->Driver
.SaveNeedFlush
= 1;
967 static void GLAPIENTRY
970 GET_CURRENT_CONTEXT(ctx
);
971 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
972 GLint i
= save
->prim_count
- 1;
974 ctx
->Driver
.CurrentSavePrimitive
= PRIM_OUTSIDE_BEGIN_END
;
975 save
->prim
[i
].end
= 1;
976 save
->prim
[i
].count
= (save
->vert_count
- save
->prim
[i
].start
);
978 if (i
== (GLint
) save
->prim_max
- 1) {
979 _save_compile_vertex_list(ctx
);
980 assert(save
->copied
.nr
== 0);
983 /* Swap out this vertex format while outside begin/end. Any color,
984 * etc. received between here and the next begin will be compiled
987 if (save
->out_of_memory
) {
988 _mesa_install_save_vtxfmt(ctx
, &save
->vtxfmt_noop
);
991 _mesa_install_save_vtxfmt(ctx
, &ctx
->ListState
.ListVtxfmt
);
996 static void GLAPIENTRY
997 _save_EvalMesh1(GLenum mode
, GLint i1
, GLint i2
)
999 GET_CURRENT_CONTEXT(ctx
);
1003 _mesa_compile_error(ctx
, GL_INVALID_OPERATION
, "glEvalMesh1");
1007 static void GLAPIENTRY
1008 _save_EvalMesh2(GLenum mode
, GLint i1
, GLint i2
, GLint j1
, GLint j2
)
1010 GET_CURRENT_CONTEXT(ctx
);
1016 _mesa_compile_error(ctx
, GL_INVALID_OPERATION
, "glEvalMesh2");
1020 static void GLAPIENTRY
1021 _save_Begin(GLenum mode
)
1023 GET_CURRENT_CONTEXT(ctx
);
1025 _mesa_compile_error(ctx
, GL_INVALID_OPERATION
, "Recursive glBegin");
1029 static void GLAPIENTRY
1030 _save_PrimitiveRestartNV(void)
1033 GET_CURRENT_CONTEXT(ctx
);
1035 curPrim
= ctx
->Driver
.CurrentSavePrimitive
;
1038 _save_Begin(curPrim
);
1042 /* Unlike the functions above, these are to be hooked into the vtxfmt
1043 * maintained in ctx->ListState, active when the list is known or
1044 * suspected to be outside any begin/end primitive.
1045 * Note: OBE = Outside Begin/End
1047 static void GLAPIENTRY
1048 _save_OBE_Rectf(GLfloat x1
, GLfloat y1
, GLfloat x2
, GLfloat y2
)
1050 GET_CURRENT_CONTEXT(ctx
);
1051 vbo_save_NotifyBegin(ctx
, GL_QUADS
| VBO_SAVE_PRIM_WEAK
);
1052 CALL_Vertex2f(GET_DISPATCH(), (x1
, y1
));
1053 CALL_Vertex2f(GET_DISPATCH(), (x2
, y1
));
1054 CALL_Vertex2f(GET_DISPATCH(), (x2
, y2
));
1055 CALL_Vertex2f(GET_DISPATCH(), (x1
, y2
));
1056 CALL_End(GET_DISPATCH(), ());
1060 static void GLAPIENTRY
1061 _save_OBE_DrawArrays(GLenum mode
, GLint start
, GLsizei count
)
1063 GET_CURRENT_CONTEXT(ctx
);
1064 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
1067 if (!_mesa_is_valid_prim_mode(ctx
, mode
)) {
1068 _mesa_compile_error(ctx
, GL_INVALID_ENUM
, "glDrawArrays(mode)");
1072 _mesa_compile_error(ctx
, GL_INVALID_VALUE
, "glDrawArrays(count<0)");
1076 if (save
->out_of_memory
)
1081 vbo_save_NotifyBegin(ctx
, (mode
| VBO_SAVE_PRIM_WEAK
1082 | VBO_SAVE_PRIM_NO_CURRENT_UPDATE
));
1084 for (i
= 0; i
< count
; i
++)
1085 CALL_ArrayElement(GET_DISPATCH(), (start
+ i
));
1086 CALL_End(GET_DISPATCH(), ());
1088 _ae_unmap_vbos(ctx
);
1092 /* Could do better by copying the arrays and element list intact and
1093 * then emitting an indexed prim at runtime.
1095 static void GLAPIENTRY
1096 _save_OBE_DrawElements(GLenum mode
, GLsizei count
, GLenum type
,
1097 const GLvoid
* indices
)
1099 GET_CURRENT_CONTEXT(ctx
);
1100 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
1103 if (!_mesa_is_valid_prim_mode(ctx
, mode
)) {
1104 _mesa_compile_error(ctx
, GL_INVALID_ENUM
, "glDrawElements(mode)");
1108 _mesa_compile_error(ctx
, GL_INVALID_VALUE
, "glDrawElements(count<0)");
1111 if (type
!= GL_UNSIGNED_BYTE
&&
1112 type
!= GL_UNSIGNED_SHORT
&&
1113 type
!= GL_UNSIGNED_INT
) {
1114 _mesa_compile_error(ctx
, GL_INVALID_VALUE
, "glDrawElements(count<0)");
1118 if (save
->out_of_memory
)
1123 if (_mesa_is_bufferobj(ctx
->Array
.ArrayObj
->ElementArrayBufferObj
))
1125 ADD_POINTERS(ctx
->Array
.ArrayObj
->ElementArrayBufferObj
->Pointer
, indices
);
1127 vbo_save_NotifyBegin(ctx
, (mode
| VBO_SAVE_PRIM_WEAK
|
1128 VBO_SAVE_PRIM_NO_CURRENT_UPDATE
));
1131 case GL_UNSIGNED_BYTE
:
1132 for (i
= 0; i
< count
; i
++)
1133 CALL_ArrayElement(GET_DISPATCH(), (((GLubyte
*) indices
)[i
]));
1135 case GL_UNSIGNED_SHORT
:
1136 for (i
= 0; i
< count
; i
++)
1137 CALL_ArrayElement(GET_DISPATCH(), (((GLushort
*) indices
)[i
]));
1139 case GL_UNSIGNED_INT
:
1140 for (i
= 0; i
< count
; i
++)
1141 CALL_ArrayElement(GET_DISPATCH(), (((GLuint
*) indices
)[i
]));
1144 _mesa_error(ctx
, GL_INVALID_ENUM
, "glDrawElements(type)");
1148 CALL_End(GET_DISPATCH(), ());
1150 _ae_unmap_vbos(ctx
);
1154 static void GLAPIENTRY
1155 _save_OBE_DrawRangeElements(GLenum mode
, GLuint start
, GLuint end
,
1156 GLsizei count
, GLenum type
,
1157 const GLvoid
* indices
)
1159 GET_CURRENT_CONTEXT(ctx
);
1160 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
1162 if (!_mesa_is_valid_prim_mode(ctx
, mode
)) {
1163 _mesa_compile_error(ctx
, GL_INVALID_ENUM
, "glDrawRangeElements(mode)");
1167 _mesa_compile_error(ctx
, GL_INVALID_VALUE
,
1168 "glDrawRangeElements(count<0)");
1171 if (type
!= GL_UNSIGNED_BYTE
&&
1172 type
!= GL_UNSIGNED_SHORT
&&
1173 type
!= GL_UNSIGNED_INT
) {
1174 _mesa_compile_error(ctx
, GL_INVALID_ENUM
, "glDrawRangeElements(type)");
1178 _mesa_compile_error(ctx
, GL_INVALID_VALUE
,
1179 "glDrawRangeElements(end < start)");
1183 if (save
->out_of_memory
)
1186 _save_OBE_DrawElements(mode
, count
, type
, indices
);
1190 static void GLAPIENTRY
1191 _save_OBE_MultiDrawElements(GLenum mode
, const GLsizei
*count
, GLenum type
,
1192 const GLvoid
**indices
, GLsizei primcount
)
1196 for (i
= 0; i
< primcount
; i
++) {
1198 CALL_DrawElements(GET_DISPATCH(), (mode
, count
[i
], type
, indices
[i
]));
1204 static void GLAPIENTRY
1205 _save_OBE_MultiDrawElementsBaseVertex(GLenum mode
, const GLsizei
*count
,
1207 const GLvoid
* const *indices
,
1209 const GLint
*basevertex
)
1213 for (i
= 0; i
< primcount
; i
++) {
1215 CALL_DrawElementsBaseVertex(GET_DISPATCH(), (mode
, count
[i
], type
,
1224 _save_vtxfmt_init(struct gl_context
*ctx
)
1226 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
1227 GLvertexformat
*vfmt
= &save
->vtxfmt
;
1229 vfmt
->ArrayElement
= _ae_ArrayElement
;
1231 vfmt
->Color3f
= _save_Color3f
;
1232 vfmt
->Color3fv
= _save_Color3fv
;
1233 vfmt
->Color4f
= _save_Color4f
;
1234 vfmt
->Color4fv
= _save_Color4fv
;
1235 vfmt
->EdgeFlag
= _save_EdgeFlag
;
1236 vfmt
->End
= _save_End
;
1237 vfmt
->PrimitiveRestartNV
= _save_PrimitiveRestartNV
;
1238 vfmt
->FogCoordfEXT
= _save_FogCoordfEXT
;
1239 vfmt
->FogCoordfvEXT
= _save_FogCoordfvEXT
;
1240 vfmt
->Indexf
= _save_Indexf
;
1241 vfmt
->Indexfv
= _save_Indexfv
;
1242 vfmt
->Materialfv
= _save_Materialfv
;
1243 vfmt
->MultiTexCoord1fARB
= _save_MultiTexCoord1f
;
1244 vfmt
->MultiTexCoord1fvARB
= _save_MultiTexCoord1fv
;
1245 vfmt
->MultiTexCoord2fARB
= _save_MultiTexCoord2f
;
1246 vfmt
->MultiTexCoord2fvARB
= _save_MultiTexCoord2fv
;
1247 vfmt
->MultiTexCoord3fARB
= _save_MultiTexCoord3f
;
1248 vfmt
->MultiTexCoord3fvARB
= _save_MultiTexCoord3fv
;
1249 vfmt
->MultiTexCoord4fARB
= _save_MultiTexCoord4f
;
1250 vfmt
->MultiTexCoord4fvARB
= _save_MultiTexCoord4fv
;
1251 vfmt
->Normal3f
= _save_Normal3f
;
1252 vfmt
->Normal3fv
= _save_Normal3fv
;
1253 vfmt
->SecondaryColor3fEXT
= _save_SecondaryColor3fEXT
;
1254 vfmt
->SecondaryColor3fvEXT
= _save_SecondaryColor3fvEXT
;
1255 vfmt
->TexCoord1f
= _save_TexCoord1f
;
1256 vfmt
->TexCoord1fv
= _save_TexCoord1fv
;
1257 vfmt
->TexCoord2f
= _save_TexCoord2f
;
1258 vfmt
->TexCoord2fv
= _save_TexCoord2fv
;
1259 vfmt
->TexCoord3f
= _save_TexCoord3f
;
1260 vfmt
->TexCoord3fv
= _save_TexCoord3fv
;
1261 vfmt
->TexCoord4f
= _save_TexCoord4f
;
1262 vfmt
->TexCoord4fv
= _save_TexCoord4fv
;
1263 vfmt
->Vertex2f
= _save_Vertex2f
;
1264 vfmt
->Vertex2fv
= _save_Vertex2fv
;
1265 vfmt
->Vertex3f
= _save_Vertex3f
;
1266 vfmt
->Vertex3fv
= _save_Vertex3fv
;
1267 vfmt
->Vertex4f
= _save_Vertex4f
;
1268 vfmt
->Vertex4fv
= _save_Vertex4fv
;
1269 vfmt
->VertexAttrib1fARB
= _save_VertexAttrib1fARB
;
1270 vfmt
->VertexAttrib1fvARB
= _save_VertexAttrib1fvARB
;
1271 vfmt
->VertexAttrib2fARB
= _save_VertexAttrib2fARB
;
1272 vfmt
->VertexAttrib2fvARB
= _save_VertexAttrib2fvARB
;
1273 vfmt
->VertexAttrib3fARB
= _save_VertexAttrib3fARB
;
1274 vfmt
->VertexAttrib3fvARB
= _save_VertexAttrib3fvARB
;
1275 vfmt
->VertexAttrib4fARB
= _save_VertexAttrib4fARB
;
1276 vfmt
->VertexAttrib4fvARB
= _save_VertexAttrib4fvARB
;
1278 vfmt
->VertexAttrib1fNV
= _save_VertexAttrib1fNV
;
1279 vfmt
->VertexAttrib1fvNV
= _save_VertexAttrib1fvNV
;
1280 vfmt
->VertexAttrib2fNV
= _save_VertexAttrib2fNV
;
1281 vfmt
->VertexAttrib2fvNV
= _save_VertexAttrib2fvNV
;
1282 vfmt
->VertexAttrib3fNV
= _save_VertexAttrib3fNV
;
1283 vfmt
->VertexAttrib3fvNV
= _save_VertexAttrib3fvNV
;
1284 vfmt
->VertexAttrib4fNV
= _save_VertexAttrib4fNV
;
1285 vfmt
->VertexAttrib4fvNV
= _save_VertexAttrib4fvNV
;
1287 /* integer-valued */
1288 vfmt
->VertexAttribI1i
= _save_VertexAttribI1i
;
1289 vfmt
->VertexAttribI2i
= _save_VertexAttribI2i
;
1290 vfmt
->VertexAttribI3i
= _save_VertexAttribI3i
;
1291 vfmt
->VertexAttribI4i
= _save_VertexAttribI4i
;
1292 vfmt
->VertexAttribI2iv
= _save_VertexAttribI2iv
;
1293 vfmt
->VertexAttribI3iv
= _save_VertexAttribI3iv
;
1294 vfmt
->VertexAttribI4iv
= _save_VertexAttribI4iv
;
1296 /* unsigned integer-valued */
1297 vfmt
->VertexAttribI1ui
= _save_VertexAttribI1ui
;
1298 vfmt
->VertexAttribI2ui
= _save_VertexAttribI2ui
;
1299 vfmt
->VertexAttribI3ui
= _save_VertexAttribI3ui
;
1300 vfmt
->VertexAttribI4ui
= _save_VertexAttribI4ui
;
1301 vfmt
->VertexAttribI2uiv
= _save_VertexAttribI2uiv
;
1302 vfmt
->VertexAttribI3uiv
= _save_VertexAttribI3uiv
;
1303 vfmt
->VertexAttribI4uiv
= _save_VertexAttribI4uiv
;
1305 vfmt
->VertexP2ui
= _save_VertexP2ui
;
1306 vfmt
->VertexP3ui
= _save_VertexP3ui
;
1307 vfmt
->VertexP4ui
= _save_VertexP4ui
;
1308 vfmt
->VertexP2uiv
= _save_VertexP2uiv
;
1309 vfmt
->VertexP3uiv
= _save_VertexP3uiv
;
1310 vfmt
->VertexP4uiv
= _save_VertexP4uiv
;
1312 vfmt
->TexCoordP1ui
= _save_TexCoordP1ui
;
1313 vfmt
->TexCoordP2ui
= _save_TexCoordP2ui
;
1314 vfmt
->TexCoordP3ui
= _save_TexCoordP3ui
;
1315 vfmt
->TexCoordP4ui
= _save_TexCoordP4ui
;
1316 vfmt
->TexCoordP1uiv
= _save_TexCoordP1uiv
;
1317 vfmt
->TexCoordP2uiv
= _save_TexCoordP2uiv
;
1318 vfmt
->TexCoordP3uiv
= _save_TexCoordP3uiv
;
1319 vfmt
->TexCoordP4uiv
= _save_TexCoordP4uiv
;
1321 vfmt
->MultiTexCoordP1ui
= _save_MultiTexCoordP1ui
;
1322 vfmt
->MultiTexCoordP2ui
= _save_MultiTexCoordP2ui
;
1323 vfmt
->MultiTexCoordP3ui
= _save_MultiTexCoordP3ui
;
1324 vfmt
->MultiTexCoordP4ui
= _save_MultiTexCoordP4ui
;
1325 vfmt
->MultiTexCoordP1uiv
= _save_MultiTexCoordP1uiv
;
1326 vfmt
->MultiTexCoordP2uiv
= _save_MultiTexCoordP2uiv
;
1327 vfmt
->MultiTexCoordP3uiv
= _save_MultiTexCoordP3uiv
;
1328 vfmt
->MultiTexCoordP4uiv
= _save_MultiTexCoordP4uiv
;
1330 vfmt
->NormalP3ui
= _save_NormalP3ui
;
1331 vfmt
->NormalP3uiv
= _save_NormalP3uiv
;
1333 vfmt
->ColorP3ui
= _save_ColorP3ui
;
1334 vfmt
->ColorP4ui
= _save_ColorP4ui
;
1335 vfmt
->ColorP3uiv
= _save_ColorP3uiv
;
1336 vfmt
->ColorP4uiv
= _save_ColorP4uiv
;
1338 vfmt
->SecondaryColorP3ui
= _save_SecondaryColorP3ui
;
1339 vfmt
->SecondaryColorP3uiv
= _save_SecondaryColorP3uiv
;
1341 vfmt
->VertexAttribP1ui
= _save_VertexAttribP1ui
;
1342 vfmt
->VertexAttribP2ui
= _save_VertexAttribP2ui
;
1343 vfmt
->VertexAttribP3ui
= _save_VertexAttribP3ui
;
1344 vfmt
->VertexAttribP4ui
= _save_VertexAttribP4ui
;
1346 vfmt
->VertexAttribP1uiv
= _save_VertexAttribP1uiv
;
1347 vfmt
->VertexAttribP2uiv
= _save_VertexAttribP2uiv
;
1348 vfmt
->VertexAttribP3uiv
= _save_VertexAttribP3uiv
;
1349 vfmt
->VertexAttribP4uiv
= _save_VertexAttribP4uiv
;
1351 /* This will all require us to fallback to saving the list as opcodes:
1353 vfmt
->CallList
= _save_CallList
;
1354 vfmt
->CallLists
= _save_CallLists
;
1356 vfmt
->EvalCoord1f
= _save_EvalCoord1f
;
1357 vfmt
->EvalCoord1fv
= _save_EvalCoord1fv
;
1358 vfmt
->EvalCoord2f
= _save_EvalCoord2f
;
1359 vfmt
->EvalCoord2fv
= _save_EvalCoord2fv
;
1360 vfmt
->EvalPoint1
= _save_EvalPoint1
;
1361 vfmt
->EvalPoint2
= _save_EvalPoint2
;
1362 vfmt
->EvalMesh1
= _save_EvalMesh1
;
1363 vfmt
->EvalMesh2
= _save_EvalMesh2
;
1365 /* These calls all generate GL_INVALID_OPERATION since this vtxfmt is
1366 * only used when we're inside a glBegin/End pair.
1368 vfmt
->Begin
= _save_Begin
;
1373 * Initialize the dispatch table with the VBO functions for display
1377 vbo_initialize_save_dispatch(const struct gl_context
*ctx
,
1378 struct _glapi_table
*exec
)
1380 SET_DrawArrays(exec
, _save_OBE_DrawArrays
);
1381 SET_DrawElements(exec
, _save_OBE_DrawElements
);
1382 SET_DrawRangeElements(exec
, _save_OBE_DrawRangeElements
);
1383 SET_MultiDrawElementsEXT(exec
, _save_OBE_MultiDrawElements
);
1384 SET_MultiDrawElementsBaseVertex(exec
, _save_OBE_MultiDrawElementsBaseVertex
);
1385 SET_Rectf(exec
, _save_OBE_Rectf
);
1386 /* Note: other glDraw functins aren't compiled into display lists */
1392 vbo_save_SaveFlushVertices(struct gl_context
*ctx
)
1394 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
1396 /* Noop when we are actually active:
1398 if (ctx
->Driver
.CurrentSavePrimitive
<= PRIM_MAX
)
1401 if (save
->vert_count
|| save
->prim_count
)
1402 _save_compile_vertex_list(ctx
);
1404 _save_copy_to_current(ctx
);
1405 _save_reset_vertex(ctx
);
1406 _save_reset_counters(ctx
);
1407 ctx
->Driver
.SaveNeedFlush
= 0;
1412 vbo_save_NewList(struct gl_context
*ctx
, GLuint list
, GLenum mode
)
1414 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
1419 if (!save
->prim_store
)
1420 save
->prim_store
= alloc_prim_store(ctx
);
1422 if (!save
->vertex_store
)
1423 save
->vertex_store
= alloc_vertex_store(ctx
);
1425 save
->buffer_ptr
= vbo_save_map_vertex_store(ctx
, save
->vertex_store
);
1427 _save_reset_vertex(ctx
);
1428 _save_reset_counters(ctx
);
1429 ctx
->Driver
.SaveNeedFlush
= 0;
1434 vbo_save_EndList(struct gl_context
*ctx
)
1436 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
1438 /* EndList called inside a (saved) Begin/End pair?
1440 if (_mesa_inside_dlist_begin_end(ctx
)) {
1441 if (save
->prim_count
> 0) {
1442 GLint i
= save
->prim_count
- 1;
1443 ctx
->Driver
.CurrentSavePrimitive
= PRIM_OUTSIDE_BEGIN_END
;
1444 save
->prim
[i
].end
= 0;
1445 save
->prim
[i
].count
= (save
->vert_count
- save
->prim
[i
].start
);
1448 /* Make sure this vertex list gets replayed by the "loopback"
1451 save
->dangling_attr_ref
= 1;
1452 vbo_save_SaveFlushVertices(ctx
);
1454 /* Swap out this vertex format while outside begin/end. Any color,
1455 * etc. received between here and the next begin will be compiled
1458 _mesa_install_save_vtxfmt(ctx
, &ctx
->ListState
.ListVtxfmt
);
1461 vbo_save_unmap_vertex_store(ctx
, save
->vertex_store
);
1463 assert(save
->vertex_size
== 0);
1468 vbo_save_BeginCallList(struct gl_context
*ctx
, struct gl_display_list
*dlist
)
1470 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
1471 save
->replay_flags
|= dlist
->Flags
;
1476 vbo_save_EndCallList(struct gl_context
*ctx
)
1478 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
1480 if (ctx
->ListState
.CallDepth
== 1) {
1481 /* This is correct: want to keep only the VBO_SAVE_FALLBACK
1482 * flag, if it is set:
1484 save
->replay_flags
&= VBO_SAVE_FALLBACK
;
1490 vbo_destroy_vertex_list(struct gl_context
*ctx
, void *data
)
1492 struct vbo_save_vertex_list
*node
= (struct vbo_save_vertex_list
*) data
;
1495 if (--node
->vertex_store
->refcount
== 0)
1496 free_vertex_store(ctx
, node
->vertex_store
);
1498 if (--node
->prim_store
->refcount
== 0)
1499 free(node
->prim_store
);
1501 free(node
->current_data
);
1502 node
->current_data
= NULL
;
1507 vbo_print_vertex_list(struct gl_context
*ctx
, void *data
)
1509 struct vbo_save_vertex_list
*node
= (struct vbo_save_vertex_list
*) data
;
1513 printf("VBO-VERTEX-LIST, %u vertices %d primitives, %d vertsize\n",
1514 node
->count
, node
->prim_count
, node
->vertex_size
);
1516 for (i
= 0; i
< node
->prim_count
; i
++) {
1517 struct _mesa_prim
*prim
= &node
->prim
[i
];
1518 printf(" prim %d: %s%s %d..%d %s %s\n",
1520 _mesa_lookup_prim_by_nr(prim
->mode
),
1521 prim
->weak
? " (weak)" : "",
1523 prim
->start
+ prim
->count
,
1524 (prim
->begin
) ? "BEGIN" : "(wrap)",
1525 (prim
->end
) ? "END" : "(wrap)");
1531 * Called during context creation/init.
1534 _save_current_init(struct gl_context
*ctx
)
1536 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
1539 for (i
= VBO_ATTRIB_POS
; i
<= VBO_ATTRIB_GENERIC15
; i
++) {
1540 const GLuint j
= i
- VBO_ATTRIB_POS
;
1541 ASSERT(j
< VERT_ATTRIB_MAX
);
1542 save
->currentsz
[i
] = &ctx
->ListState
.ActiveAttribSize
[j
];
1543 save
->current
[i
] = ctx
->ListState
.CurrentAttrib
[j
];
1546 for (i
= VBO_ATTRIB_FIRST_MATERIAL
; i
<= VBO_ATTRIB_LAST_MATERIAL
; i
++) {
1547 const GLuint j
= i
- VBO_ATTRIB_FIRST_MATERIAL
;
1548 ASSERT(j
< MAT_ATTRIB_MAX
);
1549 save
->currentsz
[i
] = &ctx
->ListState
.ActiveMaterialSize
[j
];
1550 save
->current
[i
] = ctx
->ListState
.CurrentMaterial
[j
];
1556 * Initialize the display list compiler. Called during context creation.
1559 vbo_save_api_init(struct vbo_save_context
*save
)
1561 struct gl_context
*ctx
= save
->ctx
;
1564 save
->opcode_vertex_list
=
1565 _mesa_dlist_alloc_opcode(ctx
,
1566 sizeof(struct vbo_save_vertex_list
),
1567 vbo_save_playback_vertex_list
,
1568 vbo_destroy_vertex_list
,
1569 vbo_print_vertex_list
);
1571 ctx
->Driver
.NotifySaveBegin
= vbo_save_NotifyBegin
;
1573 _save_vtxfmt_init(ctx
);
1574 _save_current_init(ctx
);
1575 _mesa_noop_vtxfmt_init(&save
->vtxfmt_noop
);
1577 /* These will actually get set again when binding/drawing */
1578 for (i
= 0; i
< VBO_ATTRIB_MAX
; i
++)
1579 save
->inputs
[i
] = &save
->arrays
[i
];