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_noop.h"
78 #include "main/api_validate.h"
79 #include "main/api_arrayelt.h"
80 #include "main/vtxfmt.h"
81 #include "main/dispatch.h"
83 #include "vbo_context.h"
94 /* An interesting VBO number/name to help with debugging */
95 #define VBO_BUF_ID 12345
99 * NOTE: Old 'parity' issue is gone, but copying can still be
100 * wrong-footed on replay.
102 static GLuint
_save_copy_vertices( GLcontext
*ctx
,
103 const struct vbo_save_vertex_list
*node
,
104 const GLfloat
*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 GLfloat
*src
= src_buffer
+ prim
->start
* sz
;
111 GLfloat
*dst
= save
->copied
.buffer
;
123 for (i
= 0 ; i
< ovf
; i
++)
124 memcpy( dst
+i
*sz
, src
+(nr
-ovf
+i
)*sz
, sz
*sizeof(GLfloat
) );
128 for (i
= 0 ; i
< ovf
; i
++)
129 memcpy( dst
+i
*sz
, src
+(nr
-ovf
+i
)*sz
, sz
*sizeof(GLfloat
) );
133 for (i
= 0 ; i
< ovf
; i
++)
134 memcpy( dst
+i
*sz
, src
+(nr
-ovf
+i
)*sz
, 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
) );
152 memcpy( dst
, src
+0, sz
*sizeof(GLfloat
) );
153 memcpy( dst
+sz
, src
+(nr
-1)*sz
, sz
*sizeof(GLfloat
) );
156 case GL_TRIANGLE_STRIP
:
159 case 0: ovf
= 0; break;
160 case 1: ovf
= 1; break;
161 default: ovf
= 2 + (nr
&1); break;
163 for (i
= 0 ; i
< ovf
; i
++)
164 memcpy( dst
+i
*sz
, src
+(nr
-ovf
+i
)*sz
, sz
*sizeof(GLfloat
) );
173 static struct vbo_save_vertex_store
*alloc_vertex_store( GLcontext
*ctx
)
175 struct vbo_save_vertex_store
*vertex_store
= CALLOC_STRUCT(vbo_save_vertex_store
);
177 /* obj->Name needs to be non-zero, but won't ever be examined more
178 * closely than that. In particular these buffers won't be entered
179 * into the hash and can never be confused with ones visible to the
180 * user. Perhaps there could be a special number for internal
183 vertex_store
->bufferobj
= ctx
->Driver
.NewBufferObject(ctx
,
185 GL_ARRAY_BUFFER_ARB
);
187 ctx
->Driver
.BufferData( ctx
,
189 VBO_SAVE_BUFFER_SIZE
* sizeof(GLfloat
),
192 vertex_store
->bufferobj
);
194 vertex_store
->buffer
= NULL
;
195 vertex_store
->used
= 0;
196 vertex_store
->refcount
= 1;
201 static void free_vertex_store( GLcontext
*ctx
, struct vbo_save_vertex_store
*vertex_store
)
203 assert(!vertex_store
->buffer
);
205 if (vertex_store
->bufferobj
) {
206 _mesa_reference_buffer_object(ctx
, &vertex_store
->bufferobj
, NULL
);
209 FREE( vertex_store
);
212 static GLfloat
*map_vertex_store( GLcontext
*ctx
, struct vbo_save_vertex_store
*vertex_store
)
214 assert(vertex_store
->bufferobj
);
215 assert(!vertex_store
->buffer
);
216 vertex_store
->buffer
= (GLfloat
*)ctx
->Driver
.MapBuffer(ctx
,
217 GL_ARRAY_BUFFER_ARB
, /* not used */
218 GL_WRITE_ONLY
, /* not used */
219 vertex_store
->bufferobj
);
221 assert(vertex_store
->buffer
);
222 return vertex_store
->buffer
+ vertex_store
->used
;
225 static void unmap_vertex_store( GLcontext
*ctx
, struct vbo_save_vertex_store
*vertex_store
)
227 ctx
->Driver
.UnmapBuffer( ctx
, GL_ARRAY_BUFFER_ARB
, vertex_store
->bufferobj
);
228 vertex_store
->buffer
= NULL
;
232 static struct vbo_save_primitive_store
*alloc_prim_store( GLcontext
*ctx
)
234 struct vbo_save_primitive_store
*store
= CALLOC_STRUCT(vbo_save_primitive_store
);
241 static void _save_reset_counters( GLcontext
*ctx
)
243 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
245 save
->prim
= save
->prim_store
->buffer
+ save
->prim_store
->used
;
246 save
->buffer
= (save
->vertex_store
->buffer
+
247 save
->vertex_store
->used
);
249 assert(save
->buffer
== save
->buffer_ptr
);
251 if (save
->vertex_size
)
252 save
->max_vert
= ((VBO_SAVE_BUFFER_SIZE
- save
->vertex_store
->used
) /
257 save
->vert_count
= 0;
258 save
->prim_count
= 0;
259 save
->prim_max
= VBO_SAVE_PRIM_SIZE
- save
->prim_store
->used
;
260 save
->dangling_attr_ref
= 0;
264 /* Insert the active immediate struct onto the display list currently
267 static void _save_compile_vertex_list( GLcontext
*ctx
)
269 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
270 struct vbo_save_vertex_list
*node
;
272 /* Allocate space for this structure in the display list currently
275 node
= (struct vbo_save_vertex_list
*)
276 _mesa_dlist_alloc(ctx
, save
->opcode_vertex_list
, sizeof(*node
));
281 /* Duplicate our template, increment refcounts to the storage structs:
283 memcpy(node
->attrsz
, save
->attrsz
, sizeof(node
->attrsz
));
284 node
->vertex_size
= save
->vertex_size
;
285 node
->buffer_offset
= (save
->buffer
- save
->vertex_store
->buffer
) * sizeof(GLfloat
);
286 node
->count
= save
->vert_count
;
287 node
->wrap_count
= save
->copied
.nr
;
288 node
->dangling_attr_ref
= save
->dangling_attr_ref
;
289 node
->prim
= save
->prim
;
290 node
->prim_count
= save
->prim_count
;
291 node
->vertex_store
= save
->vertex_store
;
292 node
->prim_store
= save
->prim_store
;
294 node
->vertex_store
->refcount
++;
295 node
->prim_store
->refcount
++;
298 node
->current_size
= node
->vertex_size
- node
->attrsz
[0];
299 node
->current_data
= NULL
;
301 if (node
->current_size
) {
302 /* If the malloc fails, we just pull the data out of the VBO
305 node
->current_data
= MALLOC( node
->current_size
* sizeof(GLfloat
) );
306 if (node
->current_data
) {
307 const char *buffer
= (const char *)save
->vertex_store
->buffer
;
308 unsigned attr_offset
= node
->attrsz
[0] * sizeof(GLfloat
);
309 unsigned vertex_offset
= 0;
312 vertex_offset
= (node
->count
-1) * node
->vertex_size
* sizeof(GLfloat
);
314 memcpy( node
->current_data
,
315 buffer
+ node
->buffer_offset
+ vertex_offset
+ attr_offset
,
316 node
->current_size
* sizeof(GLfloat
) );
322 assert(node
->attrsz
[VBO_ATTRIB_POS
] != 0 ||
325 if (save
->dangling_attr_ref
)
326 ctx
->ListState
.CurrentList
->Flags
|= DLIST_DANGLING_REFS
;
328 save
->vertex_store
->used
+= save
->vertex_size
* node
->count
;
329 save
->prim_store
->used
+= node
->prim_count
;
332 /* Copy duplicated vertices
334 save
->copied
.nr
= _save_copy_vertices( ctx
, node
, save
->buffer
);
337 /* Deal with GL_COMPILE_AND_EXECUTE:
339 if (ctx
->ExecuteFlag
) {
340 struct _glapi_table
*dispatch
= GET_DISPATCH();
342 _glapi_set_dispatch(ctx
->Exec
);
344 vbo_loopback_vertex_list( ctx
,
345 (const GLfloat
*)((const char *)save
->vertex_store
->buffer
+
346 node
->buffer_offset
),
353 _glapi_set_dispatch(dispatch
);
357 /* Decide whether the storage structs are full, or can be used for
358 * the next vertex lists as well.
360 if (save
->vertex_store
->used
>
361 VBO_SAVE_BUFFER_SIZE
- 16 * (save
->vertex_size
+ 4)) {
365 unmap_vertex_store( ctx
, save
->vertex_store
);
367 /* Release old reference:
369 save
->vertex_store
->refcount
--;
370 assert(save
->vertex_store
->refcount
!= 0);
371 save
->vertex_store
= NULL
;
373 /* Allocate and map new store:
375 save
->vertex_store
= alloc_vertex_store( ctx
);
376 save
->buffer_ptr
= map_vertex_store( ctx
, save
->vertex_store
);
379 if (save
->prim_store
->used
> VBO_SAVE_PRIM_SIZE
- 6) {
380 save
->prim_store
->refcount
--;
381 assert(save
->prim_store
->refcount
!= 0);
382 save
->prim_store
= alloc_prim_store( ctx
);
385 /* Reset our structures for the next run of vertices:
387 _save_reset_counters( ctx
);
391 /* TODO -- If no new vertices have been stored, don't bother saving
394 static void _save_wrap_buffers( GLcontext
*ctx
)
396 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
397 GLint i
= save
->prim_count
- 1;
401 assert(i
< (GLint
) save
->prim_max
);
404 /* Close off in-progress primitive.
406 save
->prim
[i
].count
= (save
->vert_count
-
407 save
->prim
[i
].start
);
408 mode
= save
->prim
[i
].mode
;
409 weak
= save
->prim
[i
].weak
;
411 /* store the copied vertices, and allocate a new list.
413 _save_compile_vertex_list( ctx
);
415 /* Restart interrupted primitive
417 save
->prim
[0].mode
= mode
;
418 save
->prim
[0].weak
= weak
;
419 save
->prim
[0].begin
= 0;
420 save
->prim
[0].end
= 0;
421 save
->prim
[0].pad
= 0;
422 save
->prim
[0].start
= 0;
423 save
->prim
[0].count
= 0;
424 save
->prim
[0].num_instances
= 1;
425 save
->prim_count
= 1;
430 /* Called only when buffers are wrapped as the result of filling the
431 * vertex_store struct.
433 static void _save_wrap_filled_vertex( GLcontext
*ctx
)
435 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
436 GLfloat
*data
= save
->copied
.buffer
;
439 /* Emit a glEnd to close off the last vertex list.
441 _save_wrap_buffers( ctx
);
443 /* Copy stored stored vertices to start of new list.
445 assert(save
->max_vert
- save
->vert_count
> save
->copied
.nr
);
447 for (i
= 0 ; i
< save
->copied
.nr
; i
++) {
448 memcpy( save
->buffer_ptr
, data
, save
->vertex_size
* sizeof(GLfloat
));
449 data
+= save
->vertex_size
;
450 save
->buffer_ptr
+= save
->vertex_size
;
456 static void _save_copy_to_current( GLcontext
*ctx
)
458 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
461 for (i
= VBO_ATTRIB_POS
+1 ; i
< VBO_ATTRIB_MAX
; i
++) {
462 if (save
->attrsz
[i
]) {
463 save
->currentsz
[i
][0] = save
->attrsz
[i
];
464 COPY_CLEAN_4V(save
->current
[i
],
472 static void _save_copy_from_current( GLcontext
*ctx
)
474 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
477 for (i
= VBO_ATTRIB_POS
+1 ; i
< VBO_ATTRIB_MAX
; i
++) {
478 switch (save
->attrsz
[i
]) {
479 case 4: save
->attrptr
[i
][3] = save
->current
[i
][3];
480 case 3: save
->attrptr
[i
][2] = save
->current
[i
][2];
481 case 2: save
->attrptr
[i
][1] = save
->current
[i
][1];
482 case 1: save
->attrptr
[i
][0] = save
->current
[i
][0];
491 /* Flush existing data, set new attrib size, replay copied vertices.
493 static void _save_upgrade_vertex( GLcontext
*ctx
,
497 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
502 /* Store the current run of vertices, and emit a GL_END. Emit a
503 * BEGIN in the new buffer.
505 if (save
->vert_count
)
506 _save_wrap_buffers( ctx
);
508 assert( save
->copied
.nr
== 0 );
510 /* Do a COPY_TO_CURRENT to ensure back-copying works for the case
511 * when the attribute already exists in the vertex and is having
512 * its size increased.
514 _save_copy_to_current( ctx
);
518 oldsz
= save
->attrsz
[attr
];
519 save
->attrsz
[attr
] = newsz
;
521 save
->vertex_size
+= newsz
- oldsz
;
522 save
->max_vert
= ((VBO_SAVE_BUFFER_SIZE
- save
->vertex_store
->used
) /
524 save
->vert_count
= 0;
526 /* Recalculate all the attrptr[] values:
528 for (i
= 0, tmp
= save
->vertex
; i
< VBO_ATTRIB_MAX
; i
++) {
529 if (save
->attrsz
[i
]) {
530 save
->attrptr
[i
] = tmp
;
531 tmp
+= save
->attrsz
[i
];
534 save
->attrptr
[i
] = NULL
; /* will not be dereferenced. */
537 /* Copy from current to repopulate the vertex with correct values.
539 _save_copy_from_current( ctx
);
541 /* Replay stored vertices to translate them to new format here.
543 * If there are copied vertices and the new (upgraded) attribute
544 * has not been defined before, this list is somewhat degenerate,
545 * and will need fixup at runtime.
549 GLfloat
*data
= save
->copied
.buffer
;
550 GLfloat
*dest
= save
->buffer
;
553 /* Need to note this and fix up at runtime (or loopback):
555 if (attr
!= VBO_ATTRIB_POS
&& save
->currentsz
[attr
][0] == 0) {
557 save
->dangling_attr_ref
= GL_TRUE
;
560 for (i
= 0 ; i
< save
->copied
.nr
; i
++) {
561 for (j
= 0 ; j
< VBO_ATTRIB_MAX
; j
++) {
562 if (save
->attrsz
[j
]) {
565 COPY_CLEAN_4V( dest
, oldsz
, data
);
570 COPY_SZ_4V( dest
, newsz
, save
->current
[attr
] );
575 GLint sz
= save
->attrsz
[j
];
576 COPY_SZ_4V( dest
, sz
, data
);
584 save
->buffer_ptr
= dest
;
585 save
->vert_count
+= save
->copied
.nr
;
589 static void save_fixup_vertex( GLcontext
*ctx
, GLuint attr
, GLuint sz
)
591 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
593 if (sz
> save
->attrsz
[attr
]) {
594 /* New size is larger. Need to flush existing vertices and get
595 * an enlarged vertex format.
597 _save_upgrade_vertex( ctx
, attr
, sz
);
599 else if (sz
< save
->active_sz
[attr
]) {
600 static GLfloat id
[4] = { 0, 0, 0, 1 };
603 /* New size is equal or smaller - just need to fill in some
606 for (i
= sz
; i
<= save
->attrsz
[attr
] ; i
++)
607 save
->attrptr
[attr
][i
-1] = id
[i
-1];
610 save
->active_sz
[attr
] = sz
;
613 static void _save_reset_vertex( GLcontext
*ctx
)
615 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
618 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
620 save
->active_sz
[i
] = 0;
623 save
->vertex_size
= 0;
628 #define ERROR() _mesa_compile_error( ctx, GL_INVALID_ENUM, __FUNCTION__ );
631 /* Only one size for each attribute may be active at once. Eg. if
632 * Color3f is installed/active, then Color4f may not be, even if the
633 * vertex actually contains 4 color coordinates. This is because the
634 * 3f version won't otherwise set color[3] to 1.0 -- this is the job
635 * of the chooser function when switching between Color4f and Color3f.
637 #define ATTR( A, N, V0, V1, V2, V3 ) \
639 struct vbo_save_context *save = &vbo_context(ctx)->save; \
641 if (save->active_sz[A] != N) \
642 save_fixup_vertex(ctx, A, N); \
645 GLfloat *dest = save->attrptr[A]; \
646 if (N>0) dest[0] = V0; \
647 if (N>1) dest[1] = V1; \
648 if (N>2) dest[2] = V2; \
649 if (N>3) dest[3] = V3; \
655 for (i = 0; i < save->vertex_size; i++) \
656 save->buffer_ptr[i] = save->vertex[i]; \
658 save->buffer_ptr += save->vertex_size; \
660 if (++save->vert_count >= save->max_vert) \
661 _save_wrap_filled_vertex( ctx ); \
665 #define TAG(x) _save_##x
667 #include "vbo_attrib_tmp.h"
672 /* Cope with EvalCoord/CallList called within a begin/end object:
673 * -- Flush current buffer
674 * -- Fallback to opcodes for the rest of the begin/end object.
676 static void DO_FALLBACK( GLcontext
*ctx
)
678 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
680 if (save
->vert_count
|| save
->prim_count
) {
681 GLint i
= save
->prim_count
- 1;
683 /* Close off in-progress primitive.
685 save
->prim
[i
].count
= (save
->vert_count
-
686 save
->prim
[i
].start
);
688 /* Need to replay this display list with loopback,
689 * unfortunately, otherwise this primitive won't be handled
692 save
->dangling_attr_ref
= 1;
694 _save_compile_vertex_list( ctx
);
697 _save_copy_to_current( ctx
);
698 _save_reset_vertex( ctx
);
699 _save_reset_counters( ctx
);
700 _mesa_install_save_vtxfmt( ctx
, &ctx
->ListState
.ListVtxfmt
);
701 ctx
->Driver
.SaveNeedFlush
= 0;
704 static void GLAPIENTRY
_save_EvalCoord1f( GLfloat u
)
706 GET_CURRENT_CONTEXT(ctx
);
708 ctx
->Save
->EvalCoord1f( u
);
711 static void GLAPIENTRY
_save_EvalCoord1fv( const GLfloat
*v
)
713 GET_CURRENT_CONTEXT(ctx
);
715 ctx
->Save
->EvalCoord1fv( v
);
718 static void GLAPIENTRY
_save_EvalCoord2f( GLfloat u
, GLfloat v
)
720 GET_CURRENT_CONTEXT(ctx
);
722 ctx
->Save
->EvalCoord2f( u
, v
);
725 static void GLAPIENTRY
_save_EvalCoord2fv( const GLfloat
*v
)
727 GET_CURRENT_CONTEXT(ctx
);
729 ctx
->Save
->EvalCoord2fv( v
);
732 static void GLAPIENTRY
_save_EvalPoint1( GLint i
)
734 GET_CURRENT_CONTEXT(ctx
);
736 ctx
->Save
->EvalPoint1( i
);
739 static void GLAPIENTRY
_save_EvalPoint2( GLint i
, GLint j
)
741 GET_CURRENT_CONTEXT(ctx
);
743 ctx
->Save
->EvalPoint2( i
, j
);
746 static void GLAPIENTRY
_save_CallList( GLuint l
)
748 GET_CURRENT_CONTEXT(ctx
);
750 ctx
->Save
->CallList( l
);
753 static void GLAPIENTRY
_save_CallLists( GLsizei n
, GLenum type
, const GLvoid
*v
)
755 GET_CURRENT_CONTEXT(ctx
);
757 ctx
->Save
->CallLists( n
, type
, v
);
763 /* This begin is hooked into ... Updating of
764 * ctx->Driver.CurrentSavePrimitive is already taken care of.
766 GLboolean
vbo_save_NotifyBegin( GLcontext
*ctx
, GLenum mode
)
768 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
770 GLuint i
= save
->prim_count
++;
772 assert(i
< save
->prim_max
);
773 save
->prim
[i
].mode
= mode
& ~VBO_SAVE_PRIM_WEAK
;
774 save
->prim
[i
].begin
= 1;
775 save
->prim
[i
].end
= 0;
776 save
->prim
[i
].weak
= (mode
& VBO_SAVE_PRIM_WEAK
) ? 1 : 0;
777 save
->prim
[i
].pad
= 0;
778 save
->prim
[i
].start
= save
->vert_count
;
779 save
->prim
[i
].count
= 0;
780 save
->prim
[i
].num_instances
= 1;
782 _mesa_install_save_vtxfmt( ctx
, &save
->vtxfmt
);
783 ctx
->Driver
.SaveNeedFlush
= 1;
789 static void GLAPIENTRY
_save_End( void )
791 GET_CURRENT_CONTEXT( ctx
);
792 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
793 GLint i
= save
->prim_count
- 1;
795 ctx
->Driver
.CurrentSavePrimitive
= PRIM_OUTSIDE_BEGIN_END
;
796 save
->prim
[i
].end
= 1;
797 save
->prim
[i
].count
= (save
->vert_count
-
798 save
->prim
[i
].start
);
800 if (i
== (GLint
) save
->prim_max
- 1) {
801 _save_compile_vertex_list( ctx
);
802 assert(save
->copied
.nr
== 0);
805 /* Swap out this vertex format while outside begin/end. Any color,
806 * etc. received between here and the next begin will be compiled
809 _mesa_install_save_vtxfmt( ctx
, &ctx
->ListState
.ListVtxfmt
);
813 /* These are all errors as this vtxfmt is only installed inside
816 static void GLAPIENTRY
_save_DrawElements(GLenum mode
, GLsizei count
, GLenum type
,
817 const GLvoid
*indices
)
819 GET_CURRENT_CONTEXT(ctx
);
820 (void) mode
; (void) count
; (void) type
; (void) indices
;
821 _mesa_compile_error( ctx
, GL_INVALID_OPERATION
, "glDrawElements" );
825 static void GLAPIENTRY
_save_DrawRangeElements(GLenum mode
,
826 GLuint start
, GLuint end
,
827 GLsizei count
, GLenum type
,
828 const GLvoid
*indices
)
830 GET_CURRENT_CONTEXT(ctx
);
831 (void) mode
; (void) start
; (void) end
; (void) count
; (void) type
; (void) indices
;
832 _mesa_compile_error( ctx
, GL_INVALID_OPERATION
, "glDrawRangeElements" );
835 static void GLAPIENTRY
_save_DrawElementsBaseVertex(GLenum mode
,
838 const GLvoid
*indices
,
841 GET_CURRENT_CONTEXT(ctx
);
842 (void) mode
; (void) count
; (void) type
; (void) indices
; (void)basevertex
;
844 _mesa_compile_error( ctx
, GL_INVALID_OPERATION
, "glDrawElements" );
847 static void GLAPIENTRY
_save_DrawRangeElementsBaseVertex(GLenum mode
,
852 const GLvoid
*indices
,
855 GET_CURRENT_CONTEXT(ctx
);
856 (void) mode
; (void) start
; (void) end
; (void) count
; (void) type
;
857 (void) indices
; (void)basevertex
;
859 _mesa_compile_error( ctx
, GL_INVALID_OPERATION
, "glDrawRangeElements" );
862 static void GLAPIENTRY
_save_DrawArrays(GLenum mode
, GLint start
, GLsizei count
)
864 GET_CURRENT_CONTEXT(ctx
);
865 (void) mode
; (void) start
; (void) count
;
866 _mesa_compile_error( ctx
, GL_INVALID_OPERATION
, "glDrawArrays" );
869 static void GLAPIENTRY
_save_Rectf( GLfloat x1
, GLfloat y1
, GLfloat x2
, GLfloat y2
)
871 GET_CURRENT_CONTEXT(ctx
);
872 (void) x1
; (void) y1
; (void) x2
; (void) y2
;
873 _mesa_compile_error( ctx
, GL_INVALID_OPERATION
, "glRectf" );
876 static void GLAPIENTRY
_save_EvalMesh1( GLenum mode
, GLint i1
, GLint i2
)
878 GET_CURRENT_CONTEXT(ctx
);
879 (void) mode
; (void) i1
; (void) i2
;
880 _mesa_compile_error( ctx
, GL_INVALID_OPERATION
, "glEvalMesh1" );
883 static void GLAPIENTRY
_save_EvalMesh2( GLenum mode
, GLint i1
, GLint i2
,
886 GET_CURRENT_CONTEXT(ctx
);
887 (void) mode
; (void) i1
; (void) i2
; (void) j1
; (void) j2
;
888 _mesa_compile_error( ctx
, GL_INVALID_OPERATION
, "glEvalMesh2" );
891 static void GLAPIENTRY
_save_Begin( GLenum mode
)
893 GET_CURRENT_CONTEXT( ctx
);
895 _mesa_compile_error( ctx
, GL_INVALID_OPERATION
, "Recursive glBegin" );
899 /* Unlike the functions above, these are to be hooked into the vtxfmt
900 * maintained in ctx->ListState, active when the list is known or
901 * suspected to be outside any begin/end primitive.
903 static void GLAPIENTRY
_save_OBE_Rectf( GLfloat x1
, GLfloat y1
, GLfloat x2
, GLfloat y2
)
905 GET_CURRENT_CONTEXT(ctx
);
906 vbo_save_NotifyBegin( ctx
, GL_QUADS
| VBO_SAVE_PRIM_WEAK
);
907 CALL_Vertex2f(GET_DISPATCH(), ( x1
, y1
));
908 CALL_Vertex2f(GET_DISPATCH(), ( x2
, y1
));
909 CALL_Vertex2f(GET_DISPATCH(), ( x2
, y2
));
910 CALL_Vertex2f(GET_DISPATCH(), ( x1
, y2
));
911 CALL_End(GET_DISPATCH(), ());
915 static void GLAPIENTRY
_save_OBE_DrawArrays(GLenum mode
, GLint start
, GLsizei count
)
917 GET_CURRENT_CONTEXT(ctx
);
920 if (!_mesa_validate_DrawArrays( ctx
, mode
, start
, count
))
925 vbo_save_NotifyBegin( ctx
, mode
| VBO_SAVE_PRIM_WEAK
);
927 for (i
= 0; i
< count
; i
++)
928 CALL_ArrayElement(GET_DISPATCH(), (start
+ i
));
929 CALL_End(GET_DISPATCH(), ());
931 _ae_unmap_vbos( ctx
);
934 /* Could do better by copying the arrays and element list intact and
935 * then emitting an indexed prim at runtime.
937 static void GLAPIENTRY
_save_OBE_DrawElements(GLenum mode
, GLsizei count
, GLenum type
,
938 const GLvoid
*indices
)
940 GET_CURRENT_CONTEXT(ctx
);
943 if (!_mesa_validate_DrawElements( ctx
, mode
, count
, type
, indices
, 0 ))
948 if (_mesa_is_bufferobj(ctx
->Array
.ElementArrayBufferObj
))
949 indices
= ADD_POINTERS(ctx
->Array
.ElementArrayBufferObj
->Pointer
, indices
);
951 vbo_save_NotifyBegin( ctx
, mode
| VBO_SAVE_PRIM_WEAK
);
954 case GL_UNSIGNED_BYTE
:
955 for (i
= 0 ; i
< count
; i
++)
956 CALL_ArrayElement(GET_DISPATCH(), ( ((GLubyte
*)indices
)[i
] ));
958 case GL_UNSIGNED_SHORT
:
959 for (i
= 0 ; i
< count
; i
++)
960 CALL_ArrayElement(GET_DISPATCH(), ( ((GLushort
*)indices
)[i
] ));
962 case GL_UNSIGNED_INT
:
963 for (i
= 0 ; i
< count
; i
++)
964 CALL_ArrayElement(GET_DISPATCH(), ( ((GLuint
*)indices
)[i
] ));
967 _mesa_error( ctx
, GL_INVALID_ENUM
, "glDrawElements(type)" );
971 CALL_End(GET_DISPATCH(), ());
973 _ae_unmap_vbos( ctx
);
976 static void GLAPIENTRY
_save_OBE_DrawRangeElements(GLenum mode
,
977 GLuint start
, GLuint end
,
978 GLsizei count
, GLenum type
,
979 const GLvoid
*indices
)
981 GET_CURRENT_CONTEXT(ctx
);
982 if (_mesa_validate_DrawRangeElements( ctx
, mode
,
984 count
, type
, indices
, 0 ))
985 _save_OBE_DrawElements( mode
, count
, type
, indices
);
992 static void _save_vtxfmt_init( GLcontext
*ctx
)
994 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
995 GLvertexformat
*vfmt
= &save
->vtxfmt
;
997 _MESA_INIT_ARRAYELT_VTXFMT(vfmt
, _ae_
);
999 vfmt
->Begin
= _save_Begin
;
1000 vfmt
->Color3f
= _save_Color3f
;
1001 vfmt
->Color3fv
= _save_Color3fv
;
1002 vfmt
->Color4f
= _save_Color4f
;
1003 vfmt
->Color4fv
= _save_Color4fv
;
1004 vfmt
->EdgeFlag
= _save_EdgeFlag
;
1005 vfmt
->End
= _save_End
;
1006 vfmt
->FogCoordfEXT
= _save_FogCoordfEXT
;
1007 vfmt
->FogCoordfvEXT
= _save_FogCoordfvEXT
;
1008 vfmt
->Indexf
= _save_Indexf
;
1009 vfmt
->Indexfv
= _save_Indexfv
;
1010 vfmt
->Materialfv
= _save_Materialfv
;
1011 vfmt
->MultiTexCoord1fARB
= _save_MultiTexCoord1f
;
1012 vfmt
->MultiTexCoord1fvARB
= _save_MultiTexCoord1fv
;
1013 vfmt
->MultiTexCoord2fARB
= _save_MultiTexCoord2f
;
1014 vfmt
->MultiTexCoord2fvARB
= _save_MultiTexCoord2fv
;
1015 vfmt
->MultiTexCoord3fARB
= _save_MultiTexCoord3f
;
1016 vfmt
->MultiTexCoord3fvARB
= _save_MultiTexCoord3fv
;
1017 vfmt
->MultiTexCoord4fARB
= _save_MultiTexCoord4f
;
1018 vfmt
->MultiTexCoord4fvARB
= _save_MultiTexCoord4fv
;
1019 vfmt
->Normal3f
= _save_Normal3f
;
1020 vfmt
->Normal3fv
= _save_Normal3fv
;
1021 vfmt
->SecondaryColor3fEXT
= _save_SecondaryColor3fEXT
;
1022 vfmt
->SecondaryColor3fvEXT
= _save_SecondaryColor3fvEXT
;
1023 vfmt
->TexCoord1f
= _save_TexCoord1f
;
1024 vfmt
->TexCoord1fv
= _save_TexCoord1fv
;
1025 vfmt
->TexCoord2f
= _save_TexCoord2f
;
1026 vfmt
->TexCoord2fv
= _save_TexCoord2fv
;
1027 vfmt
->TexCoord3f
= _save_TexCoord3f
;
1028 vfmt
->TexCoord3fv
= _save_TexCoord3fv
;
1029 vfmt
->TexCoord4f
= _save_TexCoord4f
;
1030 vfmt
->TexCoord4fv
= _save_TexCoord4fv
;
1031 vfmt
->Vertex2f
= _save_Vertex2f
;
1032 vfmt
->Vertex2fv
= _save_Vertex2fv
;
1033 vfmt
->Vertex3f
= _save_Vertex3f
;
1034 vfmt
->Vertex3fv
= _save_Vertex3fv
;
1035 vfmt
->Vertex4f
= _save_Vertex4f
;
1036 vfmt
->Vertex4fv
= _save_Vertex4fv
;
1037 vfmt
->VertexAttrib1fARB
= _save_VertexAttrib1fARB
;
1038 vfmt
->VertexAttrib1fvARB
= _save_VertexAttrib1fvARB
;
1039 vfmt
->VertexAttrib2fARB
= _save_VertexAttrib2fARB
;
1040 vfmt
->VertexAttrib2fvARB
= _save_VertexAttrib2fvARB
;
1041 vfmt
->VertexAttrib3fARB
= _save_VertexAttrib3fARB
;
1042 vfmt
->VertexAttrib3fvARB
= _save_VertexAttrib3fvARB
;
1043 vfmt
->VertexAttrib4fARB
= _save_VertexAttrib4fARB
;
1044 vfmt
->VertexAttrib4fvARB
= _save_VertexAttrib4fvARB
;
1046 vfmt
->VertexAttrib1fNV
= _save_VertexAttrib1fNV
;
1047 vfmt
->VertexAttrib1fvNV
= _save_VertexAttrib1fvNV
;
1048 vfmt
->VertexAttrib2fNV
= _save_VertexAttrib2fNV
;
1049 vfmt
->VertexAttrib2fvNV
= _save_VertexAttrib2fvNV
;
1050 vfmt
->VertexAttrib3fNV
= _save_VertexAttrib3fNV
;
1051 vfmt
->VertexAttrib3fvNV
= _save_VertexAttrib3fvNV
;
1052 vfmt
->VertexAttrib4fNV
= _save_VertexAttrib4fNV
;
1053 vfmt
->VertexAttrib4fvNV
= _save_VertexAttrib4fvNV
;
1055 /* This will all require us to fallback to saving the list as opcodes:
1057 _MESA_INIT_DLIST_VTXFMT(vfmt
, _save_
); /* inside begin/end */
1059 _MESA_INIT_EVAL_VTXFMT(vfmt
, _save_
);
1061 /* These are all errors as we at least know we are in some sort of
1064 vfmt
->Begin
= _save_Begin
;
1065 vfmt
->Rectf
= _save_Rectf
;
1066 vfmt
->DrawArrays
= _save_DrawArrays
;
1067 vfmt
->DrawElements
= _save_DrawElements
;
1068 vfmt
->DrawRangeElements
= _save_DrawRangeElements
;
1069 vfmt
->DrawElementsBaseVertex
= _save_DrawElementsBaseVertex
;
1070 vfmt
->DrawRangeElementsBaseVertex
= _save_DrawRangeElementsBaseVertex
;
1071 /* Loops back into vfmt->DrawElements */
1072 vfmt
->MultiDrawElementsEXT
= _mesa_noop_MultiDrawElements
;
1073 vfmt
->MultiDrawElementsBaseVertex
= _mesa_noop_MultiDrawElementsBaseVertex
;
1077 void vbo_save_SaveFlushVertices( GLcontext
*ctx
)
1079 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
1081 /* Noop when we are actually active:
1083 if (ctx
->Driver
.CurrentSavePrimitive
== PRIM_INSIDE_UNKNOWN_PRIM
||
1084 ctx
->Driver
.CurrentSavePrimitive
<= GL_POLYGON
)
1087 if (save
->vert_count
||
1089 _save_compile_vertex_list( ctx
);
1091 _save_copy_to_current( ctx
);
1092 _save_reset_vertex( ctx
);
1093 _save_reset_counters( ctx
);
1094 ctx
->Driver
.SaveNeedFlush
= 0;
1097 void vbo_save_NewList( GLcontext
*ctx
, GLuint list
, GLenum mode
)
1099 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
1101 (void) list
; (void) mode
;
1103 if (!save
->prim_store
)
1104 save
->prim_store
= alloc_prim_store( ctx
);
1106 if (!save
->vertex_store
)
1107 save
->vertex_store
= alloc_vertex_store( ctx
);
1109 save
->buffer_ptr
= map_vertex_store( ctx
, save
->vertex_store
);
1111 _save_reset_vertex( ctx
);
1112 _save_reset_counters( ctx
);
1113 ctx
->Driver
.SaveNeedFlush
= 0;
1116 void vbo_save_EndList( GLcontext
*ctx
)
1118 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
1120 /* EndList called inside a (saved) Begin/End pair?
1122 if (ctx
->Driver
.CurrentSavePrimitive
!= PRIM_OUTSIDE_BEGIN_END
) {
1124 if (save
->prim_count
> 0) {
1125 GLint i
= save
->prim_count
- 1;
1126 ctx
->Driver
.CurrentSavePrimitive
= PRIM_OUTSIDE_BEGIN_END
;
1127 save
->prim
[i
].end
= 0;
1128 save
->prim
[i
].count
= (save
->vert_count
-
1129 save
->prim
[i
].start
);
1132 /* Make sure this vertex list gets replayed by the "loopback"
1135 save
->dangling_attr_ref
= 1;
1136 vbo_save_SaveFlushVertices( ctx
);
1138 /* Swap out this vertex format while outside begin/end. Any color,
1139 * etc. received between here and the next begin will be compiled
1142 _mesa_install_save_vtxfmt( ctx
, &ctx
->ListState
.ListVtxfmt
);
1145 unmap_vertex_store( ctx
, save
->vertex_store
);
1147 assert(save
->vertex_size
== 0);
1150 void vbo_save_BeginCallList( GLcontext
*ctx
, struct gl_display_list
*dlist
)
1152 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
1153 save
->replay_flags
|= dlist
->Flags
;
1156 void vbo_save_EndCallList( GLcontext
*ctx
)
1158 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
1160 if (ctx
->ListState
.CallDepth
== 1) {
1161 /* This is correct: want to keep only the VBO_SAVE_FALLBACK
1162 * flag, if it is set:
1164 save
->replay_flags
&= VBO_SAVE_FALLBACK
;
1169 static void vbo_destroy_vertex_list( GLcontext
*ctx
, void *data
)
1171 struct vbo_save_vertex_list
*node
= (struct vbo_save_vertex_list
*)data
;
1174 if ( --node
->vertex_store
->refcount
== 0 )
1175 free_vertex_store( ctx
, node
->vertex_store
);
1177 if ( --node
->prim_store
->refcount
== 0 )
1178 FREE( node
->prim_store
);
1180 if (node
->current_data
) {
1181 FREE(node
->current_data
);
1182 node
->current_data
= NULL
;
1187 static void vbo_print_vertex_list( GLcontext
*ctx
, void *data
)
1189 struct vbo_save_vertex_list
*node
= (struct vbo_save_vertex_list
*)data
;
1193 printf("VBO-VERTEX-LIST, %u vertices %d primitives, %d vertsize\n",
1198 for (i
= 0 ; i
< node
->prim_count
; i
++) {
1199 struct _mesa_prim
*prim
= &node
->prim
[i
];
1200 _mesa_debug(NULL
, " prim %d: %s%s %d..%d %s %s\n",
1202 _mesa_lookup_prim_by_nr(prim
->mode
),
1203 prim
->weak
? " (weak)" : "",
1205 prim
->start
+ prim
->count
,
1206 (prim
->begin
) ? "BEGIN" : "(wrap)",
1207 (prim
->end
) ? "END" : "(wrap)");
1212 static void _save_current_init( GLcontext
*ctx
)
1214 struct vbo_save_context
*save
= &vbo_context(ctx
)->save
;
1217 for (i
= VBO_ATTRIB_POS
; i
<= VBO_ATTRIB_GENERIC15
; i
++) {
1218 const GLuint j
= i
- VBO_ATTRIB_POS
;
1219 ASSERT(j
< VERT_ATTRIB_MAX
);
1220 save
->currentsz
[i
] = &ctx
->ListState
.ActiveAttribSize
[j
];
1221 save
->current
[i
] = ctx
->ListState
.CurrentAttrib
[j
];
1224 for (i
= VBO_ATTRIB_FIRST_MATERIAL
; i
<= VBO_ATTRIB_LAST_MATERIAL
; i
++) {
1225 const GLuint j
= i
- VBO_ATTRIB_FIRST_MATERIAL
;
1226 ASSERT(j
< MAT_ATTRIB_MAX
);
1227 save
->currentsz
[i
] = &ctx
->ListState
.ActiveMaterialSize
[j
];
1228 save
->current
[i
] = ctx
->ListState
.CurrentMaterial
[j
];
1233 * Initialize the display list compiler
1235 void vbo_save_api_init( struct vbo_save_context
*save
)
1237 GLcontext
*ctx
= save
->ctx
;
1240 save
->opcode_vertex_list
=
1241 _mesa_dlist_alloc_opcode( ctx
,
1242 sizeof(struct vbo_save_vertex_list
),
1243 vbo_save_playback_vertex_list
,
1244 vbo_destroy_vertex_list
,
1245 vbo_print_vertex_list
);
1247 ctx
->Driver
.NotifySaveBegin
= vbo_save_NotifyBegin
;
1249 _save_vtxfmt_init( ctx
);
1250 _save_current_init( ctx
);
1252 /* These will actually get set again when binding/drawing */
1253 for (i
= 0; i
< VBO_ATTRIB_MAX
; i
++)
1254 save
->inputs
[i
] = &save
->arrays
[i
];
1256 /* Hook our array functions into the outside-begin-end vtxfmt in
1259 ctx
->ListState
.ListVtxfmt
.Rectf
= _save_OBE_Rectf
;
1260 ctx
->ListState
.ListVtxfmt
.DrawArrays
= _save_OBE_DrawArrays
;
1261 ctx
->ListState
.ListVtxfmt
.DrawElements
= _save_OBE_DrawElements
;
1262 ctx
->ListState
.ListVtxfmt
.DrawRangeElements
= _save_OBE_DrawRangeElements
;
1263 /* loops back into _save_OBE_DrawElements */
1264 ctx
->ListState
.ListVtxfmt
.MultiDrawElementsEXT
= _mesa_noop_MultiDrawElements
;
1265 ctx
->ListState
.ListVtxfmt
.MultiDrawElementsBaseVertex
= _mesa_noop_MultiDrawElementsBaseVertex
;
1266 _mesa_install_save_vtxfmt( ctx
, &ctx
->ListState
.ListVtxfmt
);
1270 #endif /* FEATURE_dlist */