2 /**************************************************************************
4 Copyright 2002 Tungsten Graphics Inc., Cedar Park, Texas.
8 Permission is hereby granted, free of charge, to any person obtaining a
9 copy of this software and associated documentation files (the "Software"),
10 to deal in the Software without restriction, including without limitation
11 on the rights to use, copy, modify, merge, publish, distribute, sub
12 license, and/or sell copies of the Software, and to permit persons to whom
13 the Software is furnished to do so, subject to the following conditions:
15 The above copyright notice and this permission notice (including the next
16 paragraph) shall be included in all copies or substantial portions of the
19 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
22 TUNGSTEN GRAPHICS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
23 DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
24 OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
25 USE OR OTHER DEALINGS IN THE SOFTWARE.
27 **************************************************************************/
31 * Keith Whitwell <keith@tungstengraphics.com>
36 /* Display list compiler attempts to store lists of vertices with the
37 * same vertex layout. Additionally it attempts to minimize the need
38 * for execute-time fixup of these vertex lists, allowing them to be
41 * There are still some circumstances where this can be thwarted, for
42 * example by building a list that consists of one very long primitive
43 * (eg Begin(Triangles), 1000 vertices, End), and calling that list
44 * from inside a different begin/end object (Begin(Lines), CallList,
47 * In that case the code will have to replay the list as individual
48 * commands through the Exec dispatch table, or fix up the copied
49 * vertices at execute-time.
51 * The other case where fixup is required is when a vertex attribute
52 * is introduced in the middle of a primitive. Eg:
54 * TexCoord1f() Vertex2f()
55 * TexCoord1f() Color3f() Vertex2f()
58 * If the current value of Color isn't known at compile-time, this
59 * primitive will require fixup.
62 * The list compiler currently doesn't attempt to compile lists
63 * containing EvalCoord or EvalPoint commands. On encountering one of
64 * these, compilation falls back to opcodes.
66 * This could be improved to fallback only when a mix of EvalCoord and
67 * Vertex commands are issued within a single primitive.
76 #include "api_validate.h"
77 #include "api_arrayelt.h"
79 #include "t_save_api.h"
82 * NOTE: Old 'parity' issue is gone, but copying can still be
83 * wrong-footed on replay.
85 static GLuint
_save_copy_vertices( GLcontext
*ctx
,
86 const struct tnl_vertex_list
*node
)
88 TNLcontext
*tnl
= TNL_CONTEXT( ctx
);
89 const struct tnl_prim
*prim
= &node
->prim
[node
->prim_count
-1];
90 GLuint nr
= prim
->count
;
91 GLuint sz
= tnl
->save
.vertex_size
;
92 const GLfloat
*src
= node
->buffer
+ prim
->start
* sz
;
93 GLfloat
*dst
= tnl
->save
.copied
.buffer
;
96 if (prim
->mode
& PRIM_END
)
99 switch( prim
->mode
& PRIM_MODE_MASK
)
105 for (i
= 0 ; i
< ovf
; i
++)
106 _mesa_memcpy( dst
+i
*sz
, src
+(nr
-ovf
+i
)*sz
, sz
*sizeof(GLfloat
) );
110 for (i
= 0 ; i
< ovf
; i
++)
111 _mesa_memcpy( dst
+i
*sz
, src
+(nr
-ovf
+i
)*sz
, sz
*sizeof(GLfloat
) );
115 for (i
= 0 ; i
< ovf
; i
++)
116 _mesa_memcpy( dst
+i
*sz
, src
+(nr
-ovf
+i
)*sz
, sz
*sizeof(GLfloat
) );
122 _mesa_memcpy( dst
, src
+(nr
-1)*sz
, sz
*sizeof(GLfloat
) );
126 case GL_TRIANGLE_FAN
:
131 _mesa_memcpy( dst
, src
+0, sz
*sizeof(GLfloat
) );
134 _mesa_memcpy( dst
, src
+0, sz
*sizeof(GLfloat
) );
135 _mesa_memcpy( dst
+sz
, src
+(nr
-1)*sz
, sz
*sizeof(GLfloat
) );
138 case GL_TRIANGLE_STRIP
:
141 case 0: ovf
= 0; break;
142 case 1: ovf
= 1; break;
143 default: ovf
= 2 + (nr
&1); break;
145 for (i
= 0 ; i
< ovf
; i
++)
146 _mesa_memcpy( dst
+i
*sz
, src
+(nr
-ovf
+i
)*sz
, sz
*sizeof(GLfloat
) );
156 build_normal_lengths( struct tnl_vertex_list
*node
)
160 GLfloat
*n
= node
->buffer
;
161 GLuint stride
= node
->vertex_size
;
162 GLuint count
= node
->count
;
164 len
= node
->normal_lengths
= (GLfloat
*) MALLOC( count
* sizeof(GLfloat
) );
168 /* Find the normal of the first vertex:
170 for (i
= 0 ; i
< _TNL_ATTRIB_NORMAL
; i
++)
171 n
+= node
->attrsz
[i
];
173 for (i
= 0 ; i
< count
; i
++, n
+= stride
) {
174 len
[i
] = LEN_3FV( n
);
175 if (len
[i
] > 0.0F
) len
[i
] = 1.0F
/ len
[i
];
179 static struct tnl_vertex_store
*alloc_vertex_store( GLcontext
*ctx
)
181 struct tnl_vertex_store
*store
= MALLOC_STRUCT(tnl_vertex_store
);
188 static struct tnl_primitive_store
*alloc_prim_store( GLcontext
*ctx
)
190 struct tnl_primitive_store
*store
= MALLOC_STRUCT(tnl_primitive_store
);
197 static void _save_reset_counters( GLcontext
*ctx
)
199 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
201 tnl
->save
.prim
= tnl
->save
.prim_store
->buffer
+ tnl
->save
.prim_store
->used
;
202 tnl
->save
.buffer
= (tnl
->save
.vertex_store
->buffer
+
203 tnl
->save
.vertex_store
->used
);
205 if (tnl
->save
.vertex_size
)
206 tnl
->save
.initial_counter
= ((SAVE_BUFFER_SIZE
-
207 tnl
->save
.vertex_store
->used
) /
208 tnl
->save
.vertex_size
);
210 tnl
->save
.initial_counter
= 0;
212 if (tnl
->save
.initial_counter
> ctx
->Const
.MaxArrayLockSize
)
213 tnl
->save
.initial_counter
= ctx
->Const
.MaxArrayLockSize
;
215 tnl
->save
.counter
= tnl
->save
.initial_counter
;
216 tnl
->save
.prim_count
= 0;
217 tnl
->save
.prim_max
= SAVE_PRIM_SIZE
- tnl
->save
.prim_store
->used
;
218 tnl
->save
.copied
.nr
= 0;
219 tnl
->save
.dangling_attr_ref
= 0;
223 /* Insert the active immediate struct onto the display list currently
226 static void _save_compile_vertex_list( GLcontext
*ctx
)
228 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
229 struct tnl_vertex_list
*node
;
231 /* Allocate space for this structure in the display list currently
234 node
= (struct tnl_vertex_list
*)
235 _mesa_alloc_instruction(ctx
, tnl
->save
.opcode_vertex_list
, sizeof(*node
));
240 /* Duplicate our template, increment refcounts to the storage structs:
242 _mesa_memcpy(node
->attrsz
, tnl
->save
.attrsz
, sizeof(node
->attrsz
));
243 node
->vertex_size
= tnl
->save
.vertex_size
;
244 node
->buffer
= tnl
->save
.buffer
;
245 node
->count
= tnl
->save
.initial_counter
- tnl
->save
.counter
;
246 node
->wrap_count
= tnl
->save
.copied
.nr
;
247 node
->have_materials
= tnl
->save
.have_materials
;
248 node
->dangling_attr_ref
= tnl
->save
.dangling_attr_ref
;
249 node
->normal_lengths
= NULL
;
250 node
->prim
= tnl
->save
.prim
;
251 node
->prim_count
= tnl
->save
.prim_count
;
252 node
->vertex_store
= tnl
->save
.vertex_store
;
253 node
->prim_store
= tnl
->save
.prim_store
;
255 node
->vertex_store
->refcount
++;
256 node
->prim_store
->refcount
++;
258 assert(node
->attrsz
[_TNL_ATTRIB_POS
] != 0 ||
261 if (tnl
->save
.dangling_attr_ref
)
262 ctx
->ListState
.CurrentList
->flags
|= MESA_DLIST_DANGLING_REFS
;
264 /* Maybe calculate normal lengths:
266 if (tnl
->CalcDListNormalLengths
&&
267 node
->attrsz
[_TNL_ATTRIB_NORMAL
] == 3 &&
268 !(ctx
->ListState
.CurrentList
->flags
& MESA_DLIST_DANGLING_REFS
))
269 build_normal_lengths( node
);
272 tnl
->save
.vertex_store
->used
+= tnl
->save
.vertex_size
* node
->count
;
273 tnl
->save
.prim_store
->used
+= node
->prim_count
;
275 /* Decide whether the storage structs are full, or can be used for
276 * the next vertex lists as well.
278 if (tnl
->save
.vertex_store
->used
>
279 SAVE_BUFFER_SIZE
- 16 * (tnl
->save
.vertex_size
+ 4)) {
281 tnl
->save
.vertex_store
->refcount
--;
282 assert(tnl
->save
.vertex_store
->refcount
!= 0);
283 tnl
->save
.vertex_store
= alloc_vertex_store( ctx
);
284 tnl
->save
.vbptr
= tnl
->save
.vertex_store
->buffer
;
287 if (tnl
->save
.prim_store
->used
> SAVE_PRIM_SIZE
- 6) {
288 tnl
->save
.prim_store
->refcount
--;
289 assert(tnl
->save
.prim_store
->refcount
!= 0);
290 tnl
->save
.prim_store
= alloc_prim_store( ctx
);
293 /* Reset our structures for the next run of vertices:
295 _save_reset_counters( ctx
);
297 /* Copy duplicated vertices
299 tnl
->save
.copied
.nr
= _save_copy_vertices( ctx
, node
);
302 /* Deal with GL_COMPILE_AND_EXECUTE:
304 if (ctx
->ExecuteFlag
) {
305 _tnl_playback_vertex_list( ctx
, (void *) node
);
310 /* TODO -- If no new vertices have been stored, don't bother saving
313 static void _save_wrap_buffers( GLcontext
*ctx
)
315 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
316 GLint i
= tnl
->save
.prim_count
- 1;
319 assert(i
< (GLint
) tnl
->save
.prim_max
);
322 /* Close off in-progress primitive.
324 tnl
->save
.prim
[i
].count
= ((tnl
->save
.initial_counter
- tnl
->save
.counter
) -
325 tnl
->save
.prim
[i
].start
);
326 mode
= tnl
->save
.prim
[i
].mode
& ~(PRIM_BEGIN
|PRIM_END
);
328 /* store the copied vertices, and allocate a new list.
330 _save_compile_vertex_list( ctx
);
332 /* Restart interrupted primitive
334 tnl
->save
.prim
[0].mode
= mode
;
335 tnl
->save
.prim
[0].start
= 0;
336 tnl
->save
.prim
[0].count
= 0;
337 tnl
->save
.prim_count
= 1;
342 /* Called only when buffers are wrapped as the result of filling the
343 * vertex_store struct.
345 static void _save_wrap_filled_vertex( GLcontext
*ctx
)
347 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
348 GLfloat
*data
= tnl
->save
.copied
.buffer
;
351 /* Emit a glEnd to close off the last vertex list.
353 _save_wrap_buffers( ctx
);
355 /* Copy stored stored vertices to start of new list.
357 assert(tnl
->save
.counter
> tnl
->save
.copied
.nr
);
359 for (i
= 0 ; i
< tnl
->save
.copied
.nr
; i
++) {
360 _mesa_memcpy( tnl
->save
.vbptr
, data
, tnl
->save
.vertex_size
* sizeof(GLfloat
));
361 data
+= tnl
->save
.vertex_size
;
362 tnl
->save
.vbptr
+= tnl
->save
.vertex_size
;
368 static void _save_copy_to_current( GLcontext
*ctx
)
370 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
373 for (i
= _TNL_ATTRIB_POS
+1 ; i
<= _TNL_ATTRIB_INDEX
; i
++) {
374 if (tnl
->save
.attrsz
[i
]) {
375 tnl
->save
.currentsz
[i
][0] = tnl
->save
.attrsz
[i
];
376 COPY_CLEAN_4V(tnl
->save
.current
[i
],
378 tnl
->save
.attrptr
[i
]);
382 /* Edgeflag requires special treatment:
384 * TODO: change edgeflag to GLfloat in Mesa.
386 if (tnl
->save
.attrsz
[_TNL_ATTRIB_EDGEFLAG
]) {
387 ctx
->ListState
.ActiveEdgeFlag
= 1;
388 tnl
->save
.CurrentFloatEdgeFlag
=
389 tnl
->save
.attrptr
[_TNL_ATTRIB_EDGEFLAG
][0];
390 ctx
->ListState
.CurrentEdgeFlag
=
391 (tnl
->save
.CurrentFloatEdgeFlag
== 1.0);
396 static void _save_copy_from_current( GLcontext
*ctx
)
398 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
401 for (i
= _TNL_ATTRIB_POS
+1 ; i
<= _TNL_ATTRIB_INDEX
; i
++)
402 switch (tnl
->save
.attrsz
[i
]) {
403 case 4: tnl
->save
.attrptr
[i
][3] = tnl
->save
.current
[i
][3];
404 case 3: tnl
->save
.attrptr
[i
][2] = tnl
->save
.current
[i
][2];
405 case 2: tnl
->save
.attrptr
[i
][1] = tnl
->save
.current
[i
][1];
406 case 1: tnl
->save
.attrptr
[i
][0] = tnl
->save
.current
[i
][0];
410 /* Edgeflag requires special treatment:
412 if (tnl
->save
.attrsz
[_TNL_ATTRIB_EDGEFLAG
]) {
413 tnl
->save
.CurrentFloatEdgeFlag
= (GLfloat
)ctx
->ListState
.CurrentEdgeFlag
;
414 tnl
->save
.attrptr
[_TNL_ATTRIB_EDGEFLAG
][0] = tnl
->save
.CurrentFloatEdgeFlag
;
421 /* Flush existing data, set new attrib size, replay copied vertices.
423 static void _save_upgrade_vertex( GLcontext
*ctx
,
427 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
432 /* Store the current run of vertices, and emit a GL_END. Emit a
433 * BEGIN in the new buffer.
435 if (tnl
->save
.initial_counter
!= tnl
->save
.counter
)
436 _save_wrap_buffers( ctx
);
438 assert( tnl
->save
.copied
.nr
== 0 );
440 /* Do a COPY_TO_CURRENT to ensure back-copying works for the case
441 * when the attribute already exists in the vertex and is having
442 * its size increased.
444 _save_copy_to_current( ctx
);
448 oldsz
= tnl
->save
.attrsz
[attr
];
449 tnl
->save
.attrsz
[attr
] = newsz
;
451 tnl
->save
.vertex_size
+= newsz
- oldsz
;
452 tnl
->save
.counter
= ((SAVE_BUFFER_SIZE
- tnl
->save
.vertex_store
->used
) /
453 tnl
->save
.vertex_size
);
454 if (tnl
->save
.counter
> ctx
->Const
.MaxArrayLockSize
)
455 tnl
->save
.counter
= ctx
->Const
.MaxArrayLockSize
;
456 tnl
->save
.initial_counter
= tnl
->save
.counter
;
458 /* Recalculate all the attrptr[] values:
460 for (i
= 0, tmp
= tnl
->save
.vertex
; i
< _TNL_ATTRIB_MAX
; i
++) {
461 if (tnl
->save
.attrsz
[i
]) {
462 tnl
->save
.attrptr
[i
] = tmp
;
463 tmp
+= tnl
->save
.attrsz
[i
];
466 tnl
->save
.attrptr
[i
] = NULL
; /* will not be dereferenced. */
469 /* Copy from current to repopulate the vertex with correct values.
471 _save_copy_from_current( ctx
);
473 /* Replay stored vertices to translate them to new format here.
475 * If there are copied vertices and the new (upgraded) attribute
476 * has not been defined before, this list is somewhat degenerate,
477 * and will need fixup at runtime.
479 if (tnl
->save
.copied
.nr
)
481 GLfloat
*data
= tnl
->save
.copied
.buffer
;
482 GLfloat
*dest
= tnl
->save
.buffer
;
485 /* Need to note this and fix up at runtime (or loopback):
487 if (tnl
->save
.currentsz
[attr
][0] == 0) {
489 tnl
->save
.dangling_attr_ref
= GL_TRUE
;
491 /* _mesa_debug(NULL, "_save_upgrade_vertex: dangling reference attr %d\n", */
495 /* The current strategy is to punt these degenerate cases
496 * through _tnl_loopback_vertex_list(), a lower-performance
497 * option. To minimize the impact of this, artificially
498 * reduce the size of this vertex_list.
500 if (t
->save
.counter
> 10) {
501 t
->save
.initial_counter
= 10;
502 t
->save
.counter
= 10;
507 for (i
= 0 ; i
< tnl
->save
.copied
.nr
; i
++) {
508 for (j
= 0 ; j
< _TNL_ATTRIB_MAX
; j
++) {
509 if (tnl
->save
.attrsz
[j
]) {
512 COPY_CLEAN_4V( dest
, oldsz
, data
);
517 COPY_SZ_4V( dest
, newsz
, tnl
->save
.current
[attr
] );
522 GLint sz
= tnl
->save
.attrsz
[j
];
523 COPY_SZ_4V( dest
, sz
, data
);
531 tnl
->save
.vbptr
= dest
;
532 tnl
->save
.counter
-= tnl
->save
.copied
.nr
;
539 /* Helper function for 'CHOOSE' macro. Do what's necessary when an
540 * entrypoint is called for the first time.
542 static void do_choose( GLuint attr
, GLuint sz
,
543 void (*attr_func
)( const GLfloat
*),
544 void (*choose1
)( const GLfloat
*),
545 void (*choose2
)( const GLfloat
*),
546 void (*choose3
)( const GLfloat
*),
547 void (*choose4
)( const GLfloat
*),
550 GET_CURRENT_CONTEXT( ctx
);
551 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
552 static GLfloat id
[4] = { 0, 0, 0, 1 };
555 if (tnl
->save
.attrsz
[attr
] < sz
) {
556 /* New size is larger. Need to flush existing vertices and get
557 * an enlarged vertex format.
559 _save_upgrade_vertex( ctx
, attr
, sz
);
562 /* New size is equal or smaller - just need to fill in some
565 for (i
= sz
; i
<= tnl
->save
.attrsz
[attr
] ; i
++)
566 tnl
->save
.attrptr
[attr
][i
-1] = id
[i
-1];
569 /* Reset any active pointers for this attribute
571 tnl
->save
.tabfv
[attr
][0] = choose1
;
572 tnl
->save
.tabfv
[attr
][1] = choose2
;
573 tnl
->save
.tabfv
[attr
][2] = choose3
;
574 tnl
->save
.tabfv
[attr
][3] = choose4
;
576 /* Update the secondary dispatch table with the new function
578 tnl
->save
.tabfv
[attr
][sz
-1] = attr_func
;
585 /* Only one size for each attribute may be active at once. Eg. if
586 * Color3f is installed/active, then Color4f may not be, even if the
587 * vertex actually contains 4 color coordinates. This is because the
588 * 3f version won't otherwise set color[3] to 1.0 -- this is the job
589 * of the chooser function when switching between Color4f and Color3f.
591 #define ATTRFV( ATTR, N ) \
592 static void save_choose_##ATTR##_##N( const GLfloat *v ); \
594 static void save_attrib_##ATTR##_##N( const GLfloat *v ) \
596 GET_CURRENT_CONTEXT( ctx ); \
597 TNLcontext *tnl = TNL_CONTEXT(ctx); \
602 if (N>0) tnl->save.vbptr[0] = v[0]; \
603 if (N>1) tnl->save.vbptr[1] = v[1]; \
604 if (N>2) tnl->save.vbptr[2] = v[2]; \
605 if (N>3) tnl->save.vbptr[3] = v[3]; \
607 for (i = N; i < tnl->save.vertex_size; i++) \
608 tnl->save.vbptr[i] = tnl->save.vertex[i]; \
610 tnl->save.vbptr += tnl->save.vertex_size; \
612 if (--tnl->save.counter == 0) \
613 _save_wrap_filled_vertex( ctx ); \
616 GLfloat *dest = tnl->save.attrptr[ATTR]; \
617 if (N>0) dest[0] = v[0]; \
618 if (N>1) dest[1] = v[1]; \
619 if (N>2) dest[2] = v[2]; \
620 if (N>3) dest[3] = v[3]; \
624 #define CHOOSE( ATTR, N ) \
625 static void save_choose_##ATTR##_##N( const GLfloat *v ) \
628 save_attrib_##ATTR##_##N, \
629 save_choose_##ATTR##_1, \
630 save_choose_##ATTR##_2, \
631 save_choose_##ATTR##_3, \
632 save_choose_##ATTR##_4, \
637 static void save_init_##ATTR( TNLcontext *tnl ) \
639 tnl->save.tabfv[ATTR][0] = save_choose_##ATTR##_1; \
640 tnl->save.tabfv[ATTR][1] = save_choose_##ATTR##_2; \
641 tnl->save.tabfv[ATTR][2] = save_choose_##ATTR##_3; \
642 tnl->save.tabfv[ATTR][3] = save_choose_##ATTR##_4; \
645 #define ATTRS( ATTRIB ) \
646 ATTRFV( ATTRIB, 1 ) \
647 ATTRFV( ATTRIB, 2 ) \
648 ATTRFV( ATTRIB, 3 ) \
649 ATTRFV( ATTRIB, 4 ) \
650 CHOOSE( ATTRIB, 1 ) \
651 CHOOSE( ATTRIB, 2 ) \
652 CHOOSE( ATTRIB, 3 ) \
653 CHOOSE( ATTRIB, 4 ) \
657 /* Generate a lot of functions. These are the actual worker
658 * functions, which are equivalent to those generated via codegen
679 static void _save_reset_vertex( GLcontext
*ctx
)
681 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
701 for (i
= 0 ; i
< _TNL_ATTRIB_MAX
; i
++)
702 tnl
->save
.attrsz
[i
] = 0;
704 tnl
->save
.vertex_size
= 0;
705 tnl
->save
.have_materials
= 0;
707 _save_reset_counters( ctx
);
712 /* Cope with aliasing of classic Vertex, Normal, etc. and the fan-out
713 * of glMultTexCoord and glProgramParamterNV by routing all these
714 * through a second level dispatch table.
716 #define DISPATCH_ATTRFV( ATTR, COUNT, P ) \
718 GET_CURRENT_CONTEXT( ctx ); \
719 TNLcontext *tnl = TNL_CONTEXT(ctx); \
720 tnl->save.tabfv[ATTR][COUNT-1]( P ); \
723 #define DISPATCH_ATTR1FV( ATTR, V ) DISPATCH_ATTRFV( ATTR, 1, V )
724 #define DISPATCH_ATTR2FV( ATTR, V ) DISPATCH_ATTRFV( ATTR, 2, V )
725 #define DISPATCH_ATTR3FV( ATTR, V ) DISPATCH_ATTRFV( ATTR, 3, V )
726 #define DISPATCH_ATTR4FV( ATTR, V ) DISPATCH_ATTRFV( ATTR, 4, V )
728 #define DISPATCH_ATTR1F( ATTR, S ) DISPATCH_ATTRFV( ATTR, 1, &(S) )
730 #if defined(USE_X86_ASM) && 0 /* will break register calling convention */
733 #define DISPATCH_ATTR2F( ATTR, S,T ) DISPATCH_ATTRFV( ATTR, 2, &(S) )
734 #define DISPATCH_ATTR3F( ATTR, S,T,R ) DISPATCH_ATTRFV( ATTR, 3, &(S) )
735 #define DISPATCH_ATTR4F( ATTR, S,T,R,Q ) DISPATCH_ATTRFV( ATTR, 4, &(S) )
739 #define DISPATCH_ATTR2F( ATTR, S,T ) \
742 v[0] = S; v[1] = T; \
743 DISPATCH_ATTR2FV( ATTR, v ); \
745 #define DISPATCH_ATTR3F( ATTR, S,T,R ) \
748 v[0] = S; v[1] = T; v[2] = R; \
749 DISPATCH_ATTR3FV( ATTR, v ); \
751 #define DISPATCH_ATTR4F( ATTR, S,T,R,Q ) \
754 v[0] = S; v[1] = T; v[2] = R; v[3] = Q; \
755 DISPATCH_ATTR4FV( ATTR, v ); \
760 static void enum_error( void )
762 GET_CURRENT_CONTEXT( ctx
);
763 _mesa_compile_error( ctx
, GL_INVALID_ENUM
, "glVertexAttrib" );
766 static void GLAPIENTRY
_save_Vertex2f( GLfloat x
, GLfloat y
)
768 DISPATCH_ATTR2F( _TNL_ATTRIB_POS
, x
, y
);
771 static void GLAPIENTRY
_save_Vertex2fv( const GLfloat
*v
)
773 DISPATCH_ATTR2FV( _TNL_ATTRIB_POS
, v
);
776 static void GLAPIENTRY
_save_Vertex3f( GLfloat x
, GLfloat y
, GLfloat z
)
778 DISPATCH_ATTR3F( _TNL_ATTRIB_POS
, x
, y
, z
);
781 static void GLAPIENTRY
_save_Vertex3fv( const GLfloat
*v
)
783 DISPATCH_ATTR3FV( _TNL_ATTRIB_POS
, v
);
786 static void GLAPIENTRY
_save_Vertex4f( GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
788 DISPATCH_ATTR4F( _TNL_ATTRIB_POS
, x
, y
, z
, w
);
791 static void GLAPIENTRY
_save_Vertex4fv( const GLfloat
*v
)
793 DISPATCH_ATTR4FV( _TNL_ATTRIB_POS
, v
);
796 static void GLAPIENTRY
_save_TexCoord1f( GLfloat x
)
798 DISPATCH_ATTR1F( _TNL_ATTRIB_TEX0
, x
);
801 static void GLAPIENTRY
_save_TexCoord1fv( const GLfloat
*v
)
803 DISPATCH_ATTR1FV( _TNL_ATTRIB_TEX0
, v
);
806 static void GLAPIENTRY
_save_TexCoord2f( GLfloat x
, GLfloat y
)
808 DISPATCH_ATTR2F( _TNL_ATTRIB_TEX0
, x
, y
);
811 static void GLAPIENTRY
_save_TexCoord2fv( const GLfloat
*v
)
813 DISPATCH_ATTR2FV( _TNL_ATTRIB_TEX0
, v
);
816 static void GLAPIENTRY
_save_TexCoord3f( GLfloat x
, GLfloat y
, GLfloat z
)
818 DISPATCH_ATTR3F( _TNL_ATTRIB_TEX0
, x
, y
, z
);
821 static void GLAPIENTRY
_save_TexCoord3fv( const GLfloat
*v
)
823 DISPATCH_ATTR3FV( _TNL_ATTRIB_TEX0
, v
);
826 static void GLAPIENTRY
_save_TexCoord4f( GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
828 DISPATCH_ATTR4F( _TNL_ATTRIB_TEX0
, x
, y
, z
, w
);
831 static void GLAPIENTRY
_save_TexCoord4fv( const GLfloat
*v
)
833 DISPATCH_ATTR4FV( _TNL_ATTRIB_TEX0
, v
);
836 static void GLAPIENTRY
_save_Normal3f( GLfloat x
, GLfloat y
, GLfloat z
)
838 DISPATCH_ATTR3F( _TNL_ATTRIB_NORMAL
, x
, y
, z
);
841 static void GLAPIENTRY
_save_Normal3fv( const GLfloat
*v
)
843 DISPATCH_ATTR3FV( _TNL_ATTRIB_NORMAL
, v
);
846 static void GLAPIENTRY
_save_FogCoordfEXT( GLfloat x
)
848 DISPATCH_ATTR1F( _TNL_ATTRIB_FOG
, x
);
851 static void GLAPIENTRY
_save_FogCoordfvEXT( const GLfloat
*v
)
853 DISPATCH_ATTR1FV( _TNL_ATTRIB_FOG
, v
);
856 static void GLAPIENTRY
_save_Color3f( GLfloat x
, GLfloat y
, GLfloat z
)
858 DISPATCH_ATTR3F( _TNL_ATTRIB_COLOR0
, x
, y
, z
);
861 static void GLAPIENTRY
_save_Color3fv( const GLfloat
*v
)
863 DISPATCH_ATTR3FV( _TNL_ATTRIB_COLOR0
, v
);
866 static void GLAPIENTRY
_save_Color4f( GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
868 DISPATCH_ATTR4F( _TNL_ATTRIB_COLOR0
, x
, y
, z
, w
);
871 static void GLAPIENTRY
_save_Color4fv( const GLfloat
*v
)
873 DISPATCH_ATTR4FV( _TNL_ATTRIB_COLOR0
, v
);
876 static void GLAPIENTRY
_save_SecondaryColor3fEXT( GLfloat x
, GLfloat y
, GLfloat z
)
878 DISPATCH_ATTR3F( _TNL_ATTRIB_COLOR1
, x
, y
, z
);
881 static void GLAPIENTRY
_save_SecondaryColor3fvEXT( const GLfloat
*v
)
883 DISPATCH_ATTR3FV( _TNL_ATTRIB_COLOR1
, v
);
886 static void GLAPIENTRY
_save_MultiTexCoord1f( GLenum target
, GLfloat x
)
888 GLuint attr
= (target
& 0x7) + _TNL_ATTRIB_TEX0
;
889 DISPATCH_ATTR1F( attr
, x
);
892 static void GLAPIENTRY
_save_MultiTexCoord1fv( GLenum target
, const GLfloat
*v
)
894 GLuint attr
= (target
& 0x7) + _TNL_ATTRIB_TEX0
;
895 DISPATCH_ATTR1FV( attr
, v
);
898 static void GLAPIENTRY
_save_MultiTexCoord2f( GLenum target
, GLfloat x
, GLfloat y
)
900 GLuint attr
= (target
& 0x7) + _TNL_ATTRIB_TEX0
;
901 DISPATCH_ATTR2F( attr
, x
, y
);
904 static void GLAPIENTRY
_save_MultiTexCoord2fv( GLenum target
, const GLfloat
*v
)
906 GLuint attr
= (target
& 0x7) + _TNL_ATTRIB_TEX0
;
907 DISPATCH_ATTR2FV( attr
, v
);
910 static void GLAPIENTRY
_save_MultiTexCoord3f( GLenum target
, GLfloat x
, GLfloat y
,
913 GLuint attr
= (target
& 0x7) + _TNL_ATTRIB_TEX0
;
914 DISPATCH_ATTR3F( attr
, x
, y
, z
);
917 static void GLAPIENTRY
_save_MultiTexCoord3fv( GLenum target
, const GLfloat
*v
)
919 GLuint attr
= (target
& 0x7) + _TNL_ATTRIB_TEX0
;
920 DISPATCH_ATTR3FV( attr
, v
);
923 static void GLAPIENTRY
_save_MultiTexCoord4f( GLenum target
, GLfloat x
, GLfloat y
,
924 GLfloat z
, GLfloat w
)
926 GLuint attr
= (target
& 0x7) + _TNL_ATTRIB_TEX0
;
927 DISPATCH_ATTR4F( attr
, x
, y
, z
, w
);
930 static void GLAPIENTRY
_save_MultiTexCoord4fv( GLenum target
, const GLfloat
*v
)
932 GLuint attr
= (target
& 0x7) + _TNL_ATTRIB_TEX0
;
933 DISPATCH_ATTR4FV( attr
, v
);
936 static void GLAPIENTRY
_save_VertexAttrib1fNV( GLuint index
, GLfloat x
)
938 if (index
< VERT_ATTRIB_MAX
)
939 DISPATCH_ATTR1F( index
, x
);
944 static void GLAPIENTRY
_save_VertexAttrib1fvNV( GLuint index
, const GLfloat
*v
)
946 if (index
< VERT_ATTRIB_MAX
)
947 DISPATCH_ATTR1FV( index
, v
);
952 static void GLAPIENTRY
_save_VertexAttrib2fNV( GLuint index
, GLfloat x
, GLfloat y
)
954 if (index
< VERT_ATTRIB_MAX
)
955 DISPATCH_ATTR2F( index
, x
, y
);
960 static void GLAPIENTRY
_save_VertexAttrib2fvNV( GLuint index
, const GLfloat
*v
)
962 if (index
< VERT_ATTRIB_MAX
)
963 DISPATCH_ATTR2FV( index
, v
);
968 static void GLAPIENTRY
_save_VertexAttrib3fNV( GLuint index
, GLfloat x
, GLfloat y
,
971 if (index
< VERT_ATTRIB_MAX
)
972 DISPATCH_ATTR3F( index
, x
, y
, z
);
977 static void GLAPIENTRY
_save_VertexAttrib3fvNV( GLuint index
, const GLfloat
*v
)
979 if (index
< VERT_ATTRIB_MAX
)
980 DISPATCH_ATTR3FV( index
, v
);
985 static void GLAPIENTRY
_save_VertexAttrib4fNV( GLuint index
, GLfloat x
, GLfloat y
,
986 GLfloat z
, GLfloat w
)
988 if (index
< VERT_ATTRIB_MAX
)
989 DISPATCH_ATTR4F( index
, x
, y
, z
, w
);
994 static void GLAPIENTRY
_save_VertexAttrib4fvNV( GLuint index
, const GLfloat
*v
)
996 if (index
< VERT_ATTRIB_MAX
)
997 DISPATCH_ATTR4FV( index
, v
);
1003 static void GLAPIENTRY
1004 _save_VertexAttrib1fARB( GLuint index
, GLfloat x
)
1006 if (index
< VERT_ATTRIB_MAX
)
1007 DISPATCH_ATTR1F( index
, x
);
1012 static void GLAPIENTRY
1013 _save_VertexAttrib1fvARB( GLuint index
, const GLfloat
*v
)
1015 if (index
< VERT_ATTRIB_MAX
)
1016 DISPATCH_ATTR1FV( index
, v
);
1021 static void GLAPIENTRY
1022 _save_VertexAttrib2fARB( GLuint index
, GLfloat x
, GLfloat y
)
1024 if (index
< VERT_ATTRIB_MAX
)
1025 DISPATCH_ATTR2F( index
, x
, y
);
1030 static void GLAPIENTRY
1031 _save_VertexAttrib2fvARB( GLuint index
, const GLfloat
*v
)
1033 if (index
< VERT_ATTRIB_MAX
)
1034 DISPATCH_ATTR2FV( index
, v
);
1039 static void GLAPIENTRY
1040 _save_VertexAttrib3fARB( GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
)
1042 if (index
< VERT_ATTRIB_MAX
)
1043 DISPATCH_ATTR3F( index
, x
, y
, z
);
1048 static void GLAPIENTRY
1049 _save_VertexAttrib3fvARB( GLuint index
, const GLfloat
*v
)
1051 if (index
< VERT_ATTRIB_MAX
)
1052 DISPATCH_ATTR3FV( index
, v
);
1057 static void GLAPIENTRY
1058 _save_VertexAttrib4fARB( GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1060 if (index
< VERT_ATTRIB_MAX
)
1061 DISPATCH_ATTR4F( index
, x
, y
, z
, w
);
1066 static void GLAPIENTRY
1067 _save_VertexAttrib4fvARB( GLuint index
, const GLfloat
*v
)
1069 if (index
< VERT_ATTRIB_MAX
)
1070 DISPATCH_ATTR4FV( index
, v
);
1078 * These are treated as per-vertex attributes, at indices above where
1079 * the NV_vertex_program leaves off. There are a lot of good things
1080 * about treating materials this way.
1082 * However: I don't want to double the number of generated functions
1083 * just to cope with this, so I unroll the 'C' varients of CHOOSE and
1084 * ATTRF into this function, and dispense with codegen and
1085 * second-level dispatch.
1087 * There is no aliasing of material attributes with other entrypoints.
1089 #define MAT_ATTR( A, N, params ) \
1091 if (tnl->save.attrsz[A] < N) { \
1092 _save_upgrade_vertex( ctx, A, N ); \
1093 tnl->save.have_materials = GL_TRUE; \
1097 GLfloat *dest = tnl->save.attrptr[A]; \
1098 if (N>0) dest[0] = params[0]; \
1099 if (N>1) dest[1] = params[1]; \
1100 if (N>2) dest[2] = params[2]; \
1101 if (N>3) dest[3] = params[3]; \
1106 #define MAT( ATTR, N, face, params ) \
1108 if (face != GL_BACK) \
1109 MAT_ATTR( ATTR, N, params ); /* front */ \
1110 if (face != GL_FRONT) \
1111 MAT_ATTR( ATTR + 1, N, params ); /* back */ \
1115 /* NOTE: Have to remove/deal-with colormaterial crossovers, probably
1116 * later on - in the meantime just store everything.
1118 static void GLAPIENTRY
_save_Materialfv( GLenum face
, GLenum pname
,
1119 const GLfloat
*params
)
1121 GET_CURRENT_CONTEXT( ctx
);
1122 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
1126 MAT( _TNL_ATTRIB_MAT_FRONT_EMISSION
, 4, face
, params
);
1129 MAT( _TNL_ATTRIB_MAT_FRONT_AMBIENT
, 4, face
, params
);
1132 MAT( _TNL_ATTRIB_MAT_FRONT_DIFFUSE
, 4, face
, params
);
1135 MAT( _TNL_ATTRIB_MAT_FRONT_SPECULAR
, 4, face
, params
);
1138 MAT( _TNL_ATTRIB_MAT_FRONT_SHININESS
, 1, face
, params
);
1140 case GL_COLOR_INDEXES
:
1141 MAT( _TNL_ATTRIB_MAT_FRONT_INDEXES
, 3, face
, params
);
1143 case GL_AMBIENT_AND_DIFFUSE
:
1144 MAT( _TNL_ATTRIB_MAT_FRONT_AMBIENT
, 4, face
, params
);
1145 MAT( _TNL_ATTRIB_MAT_FRONT_DIFFUSE
, 4, face
, params
);
1148 _mesa_compile_error( ctx
, GL_INVALID_ENUM
, "glMaterialfv" );
1154 #define IDX_ATTR( A, IDX ) \
1156 GET_CURRENT_CONTEXT( ctx ); \
1157 TNLcontext *tnl = TNL_CONTEXT(ctx); \
1159 if (tnl->save.attrsz[A] < 1) { \
1160 _save_upgrade_vertex( ctx, A, 1 ); \
1164 GLfloat *dest = tnl->save.attrptr[A]; \
1170 static void GLAPIENTRY
_save_EdgeFlag( GLboolean b
)
1172 IDX_ATTR( _TNL_ATTRIB_EDGEFLAG
, (GLfloat
)b
);
1175 static void GLAPIENTRY
_save_EdgeFlagv( const GLboolean
*v
)
1177 IDX_ATTR( _TNL_ATTRIB_EDGEFLAG
, (GLfloat
)(v
[0]) );
1180 static void GLAPIENTRY
_save_Indexf( GLfloat f
)
1182 IDX_ATTR( _TNL_ATTRIB_INDEX
, f
);
1185 static void GLAPIENTRY
_save_Indexfv( const GLfloat
*f
)
1187 IDX_ATTR( _TNL_ATTRIB_INDEX
, f
[0] );
1193 /* Cope with EvalCoord/CallList called within a begin/end object:
1194 * -- Flush current buffer
1195 * -- Fallback to opcodes for the rest of the begin/end object.
1197 #define FALLBACK(ctx) \
1199 TNLcontext *tnl = TNL_CONTEXT(ctx); \
1201 if (tnl->save.initial_counter != tnl->save.counter || \
1202 tnl->save.prim_count) \
1203 _save_compile_vertex_list( ctx ); \
1205 _save_copy_to_current( ctx ); \
1206 _save_reset_vertex( ctx ); \
1207 _mesa_install_save_vtxfmt( ctx, &ctx->ListState.ListVtxfmt ); \
1208 ctx->Driver.SaveNeedFlush = 0; \
1211 static void GLAPIENTRY
_save_EvalCoord1f( GLfloat u
)
1213 GET_CURRENT_CONTEXT(ctx
);
1215 ctx
->Save
->EvalCoord1f( u
);
1218 static void GLAPIENTRY
_save_EvalCoord1fv( const GLfloat
*v
)
1220 GET_CURRENT_CONTEXT(ctx
);
1222 ctx
->Save
->EvalCoord1fv( v
);
1225 static void GLAPIENTRY
_save_EvalCoord2f( GLfloat u
, GLfloat v
)
1227 GET_CURRENT_CONTEXT(ctx
);
1229 ctx
->Save
->EvalCoord2f( u
, v
);
1232 static void GLAPIENTRY
_save_EvalCoord2fv( const GLfloat
*v
)
1234 GET_CURRENT_CONTEXT(ctx
);
1236 ctx
->Save
->EvalCoord2fv( v
);
1239 static void GLAPIENTRY
_save_EvalPoint1( GLint i
)
1241 GET_CURRENT_CONTEXT(ctx
);
1243 ctx
->Save
->EvalPoint1( i
);
1246 static void GLAPIENTRY
_save_EvalPoint2( GLint i
, GLint j
)
1248 GET_CURRENT_CONTEXT(ctx
);
1250 ctx
->Save
->EvalPoint2( i
, j
);
1253 static void GLAPIENTRY
_save_CallList( GLuint l
)
1255 GET_CURRENT_CONTEXT(ctx
);
1257 ctx
->Save
->CallList( l
);
1260 static void GLAPIENTRY
_save_CallLists( GLsizei n
, GLenum type
, const GLvoid
*v
)
1262 GET_CURRENT_CONTEXT(ctx
);
1264 ctx
->Save
->CallLists( n
, type
, v
);
1270 /* This begin is hooked into ... Updating of
1271 * ctx->Driver.CurrentSavePrimitive is already taken care of.
1273 static GLboolean
_save_NotifyBegin( GLcontext
*ctx
, GLenum mode
)
1275 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
1278 GLuint i
= tnl
->save
.prim_count
++;
1280 assert(i
< tnl
->save
.prim_max
);
1281 tnl
->save
.prim
[i
].mode
= mode
| PRIM_BEGIN
;
1282 tnl
->save
.prim
[i
].start
= tnl
->save
.initial_counter
- tnl
->save
.counter
;
1283 tnl
->save
.prim
[i
].count
= 0;
1285 _mesa_install_save_vtxfmt( ctx
, &tnl
->save_vtxfmt
);
1286 ctx
->Driver
.SaveNeedFlush
= 1;
1295 static void GLAPIENTRY
_save_End( void )
1297 GET_CURRENT_CONTEXT( ctx
);
1298 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
1299 GLint i
= tnl
->save
.prim_count
- 1;
1301 ctx
->Driver
.CurrentSavePrimitive
= PRIM_OUTSIDE_BEGIN_END
;
1302 tnl
->save
.prim
[i
].mode
|= PRIM_END
;
1303 tnl
->save
.prim
[i
].count
= ((tnl
->save
.initial_counter
- tnl
->save
.counter
) -
1304 tnl
->save
.prim
[i
].start
);
1306 if (i
== (GLint
) tnl
->save
.prim_max
- 1) {
1307 _save_compile_vertex_list( ctx
);
1308 assert(tnl
->save
.copied
.nr
== 0);
1311 /* Swap out this vertex format while outside begin/end. Any color,
1312 * etc. received between here and the next begin will be compiled
1315 _mesa_install_save_vtxfmt( ctx
, &ctx
->ListState
.ListVtxfmt
);
1319 /* These are all errors as this vtxfmt is only installed inside
1322 static void GLAPIENTRY
_save_DrawElements(GLenum mode
, GLsizei count
, GLenum type
,
1323 const GLvoid
*indices
)
1325 GET_CURRENT_CONTEXT(ctx
);
1326 (void) mode
; (void) count
; (void) type
; (void) indices
;
1327 _mesa_compile_error( ctx
, GL_INVALID_OPERATION
, "glDrawElements" );
1331 static void GLAPIENTRY
_save_DrawRangeElements(GLenum mode
,
1332 GLuint start
, GLuint end
,
1333 GLsizei count
, GLenum type
,
1334 const GLvoid
*indices
)
1336 GET_CURRENT_CONTEXT(ctx
);
1337 (void) mode
; (void) start
; (void) end
; (void) count
; (void) type
; (void) indices
;
1338 _mesa_compile_error( ctx
, GL_INVALID_OPERATION
, "glDrawRangeElements" );
1341 static void GLAPIENTRY
_save_DrawArrays(GLenum mode
, GLint start
, GLsizei count
)
1343 GET_CURRENT_CONTEXT(ctx
);
1344 (void) mode
; (void) start
; (void) count
;
1345 _mesa_compile_error( ctx
, GL_INVALID_OPERATION
, "glDrawArrays" );
1348 static void GLAPIENTRY
_save_Rectf( GLfloat x1
, GLfloat y1
, GLfloat x2
, GLfloat y2
)
1350 GET_CURRENT_CONTEXT(ctx
);
1351 (void) x1
; (void) y1
; (void) x2
; (void) y2
;
1352 _mesa_compile_error( ctx
, GL_INVALID_OPERATION
, "glRectf" );
1355 static void GLAPIENTRY
_save_EvalMesh1( GLenum mode
, GLint i1
, GLint i2
)
1357 GET_CURRENT_CONTEXT(ctx
);
1358 (void) mode
; (void) i1
; (void) i2
;
1359 _mesa_compile_error( ctx
, GL_INVALID_OPERATION
, "glEvalMesh1" );
1362 static void GLAPIENTRY
_save_EvalMesh2( GLenum mode
, GLint i1
, GLint i2
,
1363 GLint j1
, GLint j2
)
1365 GET_CURRENT_CONTEXT(ctx
);
1366 (void) mode
; (void) i1
; (void) i2
; (void) j1
; (void) j2
;
1367 _mesa_compile_error( ctx
, GL_INVALID_OPERATION
, "glEvalMesh2" );
1370 static void GLAPIENTRY
_save_Begin( GLenum mode
)
1372 GET_CURRENT_CONTEXT( ctx
);
1374 _mesa_compile_error( ctx
, GL_INVALID_OPERATION
, "Recursive glBegin" );
1378 /* Unlike the functions above, these are to be hooked into the vtxfmt
1379 * maintained in ctx->ListState, active when the list is known or
1380 * suspected to be outside any begin/end primitive.
1382 static void GLAPIENTRY
_save_OBE_Rectf( GLfloat x1
, GLfloat y1
, GLfloat x2
, GLfloat y2
)
1384 GET_CURRENT_CONTEXT(ctx
);
1385 _save_NotifyBegin( ctx
, GL_QUADS
| PRIM_WEAK
);
1386 GL_CALL(Vertex2f
)( x1
, y1
);
1387 GL_CALL(Vertex2f
)( x2
, y1
);
1388 GL_CALL(Vertex2f
)( x2
, y2
);
1389 GL_CALL(Vertex2f
)( x1
, y2
);
1394 static void GLAPIENTRY
_save_OBE_DrawArrays(GLenum mode
, GLint start
, GLsizei count
)
1396 GET_CURRENT_CONTEXT(ctx
);
1399 if (!_mesa_validate_DrawArrays( ctx
, mode
, start
, count
))
1402 _save_NotifyBegin( ctx
, mode
| PRIM_WEAK
);
1403 for (i
= 0; i
< count
; i
++)
1404 GL_CALL(ArrayElement
)(start
+ i
);
1409 static void GLAPIENTRY
_save_OBE_DrawElements(GLenum mode
, GLsizei count
, GLenum type
,
1410 const GLvoid
*indices
)
1412 GET_CURRENT_CONTEXT(ctx
);
1415 if (!_mesa_validate_DrawElements( ctx
, mode
, count
, type
, indices
))
1418 _save_NotifyBegin( ctx
, mode
| PRIM_WEAK
);
1421 case GL_UNSIGNED_BYTE
:
1422 for (i
= 0 ; i
< count
; i
++)
1423 GL_CALL(ArrayElement
)( ((GLubyte
*)indices
)[i
] );
1425 case GL_UNSIGNED_SHORT
:
1426 for (i
= 0 ; i
< count
; i
++)
1427 GL_CALL(ArrayElement
)( ((GLushort
*)indices
)[i
] );
1429 case GL_UNSIGNED_INT
:
1430 for (i
= 0 ; i
< count
; i
++)
1431 GL_CALL(ArrayElement
)( ((GLuint
*)indices
)[i
] );
1434 _mesa_error( ctx
, GL_INVALID_ENUM
, "glDrawElements(type)" );
1441 static void GLAPIENTRY
_save_OBE_DrawRangeElements(GLenum mode
,
1442 GLuint start
, GLuint end
,
1443 GLsizei count
, GLenum type
,
1444 const GLvoid
*indices
)
1446 GET_CURRENT_CONTEXT(ctx
);
1447 if (_mesa_validate_DrawRangeElements( ctx
, mode
,
1449 count
, type
, indices
))
1450 _save_OBE_DrawElements( mode
, count
, type
, indices
);
1457 static void _save_vtxfmt_init( GLcontext
*ctx
)
1459 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
1460 GLvertexformat
*vfmt
= &tnl
->save_vtxfmt
;
1462 vfmt
->ArrayElement
= _ae_loopback_array_elt
; /* generic helper */
1463 vfmt
->Begin
= _save_Begin
;
1464 vfmt
->Color3f
= _save_Color3f
;
1465 vfmt
->Color3fv
= _save_Color3fv
;
1466 vfmt
->Color4f
= _save_Color4f
;
1467 vfmt
->Color4fv
= _save_Color4fv
;
1468 vfmt
->EdgeFlag
= _save_EdgeFlag
;
1469 vfmt
->EdgeFlagv
= _save_EdgeFlagv
;
1470 vfmt
->End
= _save_End
;
1471 vfmt
->FogCoordfEXT
= _save_FogCoordfEXT
;
1472 vfmt
->FogCoordfvEXT
= _save_FogCoordfvEXT
;
1473 vfmt
->Indexf
= _save_Indexf
;
1474 vfmt
->Indexfv
= _save_Indexfv
;
1475 vfmt
->Materialfv
= _save_Materialfv
;
1476 vfmt
->MultiTexCoord1fARB
= _save_MultiTexCoord1f
;
1477 vfmt
->MultiTexCoord1fvARB
= _save_MultiTexCoord1fv
;
1478 vfmt
->MultiTexCoord2fARB
= _save_MultiTexCoord2f
;
1479 vfmt
->MultiTexCoord2fvARB
= _save_MultiTexCoord2fv
;
1480 vfmt
->MultiTexCoord3fARB
= _save_MultiTexCoord3f
;
1481 vfmt
->MultiTexCoord3fvARB
= _save_MultiTexCoord3fv
;
1482 vfmt
->MultiTexCoord4fARB
= _save_MultiTexCoord4f
;
1483 vfmt
->MultiTexCoord4fvARB
= _save_MultiTexCoord4fv
;
1484 vfmt
->Normal3f
= _save_Normal3f
;
1485 vfmt
->Normal3fv
= _save_Normal3fv
;
1486 vfmt
->SecondaryColor3fEXT
= _save_SecondaryColor3fEXT
;
1487 vfmt
->SecondaryColor3fvEXT
= _save_SecondaryColor3fvEXT
;
1488 vfmt
->TexCoord1f
= _save_TexCoord1f
;
1489 vfmt
->TexCoord1fv
= _save_TexCoord1fv
;
1490 vfmt
->TexCoord2f
= _save_TexCoord2f
;
1491 vfmt
->TexCoord2fv
= _save_TexCoord2fv
;
1492 vfmt
->TexCoord3f
= _save_TexCoord3f
;
1493 vfmt
->TexCoord3fv
= _save_TexCoord3fv
;
1494 vfmt
->TexCoord4f
= _save_TexCoord4f
;
1495 vfmt
->TexCoord4fv
= _save_TexCoord4fv
;
1496 vfmt
->Vertex2f
= _save_Vertex2f
;
1497 vfmt
->Vertex2fv
= _save_Vertex2fv
;
1498 vfmt
->Vertex3f
= _save_Vertex3f
;
1499 vfmt
->Vertex3fv
= _save_Vertex3fv
;
1500 vfmt
->Vertex4f
= _save_Vertex4f
;
1501 vfmt
->Vertex4fv
= _save_Vertex4fv
;
1502 vfmt
->VertexAttrib1fNV
= _save_VertexAttrib1fNV
;
1503 vfmt
->VertexAttrib1fvNV
= _save_VertexAttrib1fvNV
;
1504 vfmt
->VertexAttrib2fNV
= _save_VertexAttrib2fNV
;
1505 vfmt
->VertexAttrib2fvNV
= _save_VertexAttrib2fvNV
;
1506 vfmt
->VertexAttrib3fNV
= _save_VertexAttrib3fNV
;
1507 vfmt
->VertexAttrib3fvNV
= _save_VertexAttrib3fvNV
;
1508 vfmt
->VertexAttrib4fNV
= _save_VertexAttrib4fNV
;
1509 vfmt
->VertexAttrib4fvNV
= _save_VertexAttrib4fvNV
;
1510 vfmt
->VertexAttrib1fARB
= _save_VertexAttrib1fARB
;
1511 vfmt
->VertexAttrib1fvARB
= _save_VertexAttrib1fvARB
;
1512 vfmt
->VertexAttrib2fARB
= _save_VertexAttrib2fARB
;
1513 vfmt
->VertexAttrib2fvARB
= _save_VertexAttrib2fvARB
;
1514 vfmt
->VertexAttrib3fARB
= _save_VertexAttrib3fARB
;
1515 vfmt
->VertexAttrib3fvARB
= _save_VertexAttrib3fvARB
;
1516 vfmt
->VertexAttrib4fARB
= _save_VertexAttrib4fARB
;
1517 vfmt
->VertexAttrib4fvARB
= _save_VertexAttrib4fvARB
;
1519 /* This will all require us to fallback to saving the list as opcodes:
1521 vfmt
->CallList
= _save_CallList
; /* inside begin/end */
1522 vfmt
->CallLists
= _save_CallLists
; /* inside begin/end */
1523 vfmt
->EvalCoord1f
= _save_EvalCoord1f
;
1524 vfmt
->EvalCoord1fv
= _save_EvalCoord1fv
;
1525 vfmt
->EvalCoord2f
= _save_EvalCoord2f
;
1526 vfmt
->EvalCoord2fv
= _save_EvalCoord2fv
;
1527 vfmt
->EvalPoint1
= _save_EvalPoint1
;
1528 vfmt
->EvalPoint2
= _save_EvalPoint2
;
1530 /* These are all errors as we at least know we are in some sort of
1533 vfmt
->EvalMesh1
= _save_EvalMesh1
;
1534 vfmt
->EvalMesh2
= _save_EvalMesh2
;
1535 vfmt
->Begin
= _save_Begin
;
1536 vfmt
->Rectf
= _save_Rectf
;
1537 vfmt
->DrawArrays
= _save_DrawArrays
;
1538 vfmt
->DrawElements
= _save_DrawElements
;
1539 vfmt
->DrawRangeElements
= _save_DrawRangeElements
;
1544 void _tnl_SaveFlushVertices( GLcontext
*ctx
)
1546 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
1548 /* Noop when we are actually active:
1550 if (ctx
->Driver
.CurrentSavePrimitive
== PRIM_INSIDE_UNKNOWN_PRIM
||
1551 ctx
->Driver
.CurrentSavePrimitive
<= GL_POLYGON
)
1554 if (tnl
->save
.initial_counter
!= tnl
->save
.counter
||
1555 tnl
->save
.prim_count
)
1556 _save_compile_vertex_list( ctx
);
1558 _save_copy_to_current( ctx
);
1559 _save_reset_vertex( ctx
);
1560 ctx
->Driver
.SaveNeedFlush
= 0;
1563 void _tnl_NewList( GLcontext
*ctx
, GLuint list
, GLenum mode
)
1565 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
1567 (void) list
; (void) mode
;
1569 if (!tnl
->save
.prim_store
)
1570 tnl
->save
.prim_store
= alloc_prim_store( ctx
);
1572 if (!tnl
->save
.vertex_store
) {
1573 tnl
->save
.vertex_store
= alloc_vertex_store( ctx
);
1574 tnl
->save
.vbptr
= tnl
->save
.vertex_store
->buffer
;
1577 _save_reset_vertex( ctx
);
1578 ctx
->Driver
.SaveNeedFlush
= 0;
1581 void _tnl_EndList( GLcontext
*ctx
)
1584 assert(TNL_CONTEXT(ctx
)->save
.vertex_size
== 0);
1587 void _tnl_BeginCallList( GLcontext
*ctx
, struct mesa_display_list
*dlist
)
1589 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
1590 tnl
->save
.replay_flags
|= dlist
->flags
;
1591 tnl
->save
.replay_flags
|= tnl
->LoopbackDListCassettes
;
1594 void _tnl_EndCallList( GLcontext
*ctx
)
1596 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
1598 if (ctx
->ListState
.CallDepth
== 1)
1599 tnl
->save
.replay_flags
= 0;
1603 static void _tnl_destroy_vertex_list( GLcontext
*ctx
, void *data
)
1605 struct tnl_vertex_list
*node
= (struct tnl_vertex_list
*)data
;
1608 if ( --node
->vertex_store
->refcount
== 0 )
1609 FREE( node
->vertex_store
);
1611 if ( --node
->prim_store
->refcount
== 0 )
1612 FREE( node
->prim_store
);
1614 if ( node
->normal_lengths
)
1615 FREE( node
->normal_lengths
);
1619 static void _tnl_print_vertex_list( GLcontext
*ctx
, void *data
)
1621 struct tnl_vertex_list
*node
= (struct tnl_vertex_list
*)data
;
1625 _mesa_debug(NULL
, "TNL-VERTEX-LIST, %u vertices %d primitives, %d vertsize\n",
1630 for (i
= 0 ; i
< node
->prim_count
; i
++) {
1631 struct tnl_prim
*prim
= &node
->prim
[i
];
1632 _mesa_debug(NULL
, " prim %d: %s %d..%d %s %s\n",
1634 _mesa_lookup_enum_by_nr(prim
->mode
& PRIM_MODE_MASK
),
1636 prim
->start
+ prim
->count
,
1637 (prim
->mode
& PRIM_BEGIN
) ? "BEGIN" : "(wrap)",
1638 (prim
->mode
& PRIM_END
) ? "END" : "(wrap)");
1643 static void _save_current_init( GLcontext
*ctx
)
1645 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
1648 for (i
= 0; i
< _TNL_ATTRIB_MAT_FRONT_AMBIENT
; i
++) {
1649 ASSERT(i
< VERT_ATTRIB_MAX
);
1650 tnl
->save
.currentsz
[i
] = &ctx
->ListState
.ActiveAttribSize
[i
];
1651 tnl
->save
.current
[i
] = ctx
->ListState
.CurrentAttrib
[i
];
1654 for (i
= _TNL_ATTRIB_MAT_FRONT_AMBIENT
; i
< _TNL_ATTRIB_INDEX
; i
++) {
1655 const GLuint j
= i
- _TNL_ATTRIB_MAT_FRONT_AMBIENT
;
1656 ASSERT(j
< MAT_ATTRIB_MAX
);
1657 tnl
->save
.currentsz
[i
] = &ctx
->ListState
.ActiveMaterialSize
[j
];
1658 tnl
->save
.current
[i
] = ctx
->ListState
.CurrentMaterial
[j
];
1661 tnl
->save
.currentsz
[_TNL_ATTRIB_INDEX
] = &ctx
->ListState
.ActiveIndex
;
1662 tnl
->save
.current
[_TNL_ATTRIB_INDEX
] = &ctx
->ListState
.CurrentIndex
;
1664 tnl
->save
.currentsz
[_TNL_ATTRIB_EDGEFLAG
] = &ctx
->ListState
.ActiveEdgeFlag
;
1665 tnl
->save
.current
[_TNL_ATTRIB_EDGEFLAG
] = &tnl
->save
.CurrentFloatEdgeFlag
;
1669 * Initialize the display list compiler
1671 void _tnl_save_init( GLcontext
*ctx
)
1673 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
1674 struct tnl_vertex_arrays
*tmp
= &tnl
->save_inputs
;
1678 for (i
= 0; i
< _TNL_ATTRIB_MAX
; i
++)
1679 _mesa_vector4f_init( &tmp
->Attribs
[i
], 0, NULL
);
1681 tnl
->save
.opcode_vertex_list
=
1682 _mesa_alloc_opcode( ctx
,
1683 sizeof(struct tnl_vertex_list
),
1684 _tnl_playback_vertex_list
,
1685 _tnl_destroy_vertex_list
,
1686 _tnl_print_vertex_list
);
1688 ctx
->Driver
.NotifySaveBegin
= _save_NotifyBegin
;
1690 _save_vtxfmt_init( ctx
);
1691 _save_current_init( ctx
);
1693 /* Hook our array functions into the outside-begin-end vtxfmt in
1696 ctx
->ListState
.ListVtxfmt
.Rectf
= _save_OBE_Rectf
;
1697 ctx
->ListState
.ListVtxfmt
.DrawArrays
= _save_OBE_DrawArrays
;
1698 ctx
->ListState
.ListVtxfmt
.DrawElements
= _save_OBE_DrawElements
;
1699 ctx
->ListState
.ListVtxfmt
.DrawRangeElements
= _save_OBE_DrawRangeElements
;
1700 _mesa_install_save_vtxfmt( ctx
, &ctx
->ListState
.ListVtxfmt
);
1705 * Deallocate the immediate-mode buffer for the given context, if
1706 * its reference count goes to zero.
1708 void _tnl_save_destroy( GLcontext
*ctx
)