projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
vbo: add software primitive restart support
[mesa.git] / src / mesa / vbo / vbo_save_api.c
1 /**************************************************************************
2
3 Copyright 2002-2008 Tungsten Graphics Inc., Cedar Park, Texas.
4
5 All Rights Reserved.
6
7 Permission is hereby granted, free of charge, to any person obtaining a
8 copy of this software and associated documentation files (the "Software"),
9 to deal in the Software without restriction, including without limitation
10 on the rights to use, copy, modify, merge, publish, distribute, sub
11 license, and/or sell copies of the Software, and to permit persons to whom
12 the Software is furnished to do so, subject to the following conditions:
13
14 The above copyright notice and this permission notice (including the next
15 paragraph) shall be included in all copies or substantial portions of the
16 Software.
17
18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
21 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.
25
26 **************************************************************************/
27
28 /*
29 * Authors:
30 * Keith Whitwell <keith@tungstengraphics.com>
31 */
32
33
34
35 /* Display list compiler attempts to store lists of vertices with the
36 * same vertex layout. Additionally it attempts to minimize the need
37 * for execute-time fixup of these vertex lists, allowing them to be
38 * cached on hardware.
39 *
40 * There are still some circumstances where this can be thwarted, for
41 * example by building a list that consists of one very long primitive
42 * (eg Begin(Triangles), 1000 vertices, End), and calling that list
43 * from inside a different begin/end object (Begin(Lines), CallList,
44 * End).
45 *
46 * In that case the code will have to replay the list as individual
47 * commands through the Exec dispatch table, or fix up the copied
48 * vertices at execute-time.
49 *
50 * The other case where fixup is required is when a vertex attribute
51 * is introduced in the middle of a primitive. Eg:
52 * Begin(Lines)
53 * TexCoord1f() Vertex2f()
54 * TexCoord1f() Color3f() Vertex2f()
55 * End()
56 *
57 * If the current value of Color isn't known at compile-time, this
58 * primitive will require fixup.
59 *
60 *
61 * The list compiler currently doesn't attempt to compile lists
62 * containing EvalCoord or EvalPoint commands. On encountering one of
63 * these, compilation falls back to opcodes.
64 *
65 * This could be improved to fallback only when a mix of EvalCoord and
66 * Vertex commands are issued within a single primitive.
67 */
68
69
70 #include "main/glheader.h"
71 #include "main/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/mfeatures.h"
78 #include "main/api_validate.h"
79 #include "main/api_arrayelt.h"
80 #include "main/vtxfmt.h"
81 #include "main/dispatch.h"
82
83 #include "vbo_context.h"
84 #include "vbo_noop.h"
85
86
87 #if FEATURE_dlist
88
89
90 #ifdef ERROR
91 #undef ERROR
92 #endif
93
94
95 /* An interesting VBO number/name to help with debugging */
96 #define VBO_BUF_ID 12345
97
98
99 /*
100 * NOTE: Old 'parity' issue is gone, but copying can still be
101 * wrong-footed on replay.
102 */
103 static GLuint
104 _save_copy_vertices(struct gl_context *ctx,
105 const struct vbo_save_vertex_list *node,
106 const GLfloat * src_buffer)
107 {
108 struct vbo_save_context *save = &vbo_context(ctx)->save;
109 const struct _mesa_prim *prim = &node->prim[node->prim_count - 1];
110 GLuint nr = prim->count;
111 GLuint sz = save->vertex_size;
112 const GLfloat *src = src_buffer + prim->start * sz;
113 GLfloat *dst = save->copied.buffer;
114 GLuint ovf, i;
115
116 if (prim->end)
117 return 0;
118
119 switch (prim->mode) {
120 case GL_POINTS:
121 return 0;
122 case GL_LINES:
123 ovf = nr & 1;
124 for (i = 0; i < ovf; i++)
125 memcpy(dst + i * sz, src + (nr - ovf + i) * sz,
126 sz * sizeof(GLfloat));
127 return i;
128 case GL_TRIANGLES:
129 ovf = nr % 3;
130 for (i = 0; i < ovf; i++)
131 memcpy(dst + i * sz, src + (nr - ovf + i) * sz,
132 sz * sizeof(GLfloat));
133 return i;
134 case GL_QUADS:
135 ovf = nr & 3;
136 for (i = 0; i < ovf; i++)
137 memcpy(dst + i * sz, src + (nr - ovf + i) * sz,
138 sz * sizeof(GLfloat));
139 return i;
140 case GL_LINE_STRIP:
141 if (nr == 0)
142 return 0;
143 else {
144 memcpy(dst, src + (nr - 1) * sz, sz * sizeof(GLfloat));
145 return 1;
146 }
147 case GL_LINE_LOOP:
148 case GL_TRIANGLE_FAN:
149 case GL_POLYGON:
150 if (nr == 0)
151 return 0;
152 else if (nr == 1) {
153 memcpy(dst, src + 0, sz * sizeof(GLfloat));
154 return 1;
155 }
156 else {
157 memcpy(dst, src + 0, sz * sizeof(GLfloat));
158 memcpy(dst + sz, src + (nr - 1) * sz, sz * sizeof(GLfloat));
159 return 2;
160 }
161 case GL_TRIANGLE_STRIP:
162 case GL_QUAD_STRIP:
163 switch (nr) {
164 case 0:
165 ovf = 0;
166 break;
167 case 1:
168 ovf = 1;
169 break;
170 default:
171 ovf = 2 + (nr & 1);
172 break;
173 }
174 for (i = 0; i < ovf; i++)
175 memcpy(dst + i * sz, src + (nr - ovf + i) * sz,
176 sz * sizeof(GLfloat));
177 return i;
178 default:
179 assert(0);
180 return 0;
181 }
182 }
183
184
185 static struct vbo_save_vertex_store *
186 alloc_vertex_store(struct gl_context *ctx)
187 {
188 struct vbo_save_context *save = &vbo_context(ctx)->save;
189 struct vbo_save_vertex_store *vertex_store =
190 CALLOC_STRUCT(vbo_save_vertex_store);
191
192 /* obj->Name needs to be non-zero, but won't ever be examined more
193 * closely than that. In particular these buffers won't be entered
194 * into the hash and can never be confused with ones visible to the
195 * user. Perhaps there could be a special number for internal
196 * buffers:
197 */
198 vertex_store->bufferobj = ctx->Driver.NewBufferObject(ctx,
199 VBO_BUF_ID,
200 GL_ARRAY_BUFFER_ARB);
201 if (vertex_store->bufferobj) {
202 save->out_of_memory =
203 !ctx->Driver.BufferData(ctx,
204 GL_ARRAY_BUFFER_ARB,
205 VBO_SAVE_BUFFER_SIZE * sizeof(GLfloat),
206 NULL, GL_STATIC_DRAW_ARB,
207 vertex_store->bufferobj);
208 }
209 else {
210 save->out_of_memory = GL_TRUE;
211 }
212
213 if (save->out_of_memory) {
214 _mesa_error(ctx, GL_OUT_OF_MEMORY, "internal VBO allocation");
215 _mesa_install_save_vtxfmt(ctx, &save->vtxfmt_noop);
216 }
217
218 vertex_store->buffer = NULL;
219 vertex_store->used = 0;
220 vertex_store->refcount = 1;
221
222 return vertex_store;
223 }
224
225
226 static void
227 free_vertex_store(struct gl_context *ctx,
228 struct vbo_save_vertex_store *vertex_store)
229 {
230 assert(!vertex_store->buffer);
231
232 if (vertex_store->bufferobj) {
233 _mesa_reference_buffer_object(ctx, &vertex_store->bufferobj, NULL);
234 }
235
236 FREE(vertex_store);
237 }
238
239
240 GLfloat *
241 vbo_save_map_vertex_store(struct gl_context *ctx,
242 struct vbo_save_vertex_store *vertex_store)
243 {
244 assert(vertex_store->bufferobj);
245 assert(!vertex_store->buffer);
246 if (vertex_store->bufferobj->Size > 0) {
247 vertex_store->buffer =
248 (GLfloat *) ctx->Driver.MapBufferRange(ctx, 0,
249 vertex_store->bufferobj->Size,
250 GL_MAP_WRITE_BIT, /* not used */
251 vertex_store->bufferobj);
252 assert(vertex_store->buffer);
253 return vertex_store->buffer + vertex_store->used;
254 }
255 else {
256 /* probably ran out of memory for buffers */
257 return NULL;
258 }
259 }
260
261
262 void
263 vbo_save_unmap_vertex_store(struct gl_context *ctx,
264 struct vbo_save_vertex_store *vertex_store)
265 {
266 if (vertex_store->bufferobj->Size > 0) {
267 ctx->Driver.UnmapBuffer(ctx, vertex_store->bufferobj);
268 }
269 vertex_store->buffer = NULL;
270 }
271
272
273 static struct vbo_save_primitive_store *
274 alloc_prim_store(struct gl_context *ctx)
275 {
276 struct vbo_save_primitive_store *store =
277 CALLOC_STRUCT(vbo_save_primitive_store);
278 (void) ctx;
279 store->used = 0;
280 store->refcount = 1;
281 return store;
282 }
283
284
285 static void
286 _save_reset_counters(struct gl_context *ctx)
287 {
288 struct vbo_save_context *save = &vbo_context(ctx)->save;
289
290 save->prim = save->prim_store->buffer + save->prim_store->used;
291 save->buffer = save->vertex_store->buffer + save->vertex_store->used;
292
293 assert(save->buffer == save->buffer_ptr);
294
295 if (save->vertex_size)
296 save->max_vert = ((VBO_SAVE_BUFFER_SIZE - save->vertex_store->used) /
297 save->vertex_size);
298 else
299 save->max_vert = 0;
300
301 save->vert_count = 0;
302 save->prim_count = 0;
303 save->prim_max = VBO_SAVE_PRIM_SIZE - save->prim_store->used;
304 save->dangling_attr_ref = 0;
305 }
306
307
308 /**
309 * Insert the active immediate struct onto the display list currently
310 * being built.
311 */
312 static void
313 _save_compile_vertex_list(struct gl_context *ctx)
314 {
315 struct vbo_save_context *save = &vbo_context(ctx)->save;
316 struct vbo_save_vertex_list *node;
317
318 /* Allocate space for this structure in the display list currently
319 * being compiled.
320 */
321 node = (struct vbo_save_vertex_list *)
322 _mesa_dlist_alloc(ctx, save->opcode_vertex_list, sizeof(*node));
323
324 if (!node)
325 return;
326
327 /* Duplicate our template, increment refcounts to the storage structs:
328 */
329 memcpy(node->attrsz, save->attrsz, sizeof(node->attrsz));
330 node->vertex_size = save->vertex_size;
331 node->buffer_offset =
332 (save->buffer - save->vertex_store->buffer) * sizeof(GLfloat);
333 node->count = save->vert_count;
334 node->wrap_count = save->copied.nr;
335 node->dangling_attr_ref = save->dangling_attr_ref;
336 node->prim = save->prim;
337 node->prim_count = save->prim_count;
338 node->vertex_store = save->vertex_store;
339 node->prim_store = save->prim_store;
340
341 node->vertex_store->refcount++;
342 node->prim_store->refcount++;
343
344 if (node->prim[0].no_current_update) {
345 node->current_size = 0;
346 node->current_data = NULL;
347 }
348 else {
349 node->current_size = node->vertex_size - node->attrsz[0];
350 node->current_data = NULL;
351
352 if (node->current_size) {
353 /* If the malloc fails, we just pull the data out of the VBO
354 * later instead.
355 */
356 node->current_data = MALLOC(node->current_size * sizeof(GLfloat));
357 if (node->current_data) {
358 const char *buffer = (const char *) save->vertex_store->buffer;
359 unsigned attr_offset = node->attrsz[0] * sizeof(GLfloat);
360 unsigned vertex_offset = 0;
361
362 if (node->count)
363 vertex_offset =
364 (node->count - 1) * node->vertex_size * sizeof(GLfloat);
365
366 memcpy(node->current_data,
367 buffer + node->buffer_offset + vertex_offset + attr_offset,
368 node->current_size * sizeof(GLfloat));
369 }
370 }
371 }
372
373 assert(node->attrsz[VBO_ATTRIB_POS] != 0 || node->count == 0);
374
375 if (save->dangling_attr_ref)
376 ctx->ListState.CurrentList->Flags |= DLIST_DANGLING_REFS;
377
378 save->vertex_store->used += save->vertex_size * node->count;
379 save->prim_store->used += node->prim_count;
380
381 /* Copy duplicated vertices
382 */
383 save->copied.nr = _save_copy_vertices(ctx, node, save->buffer);
384
385 /* Deal with GL_COMPILE_AND_EXECUTE:
386 */
387 if (ctx->ExecuteFlag) {
388 struct _glapi_table *dispatch = GET_DISPATCH();
389
390 _glapi_set_dispatch(ctx->Exec);
391
392 vbo_loopback_vertex_list(ctx,
393 (const GLfloat *) ((const char *) save->
394 vertex_store->buffer +
395 node->buffer_offset),
396 node->attrsz, node->prim, node->prim_count,
397 node->wrap_count, node->vertex_size);
398
399 _glapi_set_dispatch(dispatch);
400 }
401
402 /* Decide whether the storage structs are full, or can be used for
403 * the next vertex lists as well.
404 */
405 if (save->vertex_store->used >
406 VBO_SAVE_BUFFER_SIZE - 16 * (save->vertex_size + 4)) {
407
408 /* Unmap old store:
409 */
410 vbo_save_unmap_vertex_store(ctx, save->vertex_store);
411
412 /* Release old reference:
413 */
414 save->vertex_store->refcount--;
415 assert(save->vertex_store->refcount != 0);
416 save->vertex_store = NULL;
417
418 /* Allocate and map new store:
419 */
420 save->vertex_store = alloc_vertex_store(ctx);
421 save->buffer_ptr = vbo_save_map_vertex_store(ctx, save->vertex_store);
422 save->out_of_memory = save->buffer_ptr == NULL;
423 }
424
425 if (save->prim_store->used > VBO_SAVE_PRIM_SIZE - 6) {
426 save->prim_store->refcount--;
427 assert(save->prim_store->refcount != 0);
428 save->prim_store = alloc_prim_store(ctx);
429 }
430
431 /* Reset our structures for the next run of vertices:
432 */
433 _save_reset_counters(ctx);
434 }
435
436
437 /**
438 * TODO -- If no new vertices have been stored, don't bother saving it.
439 */
440 static void
441 _save_wrap_buffers(struct gl_context *ctx)
442 {
443 struct vbo_save_context *save = &vbo_context(ctx)->save;
444 GLint i = save->prim_count - 1;
445 GLenum mode;
446 GLboolean weak;
447 GLboolean no_current_update;
448
449 assert(i < (GLint) save->prim_max);
450 assert(i >= 0);
451
452 /* Close off in-progress primitive.
453 */
454 save->prim[i].count = (save->vert_count - save->prim[i].start);
455 mode = save->prim[i].mode;
456 weak = save->prim[i].weak;
457 no_current_update = save->prim[i].no_current_update;
458
459 /* store the copied vertices, and allocate a new list.
460 */
461 _save_compile_vertex_list(ctx);
462
463 /* Restart interrupted primitive
464 */
465 save->prim[0].mode = mode;
466 save->prim[0].weak = weak;
467 save->prim[0].no_current_update = no_current_update;
468 save->prim[0].begin = 0;
469 save->prim[0].end = 0;
470 save->prim[0].pad = 0;
471 save->prim[0].start = 0;
472 save->prim[0].count = 0;
473 save->prim[0].num_instances = 1;
474 save->prim_count = 1;
475 }
476
477
478 /**
479 * Called only when buffers are wrapped as the result of filling the
480 * vertex_store struct.
481 */
482 static void
483 _save_wrap_filled_vertex(struct gl_context *ctx)
484 {
485 struct vbo_save_context *save = &vbo_context(ctx)->save;
486 GLfloat *data = save->copied.buffer;
487 GLuint i;
488
489 /* Emit a glEnd to close off the last vertex list.
490 */
491 _save_wrap_buffers(ctx);
492
493 /* Copy stored stored vertices to start of new list.
494 */
495 assert(save->max_vert - save->vert_count > save->copied.nr);
496
497 for (i = 0; i < save->copied.nr; i++) {
498 memcpy(save->buffer_ptr, data, save->vertex_size * sizeof(GLfloat));
499 data += save->vertex_size;
500 save->buffer_ptr += save->vertex_size;
501 save->vert_count++;
502 }
503 }
504
505
506 static void
507 _save_copy_to_current(struct gl_context *ctx)
508 {
509 struct vbo_save_context *save = &vbo_context(ctx)->save;
510 GLuint i;
511
512 for (i = VBO_ATTRIB_POS + 1; i < VBO_ATTRIB_MAX; i++) {
513 if (save->attrsz[i]) {
514 save->currentsz[i][0] = save->attrsz[i];
515 COPY_CLEAN_4V(save->current[i], save->attrsz[i], save->attrptr[i]);
516 }
517 }
518 }
519
520
521 static void
522 _save_copy_from_current(struct gl_context *ctx)
523 {
524 struct vbo_save_context *save = &vbo_context(ctx)->save;
525 GLint i;
526
527 for (i = VBO_ATTRIB_POS + 1; i < VBO_ATTRIB_MAX; i++) {
528 switch (save->attrsz[i]) {
529 case 4:
530 save->attrptr[i][3] = save->current[i][3];
531 case 3:
532 save->attrptr[i][2] = save->current[i][2];
533 case 2:
534 save->attrptr[i][1] = save->current[i][1];
535 case 1:
536 save->attrptr[i][0] = save->current[i][0];
537 case 0:
538 break;
539 }
540 }
541 }
542
543
544 /* Flush existing data, set new attrib size, replay copied vertices.
545 */
546 static void
547 _save_upgrade_vertex(struct gl_context *ctx, GLuint attr, GLuint newsz)
548 {
549 struct vbo_save_context *save = &vbo_context(ctx)->save;
550 GLuint oldsz;
551 GLuint i;
552 GLfloat *tmp;
553
554 /* Store the current run of vertices, and emit a GL_END. Emit a
555 * BEGIN in the new buffer.
556 */
557 if (save->vert_count)
558 _save_wrap_buffers(ctx);
559 else
560 assert(save->copied.nr == 0);
561
562 /* Do a COPY_TO_CURRENT to ensure back-copying works for the case
563 * when the attribute already exists in the vertex and is having
564 * its size increased.
565 */
566 _save_copy_to_current(ctx);
567
568 /* Fix up sizes:
569 */
570 oldsz = save->attrsz[attr];
571 save->attrsz[attr] = newsz;
572
573 save->vertex_size += newsz - oldsz;
574 save->max_vert = ((VBO_SAVE_BUFFER_SIZE - save->vertex_store->used) /
575 save->vertex_size);
576 save->vert_count = 0;
577
578 /* Recalculate all the attrptr[] values:
579 */
580 for (i = 0, tmp = save->vertex; i < VBO_ATTRIB_MAX; i++) {
581 if (save->attrsz[i]) {
582 save->attrptr[i] = tmp;
583 tmp += save->attrsz[i];
584 }
585 else {
586 save->attrptr[i] = NULL; /* will not be dereferenced. */
587 }
588 }
589
590 /* Copy from current to repopulate the vertex with correct values.
591 */
592 _save_copy_from_current(ctx);
593
594 /* Replay stored vertices to translate them to new format here.
595 *
596 * If there are copied vertices and the new (upgraded) attribute
597 * has not been defined before, this list is somewhat degenerate,
598 * and will need fixup at runtime.
599 */
600 if (save->copied.nr) {
601 GLfloat *data = save->copied.buffer;
602 GLfloat *dest = save->buffer;
603 GLuint j;
604
605 /* Need to note this and fix up at runtime (or loopback):
606 */
607 if (attr != VBO_ATTRIB_POS && save->currentsz[attr][0] == 0) {
608 assert(oldsz == 0);
609 save->dangling_attr_ref = GL_TRUE;
610 }
611
612 for (i = 0; i < save->copied.nr; i++) {
613 for (j = 0; j < VBO_ATTRIB_MAX; j++) {
614 if (save->attrsz[j]) {
615 if (j == attr) {
616 if (oldsz) {
617 COPY_CLEAN_4V(dest, oldsz, data);
618 data += oldsz;
619 dest += newsz;
620 }
621 else {
622 COPY_SZ_4V(dest, newsz, save->current[attr]);
623 dest += newsz;
624 }
625 }
626 else {
627 GLint sz = save->attrsz[j];
628 COPY_SZ_4V(dest, sz, data);
629 data += sz;
630 dest += sz;
631 }
632 }
633 }
634 }
635
636 save->buffer_ptr = dest;
637 save->vert_count += save->copied.nr;
638 }
639 }
640
641
642 static void
643 save_fixup_vertex(struct gl_context *ctx, GLuint attr, GLuint sz)
644 {
645 struct vbo_save_context *save = &vbo_context(ctx)->save;
646
647 if (sz > save->attrsz[attr]) {
648 /* New size is larger. Need to flush existing vertices and get
649 * an enlarged vertex format.
650 */
651 _save_upgrade_vertex(ctx, attr, sz);
652 }
653 else if (sz < save->active_sz[attr]) {
654 static GLfloat id[4] = { 0, 0, 0, 1 };
655 GLuint i;
656
657 /* New size is equal or smaller - just need to fill in some
658 * zeros.
659 */
660 for (i = sz; i <= save->attrsz[attr]; i++)
661 save->attrptr[attr][i - 1] = id[i - 1];
662 }
663
664 save->active_sz[attr] = sz;
665 }
666
667
668 static void
669 _save_reset_vertex(struct gl_context *ctx)
670 {
671 struct vbo_save_context *save = &vbo_context(ctx)->save;
672 GLuint i;
673
674 for (i = 0; i < VBO_ATTRIB_MAX; i++) {
675 save->attrsz[i] = 0;
676 save->active_sz[i] = 0;
677 }
678
679 save->vertex_size = 0;
680 }
681
682
683
684 #define ERROR(err) _mesa_compile_error(ctx, err, __FUNCTION__);
685
686
687 /* Only one size for each attribute may be active at once. Eg. if
688 * Color3f is installed/active, then Color4f may not be, even if the
689 * vertex actually contains 4 color coordinates. This is because the
690 * 3f version won't otherwise set color[3] to 1.0 -- this is the job
691 * of the chooser function when switching between Color4f and Color3f.
692 */
693 #define ATTR(A, N, V0, V1, V2, V3) \
694 do { \
695 struct vbo_save_context *save = &vbo_context(ctx)->save; \
696 \
697 if (save->active_sz[A] != N) \
698 save_fixup_vertex(ctx, A, N); \
699 \
700 { \
701 GLfloat *dest = save->attrptr[A]; \
702 if (N>0) dest[0] = V0; \
703 if (N>1) dest[1] = V1; \
704 if (N>2) dest[2] = V2; \
705 if (N>3) dest[3] = V3; \
706 } \
707 \
708 if ((A) == 0) { \
709 GLuint i; \
710 \
711 for (i = 0; i < save->vertex_size; i++) \
712 save->buffer_ptr[i] = save->vertex[i]; \
713 \
714 save->buffer_ptr += save->vertex_size; \
715 \
716 if (++save->vert_count >= save->max_vert) \
717 _save_wrap_filled_vertex(ctx); \
718 } \
719 } while (0)
720
721 #define TAG(x) _save_##x
722
723 #include "vbo_attrib_tmp.h"
724
725
726
727 #define MAT( ATTR, N, face, params ) \
728 do { \
729 if (face != GL_BACK) \
730 MAT_ATTR( ATTR, N, params ); /* front */ \
731 if (face != GL_FRONT) \
732 MAT_ATTR( ATTR + 1, N, params ); /* back */ \
733 } while (0)
734
735
736 /**
737 * Save a glMaterial call found between glBegin/End.
738 * glMaterial calls outside Begin/End are handled in dlist.c.
739 */
740 static void GLAPIENTRY
741 _save_Materialfv(GLenum face, GLenum pname, const GLfloat *params)
742 {
743 GET_CURRENT_CONTEXT(ctx);
744
745 if (face != GL_FRONT && face != GL_BACK && face != GL_FRONT_AND_BACK) {
746 _mesa_compile_error(ctx, GL_INVALID_ENUM, "glMaterial(face)");
747 return;
748 }
749
750 switch (pname) {
751 case GL_EMISSION:
752 MAT(VBO_ATTRIB_MAT_FRONT_EMISSION, 4, face, params);
753 break;
754 case GL_AMBIENT:
755 MAT(VBO_ATTRIB_MAT_FRONT_AMBIENT, 4, face, params);
756 break;
757 case GL_DIFFUSE:
758 MAT(VBO_ATTRIB_MAT_FRONT_DIFFUSE, 4, face, params);
759 break;
760 case GL_SPECULAR:
761 MAT(VBO_ATTRIB_MAT_FRONT_SPECULAR, 4, face, params);
762 break;
763 case GL_SHININESS:
764 if (*params < 0 || *params > ctx->Const.MaxShininess) {
765 _mesa_compile_error(ctx, GL_INVALID_VALUE, "glMaterial(shininess)");
766 }
767 else {
768 MAT(VBO_ATTRIB_MAT_FRONT_SHININESS, 1, face, params);
769 }
770 break;
771 case GL_COLOR_INDEXES:
772 MAT(VBO_ATTRIB_MAT_FRONT_INDEXES, 3, face, params);
773 break;
774 case GL_AMBIENT_AND_DIFFUSE:
775 MAT(VBO_ATTRIB_MAT_FRONT_AMBIENT, 4, face, params);
776 MAT(VBO_ATTRIB_MAT_FRONT_DIFFUSE, 4, face, params);
777 break;
778 default:
779 _mesa_compile_error(ctx, GL_INVALID_ENUM, "glMaterial(pname)");
780 return;
781 }
782 }
783
784
785 /* Cope with EvalCoord/CallList called within a begin/end object:
786 * -- Flush current buffer
787 * -- Fallback to opcodes for the rest of the begin/end object.
788 */
789 static void
790 dlist_fallback(struct gl_context *ctx)
791 {
792 struct vbo_save_context *save = &vbo_context(ctx)->save;
793
794 if (save->vert_count || save->prim_count) {
795 if (save->prim_count > 0) {
796 /* Close off in-progress primitive. */
797 GLint i = save->prim_count - 1;
798 save->prim[i].count = save->vert_count - save->prim[i].start;
799 }
800
801 /* Need to replay this display list with loopback,
802 * unfortunately, otherwise this primitive won't be handled
803 * properly:
804 */
805 save->dangling_attr_ref = 1;
806
807 _save_compile_vertex_list(ctx);
808 }
809
810 _save_copy_to_current(ctx);
811 _save_reset_vertex(ctx);
812 _save_reset_counters(ctx);
813 if (save->out_of_memory) {
814 _mesa_install_save_vtxfmt(ctx, &save->vtxfmt_noop);
815 }
816 else {
817 _mesa_install_save_vtxfmt(ctx, &ctx->ListState.ListVtxfmt);
818 }
819 ctx->Driver.SaveNeedFlush = 0;
820 }
821
822
823 static void GLAPIENTRY
824 _save_EvalCoord1f(GLfloat u)
825 {
826 GET_CURRENT_CONTEXT(ctx);
827 dlist_fallback(ctx);
828 CALL_EvalCoord1f(ctx->Save, (u));
829 }
830
831 static void GLAPIENTRY
832 _save_EvalCoord1fv(const GLfloat * v)
833 {
834 GET_CURRENT_CONTEXT(ctx);
835 dlist_fallback(ctx);
836 CALL_EvalCoord1fv(ctx->Save, (v));
837 }
838
839 static void GLAPIENTRY
840 _save_EvalCoord2f(GLfloat u, GLfloat v)
841 {
842 GET_CURRENT_CONTEXT(ctx);
843 dlist_fallback(ctx);
844 CALL_EvalCoord2f(ctx->Save, (u, v));
845 }
846
847 static void GLAPIENTRY
848 _save_EvalCoord2fv(const GLfloat * v)
849 {
850 GET_CURRENT_CONTEXT(ctx);
851 dlist_fallback(ctx);
852 CALL_EvalCoord2fv(ctx->Save, (v));
853 }
854
855 static void GLAPIENTRY
856 _save_EvalPoint1(GLint i)
857 {
858 GET_CURRENT_CONTEXT(ctx);
859 dlist_fallback(ctx);
860 CALL_EvalPoint1(ctx->Save, (i));
861 }
862
863 static void GLAPIENTRY
864 _save_EvalPoint2(GLint i, GLint j)
865 {
866 GET_CURRENT_CONTEXT(ctx);
867 dlist_fallback(ctx);
868 CALL_EvalPoint2(ctx->Save, (i, j));
869 }
870
871 static void GLAPIENTRY
872 _save_CallList(GLuint l)
873 {
874 GET_CURRENT_CONTEXT(ctx);
875 dlist_fallback(ctx);
876 CALL_CallList(ctx->Save, (l));
877 }
878
879 static void GLAPIENTRY
880 _save_CallLists(GLsizei n, GLenum type, const GLvoid * v)
881 {
882 GET_CURRENT_CONTEXT(ctx);
883 dlist_fallback(ctx);
884 CALL_CallLists(ctx->Save, (n, type, v));
885 }
886
887
888
889 /* This begin is hooked into ... Updating of
890 * ctx->Driver.CurrentSavePrimitive is already taken care of.
891 */
892 GLboolean
893 vbo_save_NotifyBegin(struct gl_context *ctx, GLenum mode)
894 {
895 struct vbo_save_context *save = &vbo_context(ctx)->save;
896
897 GLuint i = save->prim_count++;
898
899 assert(i < save->prim_max);
900 save->prim[i].mode = mode & VBO_SAVE_PRIM_MODE_MASK;
901 save->prim[i].begin = 1;
902 save->prim[i].end = 0;
903 save->prim[i].weak = (mode & VBO_SAVE_PRIM_WEAK) ? 1 : 0;
904 save->prim[i].no_current_update =
905 (mode & VBO_SAVE_PRIM_NO_CURRENT_UPDATE) ? 1 : 0;
906 save->prim[i].pad = 0;
907 save->prim[i].start = save->vert_count;
908 save->prim[i].count = 0;
909 save->prim[i].num_instances = 1;
910
911 if (save->out_of_memory) {
912 _mesa_install_save_vtxfmt(ctx, &save->vtxfmt_noop);
913 }
914 else {
915 _mesa_install_save_vtxfmt(ctx, &save->vtxfmt);
916 }
917 ctx->Driver.SaveNeedFlush = 1;
918 return GL_TRUE;
919 }
920
921
922 static void GLAPIENTRY
923 _save_End(void)
924 {
925 GET_CURRENT_CONTEXT(ctx);
926 struct vbo_save_context *save = &vbo_context(ctx)->save;
927 GLint i = save->prim_count - 1;
928
929 ctx->Driver.CurrentSavePrimitive = PRIM_OUTSIDE_BEGIN_END;
930 save->prim[i].end = 1;
931 save->prim[i].count = (save->vert_count - save->prim[i].start);
932
933 if (i == (GLint) save->prim_max - 1) {
934 _save_compile_vertex_list(ctx);
935 assert(save->copied.nr == 0);
936 }
937
938 /* Swap out this vertex format while outside begin/end. Any color,
939 * etc. received between here and the next begin will be compiled
940 * as opcodes.
941 */
942 if (save->out_of_memory) {
943 _mesa_install_save_vtxfmt(ctx, &save->vtxfmt_noop);
944 }
945 else {
946 _mesa_install_save_vtxfmt(ctx, &ctx->ListState.ListVtxfmt);
947 }
948 }
949
950
951 /* These are all errors as this vtxfmt is only installed inside
952 * begin/end pairs.
953 */
954 static void GLAPIENTRY
955 _save_DrawElements(GLenum mode, GLsizei count, GLenum type,
956 const GLvoid * indices)
957 {
958 GET_CURRENT_CONTEXT(ctx);
959 (void) mode;
960 (void) count;
961 (void) type;
962 (void) indices;
963 _mesa_compile_error(ctx, GL_INVALID_OPERATION, "glDrawElements");
964 }
965
966
967 static void GLAPIENTRY
968 _save_DrawRangeElements(GLenum mode, GLuint start, GLuint end,
969 GLsizei count, GLenum type, const GLvoid * indices)
970 {
971 GET_CURRENT_CONTEXT(ctx);
972 (void) mode;
973 (void) start;
974 (void) end;
975 (void) count;
976 (void) type;
977 (void) indices;
978 _mesa_compile_error(ctx, GL_INVALID_OPERATION, "glDrawRangeElements");
979 }
980
981
982 static void GLAPIENTRY
983 _save_DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type,
984 const GLvoid * indices, GLint basevertex)
985 {
986 GET_CURRENT_CONTEXT(ctx);
987 (void) mode;
988 (void) count;
989 (void) type;
990 (void) indices;
991 (void) basevertex;
992 _mesa_compile_error(ctx, GL_INVALID_OPERATION, "glDrawElements");
993 }
994
995
996 static void GLAPIENTRY
997 _save_DrawRangeElementsBaseVertex(GLenum mode,
998 GLuint start,
999 GLuint end,
1000 GLsizei count,
1001 GLenum type,
1002 const GLvoid * indices, GLint basevertex)
1003 {
1004 GET_CURRENT_CONTEXT(ctx);
1005 (void) mode;
1006 (void) start;
1007 (void) end;
1008 (void) count;
1009 (void) type;
1010 (void) indices;
1011 (void) basevertex;
1012 _mesa_compile_error(ctx, GL_INVALID_OPERATION, "glDrawRangeElements");
1013 }
1014
1015
1016 static void GLAPIENTRY
1017 _save_DrawArrays(GLenum mode, GLint start, GLsizei count)
1018 {
1019 GET_CURRENT_CONTEXT(ctx);
1020 (void) mode;
1021 (void) start;
1022 (void) count;
1023 _mesa_compile_error(ctx, GL_INVALID_OPERATION, "glDrawArrays");
1024 }
1025
1026
1027 static void GLAPIENTRY
1028 _save_MultiDrawElements(GLenum mode, const GLsizei *count, GLenum type,
1029 const GLvoid **indices, GLsizei primcount)
1030 {
1031 GET_CURRENT_CONTEXT(ctx);
1032 (void) mode;
1033 (void) count;
1034 (void) type;
1035 (void) indices;
1036 (void) primcount;
1037 _mesa_compile_error(ctx, GL_INVALID_OPERATION, "glMultiDrawElements");
1038 }
1039
1040
1041 static void GLAPIENTRY
1042 _save_MultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count,
1043 GLenum type, const GLvoid **indices,
1044 GLsizei primcount, const GLint *basevertex)
1045 {
1046 GET_CURRENT_CONTEXT(ctx);
1047 (void) mode;
1048 (void) count;
1049 (void) type;
1050 (void) indices;
1051 (void) primcount;
1052 (void) basevertex;
1053 _mesa_compile_error(ctx, GL_INVALID_OPERATION,
1054 "glMultiDrawElementsBaseVertex");
1055 }
1056
1057
1058 static void GLAPIENTRY
1059 _save_DrawTransformFeedback(GLenum mode, GLuint name)
1060 {
1061 GET_CURRENT_CONTEXT(ctx);
1062 (void) mode;
1063 (void) name;
1064 _mesa_compile_error(ctx, GL_INVALID_OPERATION, "glDrawTransformFeedback");
1065 }
1066
1067
1068 static void GLAPIENTRY
1069 _save_Rectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
1070 {
1071 GET_CURRENT_CONTEXT(ctx);
1072 (void) x1;
1073 (void) y1;
1074 (void) x2;
1075 (void) y2;
1076 _mesa_compile_error(ctx, GL_INVALID_OPERATION, "glRectf");
1077 }
1078
1079
1080 static void GLAPIENTRY
1081 _save_EvalMesh1(GLenum mode, GLint i1, GLint i2)
1082 {
1083 GET_CURRENT_CONTEXT(ctx);
1084 (void) mode;
1085 (void) i1;
1086 (void) i2;
1087 _mesa_compile_error(ctx, GL_INVALID_OPERATION, "glEvalMesh1");
1088 }
1089
1090
1091 static void GLAPIENTRY
1092 _save_EvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
1093 {
1094 GET_CURRENT_CONTEXT(ctx);
1095 (void) mode;
1096 (void) i1;
1097 (void) i2;
1098 (void) j1;
1099 (void) j2;
1100 _mesa_compile_error(ctx, GL_INVALID_OPERATION, "glEvalMesh2");
1101 }
1102
1103
1104 static void GLAPIENTRY
1105 _save_Begin(GLenum mode)
1106 {
1107 GET_CURRENT_CONTEXT(ctx);
1108 (void) mode;
1109 _mesa_compile_error(ctx, GL_INVALID_OPERATION, "Recursive glBegin");
1110 }
1111
1112
1113 static void GLAPIENTRY
1114 _save_PrimitiveRestartNV(void)
1115 {
1116 GLenum curPrim;
1117 GET_CURRENT_CONTEXT(ctx);
1118
1119 curPrim = ctx->Driver.CurrentSavePrimitive;
1120
1121 _save_End();
1122 _save_Begin(curPrim);
1123 }
1124
1125
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
1130 */
1131 static void GLAPIENTRY
1132 _save_OBE_Rectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
1133 {
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(), ());
1141 }
1142
1143
1144 static void GLAPIENTRY
1145 _save_OBE_DrawArrays(GLenum mode, GLint start, GLsizei count)
1146 {
1147 GET_CURRENT_CONTEXT(ctx);
1148 struct vbo_save_context *save = &vbo_context(ctx)->save;
1149 GLint i;
1150
1151 if (!_mesa_validate_DrawArrays(ctx, mode, start, count))
1152 return;
1153
1154 if (save->out_of_memory)
1155 return;
1156
1157 _ae_map_vbos(ctx);
1158
1159 vbo_save_NotifyBegin(ctx, (mode | VBO_SAVE_PRIM_WEAK
1160 | VBO_SAVE_PRIM_NO_CURRENT_UPDATE));
1161
1162 for (i = 0; i < count; i++)
1163 CALL_ArrayElement(GET_DISPATCH(), (start + i));
1164 CALL_End(GET_DISPATCH(), ());
1165
1166 _ae_unmap_vbos(ctx);
1167 }
1168
1169
1170 /* Could do better by copying the arrays and element list intact and
1171 * then emitting an indexed prim at runtime.
1172 */
1173 static void GLAPIENTRY
1174 _save_OBE_DrawElements(GLenum mode, GLsizei count, GLenum type,
1175 const GLvoid * indices)
1176 {
1177 GET_CURRENT_CONTEXT(ctx);
1178 struct vbo_save_context *save = &vbo_context(ctx)->save;
1179 GLint i;
1180
1181 if (!_mesa_validate_DrawElements(ctx, mode, count, type, indices, 0))
1182 return;
1183
1184 if (save->out_of_memory)
1185 return;
1186
1187 _ae_map_vbos(ctx);
1188
1189 if (_mesa_is_bufferobj(ctx->Array.ArrayObj->ElementArrayBufferObj))
1190 indices =
1191 ADD_POINTERS(ctx->Array.ArrayObj->ElementArrayBufferObj->Pointer, indices);
1192
1193 vbo_save_NotifyBegin(ctx, (mode | VBO_SAVE_PRIM_WEAK |
1194 VBO_SAVE_PRIM_NO_CURRENT_UPDATE));
1195
1196 switch (type) {
1197 case GL_UNSIGNED_BYTE:
1198 for (i = 0; i < count; i++)
1199 CALL_ArrayElement(GET_DISPATCH(), (((GLubyte *) indices)[i]));
1200 break;
1201 case GL_UNSIGNED_SHORT:
1202 for (i = 0; i < count; i++)
1203 CALL_ArrayElement(GET_DISPATCH(), (((GLushort *) indices)[i]));
1204 break;
1205 case GL_UNSIGNED_INT:
1206 for (i = 0; i < count; i++)
1207 CALL_ArrayElement(GET_DISPATCH(), (((GLuint *) indices)[i]));
1208 break;
1209 default:
1210 _mesa_error(ctx, GL_INVALID_ENUM, "glDrawElements(type)");
1211 break;
1212 }
1213
1214 CALL_End(GET_DISPATCH(), ());
1215
1216 _ae_unmap_vbos(ctx);
1217 }
1218
1219
1220 static void GLAPIENTRY
1221 _save_OBE_DrawRangeElements(GLenum mode, GLuint start, GLuint end,
1222 GLsizei count, GLenum type,
1223 const GLvoid * indices)
1224 {
1225 GET_CURRENT_CONTEXT(ctx);
1226 struct vbo_save_context *save = &vbo_context(ctx)->save;
1227
1228 if (!_mesa_validate_DrawRangeElements(ctx, mode,
1229 start, end, count, type, indices, 0))
1230 return;
1231
1232 if (save->out_of_memory)
1233 return;
1234
1235 _save_OBE_DrawElements(mode, count, type, indices);
1236 }
1237
1238
1239 static void GLAPIENTRY
1240 _save_OBE_MultiDrawElements(GLenum mode, const GLsizei *count, GLenum type,
1241 const GLvoid **indices, GLsizei primcount)
1242 {
1243 GLsizei i;
1244
1245 for (i = 0; i < primcount; i++) {
1246 if (count[i] > 0) {
1247 CALL_DrawElements(GET_DISPATCH(), (mode, count[i], type, indices[i]));
1248 }
1249 }
1250 }
1251
1252
1253 static void GLAPIENTRY
1254 _save_OBE_MultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count,
1255 GLenum type,
1256 const GLvoid **indices,
1257 GLsizei primcount,
1258 const GLint *basevertex)
1259 {
1260 GLsizei i;
1261
1262 for (i = 0; i < primcount; i++) {
1263 if (count[i] > 0) {
1264 CALL_DrawElementsBaseVertex(GET_DISPATCH(), (mode, count[i], type,
1265 indices[i],
1266 basevertex[i]));
1267 }
1268 }
1269 }
1270
1271
1272 static void
1273 _save_vtxfmt_init(struct gl_context *ctx)
1274 {
1275 struct vbo_save_context *save = &vbo_context(ctx)->save;
1276 GLvertexformat *vfmt = &save->vtxfmt;
1277
1278 _MESA_INIT_ARRAYELT_VTXFMT(vfmt, _ae_);
1279
1280 vfmt->Begin = _save_Begin;
1281 vfmt->Color3f = _save_Color3f;
1282 vfmt->Color3fv = _save_Color3fv;
1283 vfmt->Color4f = _save_Color4f;
1284 vfmt->Color4fv = _save_Color4fv;
1285 vfmt->EdgeFlag = _save_EdgeFlag;
1286 vfmt->End = _save_End;
1287 vfmt->PrimitiveRestartNV = _save_PrimitiveRestartNV;
1288 vfmt->FogCoordfEXT = _save_FogCoordfEXT;
1289 vfmt->FogCoordfvEXT = _save_FogCoordfvEXT;
1290 vfmt->Indexf = _save_Indexf;
1291 vfmt->Indexfv = _save_Indexfv;
1292 vfmt->Materialfv = _save_Materialfv;
1293 vfmt->MultiTexCoord1fARB = _save_MultiTexCoord1f;
1294 vfmt->MultiTexCoord1fvARB = _save_MultiTexCoord1fv;
1295 vfmt->MultiTexCoord2fARB = _save_MultiTexCoord2f;
1296 vfmt->MultiTexCoord2fvARB = _save_MultiTexCoord2fv;
1297 vfmt->MultiTexCoord3fARB = _save_MultiTexCoord3f;
1298 vfmt->MultiTexCoord3fvARB = _save_MultiTexCoord3fv;
1299 vfmt->MultiTexCoord4fARB = _save_MultiTexCoord4f;
1300 vfmt->MultiTexCoord4fvARB = _save_MultiTexCoord4fv;
1301 vfmt->Normal3f = _save_Normal3f;
1302 vfmt->Normal3fv = _save_Normal3fv;
1303 vfmt->SecondaryColor3fEXT = _save_SecondaryColor3fEXT;
1304 vfmt->SecondaryColor3fvEXT = _save_SecondaryColor3fvEXT;
1305 vfmt->TexCoord1f = _save_TexCoord1f;
1306 vfmt->TexCoord1fv = _save_TexCoord1fv;
1307 vfmt->TexCoord2f = _save_TexCoord2f;
1308 vfmt->TexCoord2fv = _save_TexCoord2fv;
1309 vfmt->TexCoord3f = _save_TexCoord3f;
1310 vfmt->TexCoord3fv = _save_TexCoord3fv;
1311 vfmt->TexCoord4f = _save_TexCoord4f;
1312 vfmt->TexCoord4fv = _save_TexCoord4fv;
1313 vfmt->Vertex2f = _save_Vertex2f;
1314 vfmt->Vertex2fv = _save_Vertex2fv;
1315 vfmt->Vertex3f = _save_Vertex3f;
1316 vfmt->Vertex3fv = _save_Vertex3fv;
1317 vfmt->Vertex4f = _save_Vertex4f;
1318 vfmt->Vertex4fv = _save_Vertex4fv;
1319 vfmt->VertexAttrib1fARB = _save_VertexAttrib1fARB;
1320 vfmt->VertexAttrib1fvARB = _save_VertexAttrib1fvARB;
1321 vfmt->VertexAttrib2fARB = _save_VertexAttrib2fARB;
1322 vfmt->VertexAttrib2fvARB = _save_VertexAttrib2fvARB;
1323 vfmt->VertexAttrib3fARB = _save_VertexAttrib3fARB;
1324 vfmt->VertexAttrib3fvARB = _save_VertexAttrib3fvARB;
1325 vfmt->VertexAttrib4fARB = _save_VertexAttrib4fARB;
1326 vfmt->VertexAttrib4fvARB = _save_VertexAttrib4fvARB;
1327
1328 vfmt->VertexAttrib1fNV = _save_VertexAttrib1fNV;
1329 vfmt->VertexAttrib1fvNV = _save_VertexAttrib1fvNV;
1330 vfmt->VertexAttrib2fNV = _save_VertexAttrib2fNV;
1331 vfmt->VertexAttrib2fvNV = _save_VertexAttrib2fvNV;
1332 vfmt->VertexAttrib3fNV = _save_VertexAttrib3fNV;
1333 vfmt->VertexAttrib3fvNV = _save_VertexAttrib3fvNV;
1334 vfmt->VertexAttrib4fNV = _save_VertexAttrib4fNV;
1335 vfmt->VertexAttrib4fvNV = _save_VertexAttrib4fvNV;
1336
1337 /* integer-valued */
1338 vfmt->VertexAttribI1i = _save_VertexAttribI1i;
1339 vfmt->VertexAttribI2i = _save_VertexAttribI2i;
1340 vfmt->VertexAttribI3i = _save_VertexAttribI3i;
1341 vfmt->VertexAttribI4i = _save_VertexAttribI4i;
1342 vfmt->VertexAttribI2iv = _save_VertexAttribI2iv;
1343 vfmt->VertexAttribI3iv = _save_VertexAttribI3iv;
1344 vfmt->VertexAttribI4iv = _save_VertexAttribI4iv;
1345
1346 /* unsigned integer-valued */
1347 vfmt->VertexAttribI1ui = _save_VertexAttribI1ui;
1348 vfmt->VertexAttribI2ui = _save_VertexAttribI2ui;
1349 vfmt->VertexAttribI3ui = _save_VertexAttribI3ui;
1350 vfmt->VertexAttribI4ui = _save_VertexAttribI4ui;
1351 vfmt->VertexAttribI2uiv = _save_VertexAttribI2uiv;
1352 vfmt->VertexAttribI3uiv = _save_VertexAttribI3uiv;
1353 vfmt->VertexAttribI4uiv = _save_VertexAttribI4uiv;
1354
1355 vfmt->VertexP2ui = _save_VertexP2ui;
1356 vfmt->VertexP3ui = _save_VertexP3ui;
1357 vfmt->VertexP4ui = _save_VertexP4ui;
1358 vfmt->VertexP2uiv = _save_VertexP2uiv;
1359 vfmt->VertexP3uiv = _save_VertexP3uiv;
1360 vfmt->VertexP4uiv = _save_VertexP4uiv;
1361
1362 vfmt->TexCoordP1ui = _save_TexCoordP1ui;
1363 vfmt->TexCoordP2ui = _save_TexCoordP2ui;
1364 vfmt->TexCoordP3ui = _save_TexCoordP3ui;
1365 vfmt->TexCoordP4ui = _save_TexCoordP4ui;
1366 vfmt->TexCoordP1uiv = _save_TexCoordP1uiv;
1367 vfmt->TexCoordP2uiv = _save_TexCoordP2uiv;
1368 vfmt->TexCoordP3uiv = _save_TexCoordP3uiv;
1369 vfmt->TexCoordP4uiv = _save_TexCoordP4uiv;
1370
1371 vfmt->MultiTexCoordP1ui = _save_MultiTexCoordP1ui;
1372 vfmt->MultiTexCoordP2ui = _save_MultiTexCoordP2ui;
1373 vfmt->MultiTexCoordP3ui = _save_MultiTexCoordP3ui;
1374 vfmt->MultiTexCoordP4ui = _save_MultiTexCoordP4ui;
1375 vfmt->MultiTexCoordP1uiv = _save_MultiTexCoordP1uiv;
1376 vfmt->MultiTexCoordP2uiv = _save_MultiTexCoordP2uiv;
1377 vfmt->MultiTexCoordP3uiv = _save_MultiTexCoordP3uiv;
1378 vfmt->MultiTexCoordP4uiv = _save_MultiTexCoordP4uiv;
1379
1380 vfmt->NormalP3ui = _save_NormalP3ui;
1381 vfmt->NormalP3uiv = _save_NormalP3uiv;
1382
1383 vfmt->ColorP3ui = _save_ColorP3ui;
1384 vfmt->ColorP4ui = _save_ColorP4ui;
1385 vfmt->ColorP3uiv = _save_ColorP3uiv;
1386 vfmt->ColorP4uiv = _save_ColorP4uiv;
1387
1388 vfmt->SecondaryColorP3ui = _save_SecondaryColorP3ui;
1389 vfmt->SecondaryColorP3uiv = _save_SecondaryColorP3uiv;
1390
1391 vfmt->VertexAttribP1ui = _save_VertexAttribP1ui;
1392 vfmt->VertexAttribP2ui = _save_VertexAttribP2ui;
1393 vfmt->VertexAttribP3ui = _save_VertexAttribP3ui;
1394 vfmt->VertexAttribP4ui = _save_VertexAttribP4ui;
1395
1396 vfmt->VertexAttribP1uiv = _save_VertexAttribP1uiv;
1397 vfmt->VertexAttribP2uiv = _save_VertexAttribP2uiv;
1398 vfmt->VertexAttribP3uiv = _save_VertexAttribP3uiv;
1399 vfmt->VertexAttribP4uiv = _save_VertexAttribP4uiv;
1400
1401 /* This will all require us to fallback to saving the list as opcodes:
1402 */
1403 _MESA_INIT_DLIST_VTXFMT(vfmt, _save_); /* inside begin/end */
1404
1405 _MESA_INIT_EVAL_VTXFMT(vfmt, _save_);
1406
1407 /* These calls all generate GL_INVALID_OPERATION since this vtxfmt is
1408 * only used when we're inside a glBegin/End pair.
1409 */
1410 vfmt->Begin = _save_Begin;
1411 vfmt->Rectf = _save_Rectf;
1412 vfmt->DrawArrays = _save_DrawArrays;
1413 vfmt->DrawElements = _save_DrawElements;
1414 vfmt->DrawRangeElements = _save_DrawRangeElements;
1415 vfmt->DrawElementsBaseVertex = _save_DrawElementsBaseVertex;
1416 vfmt->DrawRangeElementsBaseVertex = _save_DrawRangeElementsBaseVertex;
1417 vfmt->DrawTransformFeedback = _save_DrawTransformFeedback;
1418 vfmt->MultiDrawElementsEXT = _save_MultiDrawElements;
1419 vfmt->MultiDrawElementsBaseVertex = _save_MultiDrawElementsBaseVertex;
1420 }
1421
1422
1423 void
1424 vbo_save_SaveFlushVertices(struct gl_context *ctx)
1425 {
1426 struct vbo_save_context *save = &vbo_context(ctx)->save;
1427
1428 /* Noop when we are actually active:
1429 */
1430 if (ctx->Driver.CurrentSavePrimitive == PRIM_INSIDE_UNKNOWN_PRIM ||
1431 ctx->Driver.CurrentSavePrimitive <= GL_POLYGON)
1432 return;
1433
1434 if (save->vert_count || save->prim_count)
1435 _save_compile_vertex_list(ctx);
1436
1437 _save_copy_to_current(ctx);
1438 _save_reset_vertex(ctx);
1439 _save_reset_counters(ctx);
1440 ctx->Driver.SaveNeedFlush = 0;
1441 }
1442
1443
1444 void
1445 vbo_save_NewList(struct gl_context *ctx, GLuint list, GLenum mode)
1446 {
1447 struct vbo_save_context *save = &vbo_context(ctx)->save;
1448
1449 (void) list;
1450 (void) mode;
1451
1452 if (!save->prim_store)
1453 save->prim_store = alloc_prim_store(ctx);
1454
1455 if (!save->vertex_store)
1456 save->vertex_store = alloc_vertex_store(ctx);
1457
1458 save->buffer_ptr = vbo_save_map_vertex_store(ctx, save->vertex_store);
1459
1460 _save_reset_vertex(ctx);
1461 _save_reset_counters(ctx);
1462 ctx->Driver.SaveNeedFlush = 0;
1463 }
1464
1465
1466 void
1467 vbo_save_EndList(struct gl_context *ctx)
1468 {
1469 struct vbo_save_context *save = &vbo_context(ctx)->save;
1470
1471 /* EndList called inside a (saved) Begin/End pair?
1472 */
1473 if (ctx->Driver.CurrentSavePrimitive != PRIM_OUTSIDE_BEGIN_END) {
1474
1475 if (save->prim_count > 0) {
1476 GLint i = save->prim_count - 1;
1477 ctx->Driver.CurrentSavePrimitive = PRIM_OUTSIDE_BEGIN_END;
1478 save->prim[i].end = 0;
1479 save->prim[i].count = (save->vert_count - save->prim[i].start);
1480 }
1481
1482 /* Make sure this vertex list gets replayed by the "loopback"
1483 * mechanism:
1484 */
1485 save->dangling_attr_ref = 1;
1486 vbo_save_SaveFlushVertices(ctx);
1487
1488 /* Swap out this vertex format while outside begin/end. Any color,
1489 * etc. received between here and the next begin will be compiled
1490 * as opcodes.
1491 */
1492 _mesa_install_save_vtxfmt(ctx, &ctx->ListState.ListVtxfmt);
1493 }
1494
1495 vbo_save_unmap_vertex_store(ctx, save->vertex_store);
1496
1497 assert(save->vertex_size == 0);
1498 }
1499
1500
1501 void
1502 vbo_save_BeginCallList(struct gl_context *ctx, struct gl_display_list *dlist)
1503 {
1504 struct vbo_save_context *save = &vbo_context(ctx)->save;
1505 save->replay_flags |= dlist->Flags;
1506 }
1507
1508
1509 void
1510 vbo_save_EndCallList(struct gl_context *ctx)
1511 {
1512 struct vbo_save_context *save = &vbo_context(ctx)->save;
1513
1514 if (ctx->ListState.CallDepth == 1) {
1515 /* This is correct: want to keep only the VBO_SAVE_FALLBACK
1516 * flag, if it is set:
1517 */
1518 save->replay_flags &= VBO_SAVE_FALLBACK;
1519 }
1520 }
1521
1522
1523 static void
1524 vbo_destroy_vertex_list(struct gl_context *ctx, void *data)
1525 {
1526 struct vbo_save_vertex_list *node = (struct vbo_save_vertex_list *) data;
1527 (void) ctx;
1528
1529 if (--node->vertex_store->refcount == 0)
1530 free_vertex_store(ctx, node->vertex_store);
1531
1532 if (--node->prim_store->refcount == 0)
1533 FREE(node->prim_store);
1534
1535 if (node->current_data) {
1536 FREE(node->current_data);
1537 node->current_data = NULL;
1538 }
1539 }
1540
1541
1542 static void
1543 vbo_print_vertex_list(struct gl_context *ctx, void *data)
1544 {
1545 struct vbo_save_vertex_list *node = (struct vbo_save_vertex_list *) data;
1546 GLuint i;
1547 (void) ctx;
1548
1549 printf("VBO-VERTEX-LIST, %u vertices %d primitives, %d vertsize\n",
1550 node->count, node->prim_count, node->vertex_size);
1551
1552 for (i = 0; i < node->prim_count; i++) {
1553 struct _mesa_prim *prim = &node->prim[i];
1554 _mesa_debug(NULL, " prim %d: %s%s %d..%d %s %s\n",
1555 i,
1556 _mesa_lookup_prim_by_nr(prim->mode),
1557 prim->weak ? " (weak)" : "",
1558 prim->start,
1559 prim->start + prim->count,
1560 (prim->begin) ? "BEGIN" : "(wrap)",
1561 (prim->end) ? "END" : "(wrap)");
1562 }
1563 }
1564
1565
1566 /**
1567 * Called during context creation/init.
1568 */
1569 static void
1570 _save_current_init(struct gl_context *ctx)
1571 {
1572 struct vbo_save_context *save = &vbo_context(ctx)->save;
1573 GLint i;
1574
1575 for (i = VBO_ATTRIB_POS; i <= VBO_ATTRIB_GENERIC15; i++) {
1576 const GLuint j = i - VBO_ATTRIB_POS;
1577 ASSERT(j < VERT_ATTRIB_MAX);
1578 save->currentsz[i] = &ctx->ListState.ActiveAttribSize[j];
1579 save->current[i] = ctx->ListState.CurrentAttrib[j];
1580 }
1581
1582 for (i = VBO_ATTRIB_FIRST_MATERIAL; i <= VBO_ATTRIB_LAST_MATERIAL; i++) {
1583 const GLuint j = i - VBO_ATTRIB_FIRST_MATERIAL;
1584 ASSERT(j < MAT_ATTRIB_MAX);
1585 save->currentsz[i] = &ctx->ListState.ActiveMaterialSize[j];
1586 save->current[i] = ctx->ListState.CurrentMaterial[j];
1587 }
1588 }
1589
1590
1591 /**
1592 * Initialize the display list compiler. Called during context creation.
1593 */
1594 void
1595 vbo_save_api_init(struct vbo_save_context *save)
1596 {
1597 struct gl_context *ctx = save->ctx;
1598 GLuint i;
1599
1600 save->opcode_vertex_list =
1601 _mesa_dlist_alloc_opcode(ctx,
1602 sizeof(struct vbo_save_vertex_list),
1603 vbo_save_playback_vertex_list,
1604 vbo_destroy_vertex_list,
1605 vbo_print_vertex_list);
1606
1607 ctx->Driver.NotifySaveBegin = vbo_save_NotifyBegin;
1608
1609 _save_vtxfmt_init(ctx);
1610 _save_current_init(ctx);
1611 _mesa_noop_vtxfmt_init(&save->vtxfmt_noop);
1612
1613 /* These will actually get set again when binding/drawing */
1614 for (i = 0; i < VBO_ATTRIB_MAX; i++)
1615 save->inputs[i] = &save->arrays[i];
1616
1617 /* Hook our array functions into the outside-begin-end vtxfmt in
1618 * ctx->ListState.
1619 */
1620 ctx->ListState.ListVtxfmt.Rectf = _save_OBE_Rectf;
1621 ctx->ListState.ListVtxfmt.DrawArrays = _save_OBE_DrawArrays;
1622 ctx->ListState.ListVtxfmt.DrawElements = _save_OBE_DrawElements;
1623 ctx->ListState.ListVtxfmt.DrawRangeElements = _save_OBE_DrawRangeElements;
1624 ctx->ListState.ListVtxfmt.MultiDrawElementsEXT = _save_OBE_MultiDrawElements;
1625 ctx->ListState.ListVtxfmt.MultiDrawElementsBaseVertex = _save_OBE_MultiDrawElementsBaseVertex;
1626 _mesa_install_save_vtxfmt(ctx, &ctx->ListState.ListVtxfmt);
1627 }
1628
1629
1630 #endif /* FEATURE_dlist */