1 /* $XFree86: xc/lib/GL/mesa/src/drv/radeon/radeon_vtxfmt.c,v 1.6 2003/05/06 23:52:08 daenzer Exp $ */
2 /**************************************************************************
4 Copyright 2000, 2001 ATI Technologies Inc., Ontario, Canada, and
5 Tungsten Graphics Inc., Cedar Park, Texas.
9 Permission is hereby granted, free of charge, to any person obtaining
10 a copy of this software and associated documentation files (the
11 "Software"), to deal in the Software without restriction, including
12 without limitation the rights to use, copy, modify, merge, publish,
13 distribute, sublicense, and/or sell copies of the Software, and to
14 permit persons to whom the Software is furnished to do so, subject to
15 the following conditions:
17 The above copyright notice and this permission notice (including the
18 next paragraph) shall be included in all copies or substantial
19 portions of the Software.
21 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
22 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
23 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
24 IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
25 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
26 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
27 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 **************************************************************************/
33 * Keith Whitwell <keith@tungstengraphics.com>
38 #include "api_arrayelt.h"
49 #include "tnl/t_context.h"
50 #include "tnl/t_array_api.h"
52 #include "radeon_context.h"
53 #include "radeon_state.h"
54 #include "radeon_ioctl.h"
55 #include "radeon_tex.h"
56 #include "radeon_tcl.h"
57 #include "radeon_swtcl.h"
58 #include "radeon_vtxfmt.h"
60 static void radeonVtxfmtFlushVertices( GLcontext
*, GLuint
);
62 static void count_func( const char *name
, struct dynfn
*l
)
67 if (i
) fprintf(stderr
, "%s: %d\n", name
, i
);
70 static void count_funcs( radeonContextPtr rmesa
)
72 count_func( "Vertex2f", &rmesa
->vb
.dfn_cache
.Vertex2f
);
73 count_func( "Vertex2fv", &rmesa
->vb
.dfn_cache
.Vertex2fv
);
74 count_func( "Vertex3f", &rmesa
->vb
.dfn_cache
.Vertex3f
);
75 count_func( "Vertex3fv", &rmesa
->vb
.dfn_cache
.Vertex3fv
);
76 count_func( "Color4ub", &rmesa
->vb
.dfn_cache
.Color4ub
);
77 count_func( "Color4ubv", &rmesa
->vb
.dfn_cache
.Color4ubv
);
78 count_func( "Color3ub", &rmesa
->vb
.dfn_cache
.Color3ub
);
79 count_func( "Color3ubv", &rmesa
->vb
.dfn_cache
.Color3ubv
);
80 count_func( "Color4f", &rmesa
->vb
.dfn_cache
.Color4f
);
81 count_func( "Color4fv", &rmesa
->vb
.dfn_cache
.Color4fv
);
82 count_func( "Color3f", &rmesa
->vb
.dfn_cache
.Color3f
);
83 count_func( "Color3fv", &rmesa
->vb
.dfn_cache
.Color3fv
);
84 count_func( "SecondaryColor3f", &rmesa
->vb
.dfn_cache
.SecondaryColor3fEXT
);
85 count_func( "SecondaryColor3fv", &rmesa
->vb
.dfn_cache
.SecondaryColor3fvEXT
);
86 count_func( "SecondaryColor3ub", &rmesa
->vb
.dfn_cache
.SecondaryColor3ubEXT
);
87 count_func( "SecondaryColor3ubv", &rmesa
->vb
.dfn_cache
.SecondaryColor3ubvEXT
);
88 count_func( "Normal3f", &rmesa
->vb
.dfn_cache
.Normal3f
);
89 count_func( "Normal3fv", &rmesa
->vb
.dfn_cache
.Normal3fv
);
90 count_func( "TexCoord2f", &rmesa
->vb
.dfn_cache
.TexCoord2f
);
91 count_func( "TexCoord2fv", &rmesa
->vb
.dfn_cache
.TexCoord2fv
);
92 count_func( "TexCoord1f", &rmesa
->vb
.dfn_cache
.TexCoord1f
);
93 count_func( "TexCoord1fv", &rmesa
->vb
.dfn_cache
.TexCoord1fv
);
94 count_func( "MultiTexCoord2fARB", &rmesa
->vb
.dfn_cache
.MultiTexCoord2fARB
);
95 count_func( "MultiTexCoord2fvARB", &rmesa
->vb
.dfn_cache
.MultiTexCoord2fvARB
);
96 count_func( "MultiTexCoord1fARB", &rmesa
->vb
.dfn_cache
.MultiTexCoord1fARB
);
97 count_func( "MultiTexCoord1fvARB", &rmesa
->vb
.dfn_cache
.MultiTexCoord1fvARB
);
101 void radeon_copy_to_current( GLcontext
*ctx
)
103 radeonContextPtr rmesa
= RADEON_CONTEXT(ctx
);
105 assert(ctx
->Driver
.NeedFlush
& FLUSH_UPDATE_CURRENT
);
107 if (rmesa
->vb
.vertex_format
& RADEON_CP_VC_FRMT_N0
) {
108 ctx
->Current
.Attrib
[VERT_ATTRIB_NORMAL
][0] = rmesa
->vb
.normalptr
[0];
109 ctx
->Current
.Attrib
[VERT_ATTRIB_NORMAL
][1] = rmesa
->vb
.normalptr
[1];
110 ctx
->Current
.Attrib
[VERT_ATTRIB_NORMAL
][2] = rmesa
->vb
.normalptr
[2];
113 if (rmesa
->vb
.vertex_format
& RADEON_CP_VC_FRMT_PKCOLOR
) {
114 ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][0] = UBYTE_TO_FLOAT( rmesa
->vb
.colorptr
->red
);
115 ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][1] = UBYTE_TO_FLOAT( rmesa
->vb
.colorptr
->green
);
116 ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][2] = UBYTE_TO_FLOAT( rmesa
->vb
.colorptr
->blue
);
117 ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][3] = UBYTE_TO_FLOAT( rmesa
->vb
.colorptr
->alpha
);
120 if (rmesa
->vb
.vertex_format
& RADEON_CP_VC_FRMT_FPCOLOR
) {
121 ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][0] = rmesa
->vb
.floatcolorptr
[0];
122 ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][1] = rmesa
->vb
.floatcolorptr
[1];
123 ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][2] = rmesa
->vb
.floatcolorptr
[2];
126 if (rmesa
->vb
.vertex_format
& RADEON_CP_VC_FRMT_FPALPHA
)
127 ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][3] = rmesa
->vb
.floatcolorptr
[3];
129 if (rmesa
->vb
.vertex_format
& RADEON_CP_VC_FRMT_PKSPEC
) {
130 ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR1
][0] = UBYTE_TO_FLOAT( rmesa
->vb
.specptr
->red
);
131 ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR1
][1] = UBYTE_TO_FLOAT( rmesa
->vb
.specptr
->green
);
132 ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR1
][2] = UBYTE_TO_FLOAT( rmesa
->vb
.specptr
->blue
);
135 if (rmesa
->vb
.vertex_format
& RADEON_CP_VC_FRMT_ST0
) {
136 ctx
->Current
.Attrib
[VERT_ATTRIB_TEX0
][0] = rmesa
->vb
.texcoordptr
[0][0];
137 ctx
->Current
.Attrib
[VERT_ATTRIB_TEX0
][1] = rmesa
->vb
.texcoordptr
[0][1];
138 ctx
->Current
.Attrib
[VERT_ATTRIB_TEX0
][2] = 0.0F
;
139 ctx
->Current
.Attrib
[VERT_ATTRIB_TEX0
][3] = 1.0F
;
142 if (rmesa
->vb
.vertex_format
& RADEON_CP_VC_FRMT_ST1
) {
143 ctx
->Current
.Attrib
[VERT_ATTRIB_TEX1
][0] = rmesa
->vb
.texcoordptr
[1][0];
144 ctx
->Current
.Attrib
[VERT_ATTRIB_TEX1
][1] = rmesa
->vb
.texcoordptr
[1][1];
145 ctx
->Current
.Attrib
[VERT_ATTRIB_TEX1
][2] = 0.0F
;
146 ctx
->Current
.Attrib
[VERT_ATTRIB_TEX1
][3] = 1.0F
;
149 ctx
->Driver
.NeedFlush
&= ~FLUSH_UPDATE_CURRENT
;
152 static GLboolean discreet_gl_prim
[GL_POLYGON
+1] = {
155 0, /* 2 line_strip */
165 static void flush_prims( radeonContextPtr rmesa
)
168 struct radeon_dma_region tmp
= rmesa
->dma
.current
;
171 tmp
.aos_size
= rmesa
->vb
.vertex_size
;
172 tmp
.aos_stride
= rmesa
->vb
.vertex_size
;
173 tmp
.aos_start
= GET_START(&tmp
);
175 rmesa
->dma
.current
.ptr
= rmesa
->dma
.current
.start
+=
176 (rmesa
->vb
.initial_counter
- rmesa
->vb
.counter
) * rmesa
->vb
.vertex_size
* 4;
178 rmesa
->tcl
.vertex_format
= rmesa
->vb
.vertex_format
;
179 rmesa
->tcl
.aos_components
[0] = &tmp
;
180 rmesa
->tcl
.nr_aos_components
= 1;
181 rmesa
->dma
.flush
= 0;
183 /* Optimize the primitive list:
185 if (rmesa
->vb
.nrprims
> 1) {
186 for (j
= 0, i
= 1 ; i
< rmesa
->vb
.nrprims
; i
++) {
187 int pj
= rmesa
->vb
.primlist
[j
].prim
& 0xf;
188 int pi
= rmesa
->vb
.primlist
[i
].prim
& 0xf;
190 if (pj
== pi
&& discreet_gl_prim
[pj
] &&
191 rmesa
->vb
.primlist
[i
].start
== rmesa
->vb
.primlist
[j
].end
) {
192 rmesa
->vb
.primlist
[j
].end
= rmesa
->vb
.primlist
[i
].end
;
196 if (j
!= i
) rmesa
->vb
.primlist
[j
] = rmesa
->vb
.primlist
[i
];
199 rmesa
->vb
.nrprims
= j
+1;
202 for (i
= 0 ; i
< rmesa
->vb
.nrprims
; i
++) {
203 if (RADEON_DEBUG
& DEBUG_PRIMS
)
204 fprintf(stderr
, "vtxfmt prim %d: %s %d..%d\n", i
,
205 _mesa_lookup_enum_by_nr( rmesa
->vb
.primlist
[i
].prim
&
207 rmesa
->vb
.primlist
[i
].start
,
208 rmesa
->vb
.primlist
[i
].end
);
210 radeonEmitPrimitive( rmesa
->glCtx
,
211 rmesa
->vb
.primlist
[i
].start
,
212 rmesa
->vb
.primlist
[i
].end
,
213 rmesa
->vb
.primlist
[i
].prim
);
216 rmesa
->vb
.nrprims
= 0;
217 radeonReleaseDmaRegion( rmesa
, &tmp
, __FUNCTION__
);
221 static void start_prim( radeonContextPtr rmesa
, GLuint mode
)
223 if (RADEON_DEBUG
& DEBUG_VFMT
)
224 fprintf(stderr
, "%s %d\n", __FUNCTION__
, rmesa
->vb
.initial_counter
- rmesa
->vb
.counter
);
226 rmesa
->vb
.primlist
[rmesa
->vb
.nrprims
].start
= rmesa
->vb
.initial_counter
- rmesa
->vb
.counter
;
227 rmesa
->vb
.primlist
[rmesa
->vb
.nrprims
].prim
= mode
;
230 static void note_last_prim( radeonContextPtr rmesa
, GLuint flags
)
232 if (RADEON_DEBUG
& DEBUG_VFMT
)
233 fprintf(stderr
, "%s %d\n", __FUNCTION__
, rmesa
->vb
.initial_counter
- rmesa
->vb
.counter
);
235 if (rmesa
->vb
.prim
[0] != GL_POLYGON
+1) {
236 rmesa
->vb
.primlist
[rmesa
->vb
.nrprims
].prim
|= flags
;
237 rmesa
->vb
.primlist
[rmesa
->vb
.nrprims
].end
= rmesa
->vb
.initial_counter
- rmesa
->vb
.counter
;
239 if (++(rmesa
->vb
.nrprims
) == RADEON_MAX_PRIMS
)
240 flush_prims( rmesa
);
245 static void copy_vertex( radeonContextPtr rmesa
, GLuint n
, GLfloat
*dst
)
248 GLfloat
*src
= (GLfloat
*)(rmesa
->dma
.current
.address
+
249 rmesa
->dma
.current
.ptr
+
250 (rmesa
->vb
.primlist
[rmesa
->vb
.nrprims
].start
+ n
) *
251 rmesa
->vb
.vertex_size
* 4);
253 if (RADEON_DEBUG
& DEBUG_VFMT
)
254 fprintf(stderr
, "copy_vertex %d\n", rmesa
->vb
.primlist
[rmesa
->vb
.nrprims
].start
+ n
);
256 for (i
= 0 ; i
< rmesa
->vb
.vertex_size
; i
++) {
261 /* NOTE: This actually reads the copied vertices back from uncached
262 * memory. Could also use the counter/notify mechanism to populate
263 * tmp on the fly as vertices are generated.
265 static GLuint
copy_dma_verts( radeonContextPtr rmesa
, GLfloat (*tmp
)[15] )
268 GLuint nr
= (rmesa
->vb
.initial_counter
- rmesa
->vb
.counter
) - rmesa
->vb
.primlist
[rmesa
->vb
.nrprims
].start
;
270 if (RADEON_DEBUG
& DEBUG_VFMT
)
271 fprintf(stderr
, "%s %d verts\n", __FUNCTION__
, nr
);
273 switch( rmesa
->vb
.prim
[0] )
279 for (i
= 0 ; i
< ovf
; i
++)
280 copy_vertex( rmesa
, nr
-ovf
+i
, tmp
[i
] );
284 for (i
= 0 ; i
< ovf
; i
++)
285 copy_vertex( rmesa
, nr
-ovf
+i
, tmp
[i
] );
289 for (i
= 0 ; i
< ovf
; i
++)
290 copy_vertex( rmesa
, nr
-ovf
+i
, tmp
[i
] );
295 copy_vertex( rmesa
, nr
-1, tmp
[0] );
298 case GL_TRIANGLE_FAN
:
303 copy_vertex( rmesa
, 0, tmp
[0] );
306 copy_vertex( rmesa
, 0, tmp
[0] );
307 copy_vertex( rmesa
, nr
-1, tmp
[1] );
310 case GL_TRIANGLE_STRIP
:
312 for (i
= 0 ; i
< ovf
; i
++)
313 copy_vertex( rmesa
, nr
-ovf
+i
, tmp
[i
] );
317 case 0: ovf
= 0; break;
318 case 1: ovf
= 1; break;
319 default: ovf
= 2 + (nr
&1); break;
321 for (i
= 0 ; i
< ovf
; i
++)
322 copy_vertex( rmesa
, nr
-ovf
+i
, tmp
[i
] );
330 static void VFMT_FALLBACK_OUTSIDE_BEGIN_END( const char *caller
)
332 GET_CURRENT_CONTEXT(ctx
);
333 radeonContextPtr rmesa
= RADEON_CONTEXT(ctx
);
335 if (RADEON_DEBUG
& (DEBUG_VFMT
|DEBUG_FALLBACKS
))
336 fprintf(stderr
, "%s from %s\n", __FUNCTION__
, caller
);
338 if (ctx
->Driver
.NeedFlush
)
339 radeonVtxfmtFlushVertices( ctx
, ctx
->Driver
.NeedFlush
);
342 _mesa_update_state( ctx
); /* clear state so fell_back sticks */
344 _tnl_wakeup_exec( ctx
);
345 ctx
->Driver
.FlushVertices
= radeonFlushVertices
;
347 assert( rmesa
->dma
.flush
== 0 );
348 rmesa
->vb
.fell_back
= GL_TRUE
;
349 rmesa
->vb
.installed
= GL_FALSE
;
353 static void VFMT_FALLBACK( const char *caller
)
355 GET_CURRENT_CONTEXT(ctx
);
356 radeonContextPtr rmesa
= RADEON_CONTEXT(ctx
);
359 GLuint ind
= rmesa
->vb
.vertex_format
;
363 if (RADEON_DEBUG
& (DEBUG_FALLBACKS
|DEBUG_VFMT
))
364 fprintf(stderr
, "%s from %s\n", __FUNCTION__
, caller
);
366 if (rmesa
->vb
.prim
[0] == GL_POLYGON
+1) {
367 VFMT_FALLBACK_OUTSIDE_BEGIN_END( __FUNCTION__
);
371 /* Copy vertices out of dma:
373 nrverts
= copy_dma_verts( rmesa
, tmp
);
375 /* Finish the prim at this point:
377 note_last_prim( rmesa
, 0 );
378 flush_prims( rmesa
);
380 /* Update ctx->Driver.CurrentExecPrimitive and swap in swtnl.
382 prim
= rmesa
->vb
.prim
[0];
383 ctx
->Driver
.CurrentExecPrimitive
= GL_POLYGON
+1;
384 _tnl_wakeup_exec( ctx
);
385 ctx
->Driver
.FlushVertices
= radeonFlushVertices
;
387 assert(rmesa
->dma
.flush
== 0);
388 rmesa
->vb
.fell_back
= GL_TRUE
;
389 rmesa
->vb
.installed
= GL_FALSE
;
390 GL_CALL(Begin
)( prim
);
392 if (rmesa
->vb
.installed_color_3f_sz
== 4)
393 alpha
= ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][3];
395 /* Replay saved vertices
397 for (i
= 0 ; i
< nrverts
; i
++) {
399 if (ind
& RADEON_CP_VC_FRMT_N0
) {
400 GL_CALL(Normal3fv
)( &tmp
[i
][offset
] );
404 if (ind
& RADEON_CP_VC_FRMT_PKCOLOR
) {
405 radeon_color_t
*col
= (radeon_color_t
*)&tmp
[i
][offset
];
406 GL_CALL(Color4ub
)( col
->red
, col
->green
, col
->blue
, col
->alpha
);
409 else if (ind
& RADEON_CP_VC_FRMT_FPALPHA
) {
410 GL_CALL(Color4fv
)( &tmp
[i
][offset
] );
413 else if (ind
& RADEON_CP_VC_FRMT_FPCOLOR
) {
414 GL_CALL(Color3fv
)( &tmp
[i
][offset
] );
418 if (ind
& RADEON_CP_VC_FRMT_PKSPEC
) {
419 radeon_color_t
*spec
= (radeon_color_t
*)&tmp
[i
][offset
];
420 GL_CALL(SecondaryColor3ubEXT
)( spec
->red
, spec
->green
, spec
->blue
);
424 if (ind
& RADEON_CP_VC_FRMT_ST0
) {
425 GL_CALL(TexCoord2fv
)( &tmp
[i
][offset
] );
429 if (ind
& RADEON_CP_VC_FRMT_ST1
) {
430 GL_CALL(MultiTexCoord2fvARB
)( GL_TEXTURE1_ARB
, &tmp
[i
][offset
] );
433 GL_CALL(Vertex3fv
)( &tmp
[i
][0] );
436 /* Replay current vertex
438 if (ind
& RADEON_CP_VC_FRMT_N0
)
439 GL_CALL(Normal3fv
)( rmesa
->vb
.normalptr
);
441 if (ind
& RADEON_CP_VC_FRMT_PKCOLOR
)
442 GL_CALL(Color4ub
)( rmesa
->vb
.colorptr
->red
, rmesa
->vb
.colorptr
->green
, rmesa
->vb
.colorptr
->blue
, rmesa
->vb
.colorptr
->alpha
);
443 else if (ind
& RADEON_CP_VC_FRMT_FPALPHA
)
444 GL_CALL(Color4fv
)( rmesa
->vb
.floatcolorptr
);
445 else if (ind
& RADEON_CP_VC_FRMT_FPCOLOR
) {
446 if (rmesa
->vb
.installed_color_3f_sz
== 4 && alpha
!= 1.0)
447 GL_CALL(Color4f
)( rmesa
->vb
.floatcolorptr
[0],
448 rmesa
->vb
.floatcolorptr
[1],
449 rmesa
->vb
.floatcolorptr
[2],
452 GL_CALL(Color3fv
)( rmesa
->vb
.floatcolorptr
);
455 if (ind
& RADEON_CP_VC_FRMT_PKSPEC
)
456 GL_CALL(SecondaryColor3ubEXT
)( rmesa
->vb
.specptr
->red
, rmesa
->vb
.specptr
->green
, rmesa
->vb
.specptr
->blue
);
458 if (ind
& RADEON_CP_VC_FRMT_ST0
)
459 GL_CALL(TexCoord2fv
)( rmesa
->vb
.texcoordptr
[0] );
461 if (ind
& RADEON_CP_VC_FRMT_ST1
)
462 GL_CALL(MultiTexCoord2fvARB
)( GL_TEXTURE1_ARB
, rmesa
->vb
.texcoordptr
[1] );
467 static void wrap_buffer( void )
469 GET_CURRENT_CONTEXT(ctx
);
470 radeonContextPtr rmesa
= RADEON_CONTEXT(ctx
);
474 if (RADEON_DEBUG
& (DEBUG_VFMT
|DEBUG_PRIMS
))
475 fprintf(stderr
, "%s %d\n", __FUNCTION__
, rmesa
->vb
.initial_counter
- rmesa
->vb
.counter
);
477 /* Don't deal with parity.
479 if ((((rmesa
->vb
.initial_counter
- rmesa
->vb
.counter
) -
480 rmesa
->vb
.primlist
[rmesa
->vb
.nrprims
].start
) & 1)) {
482 rmesa
->vb
.initial_counter
++;
486 /* Copy vertices out of dma:
488 if (rmesa
->vb
.prim
[0] == GL_POLYGON
+1)
491 nrverts
= copy_dma_verts( rmesa
, tmp
);
493 if (RADEON_DEBUG
& DEBUG_VFMT
)
494 fprintf(stderr
, "%d vertices to copy\n", nrverts
);
496 /* Finish the prim at this point:
498 note_last_prim( rmesa
, 0 );
501 /* Fire any buffered primitives
503 flush_prims( rmesa
);
507 radeonRefillCurrentDmaRegion( rmesa
);
509 /* Reset counter, dmaptr
511 rmesa
->vb
.dmaptr
= (int *)(rmesa
->dma
.current
.ptr
+ rmesa
->dma
.current
.address
);
512 rmesa
->vb
.counter
= (rmesa
->dma
.current
.end
- rmesa
->dma
.current
.ptr
) /
513 (rmesa
->vb
.vertex_size
* 4);
515 rmesa
->vb
.initial_counter
= rmesa
->vb
.counter
;
516 rmesa
->vb
.notify
= wrap_buffer
;
518 rmesa
->dma
.flush
= flush_prims
;
520 /* Restart wrapped primitive:
522 if (rmesa
->vb
.prim
[0] != GL_POLYGON
+1)
523 start_prim( rmesa
, rmesa
->vb
.prim
[0] );
525 /* Reemit saved vertices
527 for (i
= 0 ; i
< nrverts
; i
++) {
528 if (RADEON_DEBUG
& DEBUG_VERTS
) {
530 fprintf(stderr
, "re-emit vertex %d to %p\n", i
, (void *)rmesa
->vb
.dmaptr
);
531 if (RADEON_DEBUG
& DEBUG_VERBOSE
)
532 for (j
= 0 ; j
< rmesa
->vb
.vertex_size
; j
++)
533 fprintf(stderr
, "\t%08x/%f\n", *(int*)&tmp
[i
][j
], tmp
[i
][j
]);
536 memcpy( rmesa
->vb
.dmaptr
, tmp
[i
], rmesa
->vb
.vertex_size
* 4 );
537 rmesa
->vb
.dmaptr
+= rmesa
->vb
.vertex_size
;
544 static GLboolean
check_vtx_fmt( GLcontext
*ctx
)
546 radeonContextPtr rmesa
= RADEON_CONTEXT(ctx
);
547 GLuint ind
= RADEON_CP_VC_FRMT_Z
;
549 if (rmesa
->TclFallback
|| rmesa
->vb
.fell_back
|| ctx
->CompileFlag
)
552 if (ctx
->Driver
.NeedFlush
& FLUSH_UPDATE_CURRENT
)
553 ctx
->Driver
.FlushVertices( ctx
, FLUSH_UPDATE_CURRENT
);
555 /* Make all this event-driven:
557 if (ctx
->Light
.Enabled
) {
558 ind
|= RADEON_CP_VC_FRMT_N0
;
560 /* TODO: make this data driven: If we receive only ubytes, send
561 * color as ubytes. Also check if converting (with free
562 * checking for overflow) is cheaper than sending floats
565 if (ctx
->Light
.ColorMaterialEnabled
) {
566 ind
|= (RADEON_CP_VC_FRMT_FPCOLOR
|
567 RADEON_CP_VC_FRMT_FPALPHA
);
570 ind
|= RADEON_CP_VC_FRMT_PKCOLOR
; /* for alpha? */
573 /* TODO: make this data driven?
575 ind
|= RADEON_CP_VC_FRMT_PKCOLOR
;
577 if (ctx
->_TriangleCaps
& DD_SEPARATE_SPECULAR
) {
578 ind
|= RADEON_CP_VC_FRMT_PKSPEC
;
582 if (ctx
->Texture
.Unit
[0]._ReallyEnabled
) {
583 if (ctx
->Texture
.Unit
[0].TexGenEnabled
) {
584 if (rmesa
->TexGenNeedNormals
[0]) {
585 ind
|= RADEON_CP_VC_FRMT_N0
;
588 if (ctx
->Current
.Attrib
[VERT_ATTRIB_TEX0
][2] != 0.0F
||
589 ctx
->Current
.Attrib
[VERT_ATTRIB_TEX0
][3] != 1.0) {
590 if (RADEON_DEBUG
& (DEBUG_VFMT
|DEBUG_FALLBACKS
))
591 fprintf(stderr
, "%s: rq0\n", __FUNCTION__
);
594 ind
|= RADEON_CP_VC_FRMT_ST0
;
598 if (ctx
->Texture
.Unit
[1]._ReallyEnabled
) {
599 if (ctx
->Texture
.Unit
[1].TexGenEnabled
) {
600 if (rmesa
->TexGenNeedNormals
[1]) {
601 ind
|= RADEON_CP_VC_FRMT_N0
;
604 if (ctx
->Current
.Attrib
[VERT_ATTRIB_TEX1
][2] != 0.0F
||
605 ctx
->Current
.Attrib
[VERT_ATTRIB_TEX1
][3] != 1.0) {
606 if (RADEON_DEBUG
& (DEBUG_VFMT
|DEBUG_FALLBACKS
))
607 fprintf(stderr
, "%s: rq1\n", __FUNCTION__
);
610 ind
|= RADEON_CP_VC_FRMT_ST1
;
614 if (RADEON_DEBUG
& (DEBUG_VFMT
|DEBUG_STATE
))
615 fprintf(stderr
, "%s: format: 0x%x\n", __FUNCTION__
, ind
);
617 RADEON_NEWPRIM(rmesa
);
618 rmesa
->vb
.vertex_format
= ind
;
619 rmesa
->vb
.vertex_size
= 3;
620 rmesa
->vb
.prim
= &ctx
->Driver
.CurrentExecPrimitive
;
622 rmesa
->vb
.normalptr
= ctx
->Current
.Attrib
[VERT_ATTRIB_NORMAL
];
623 rmesa
->vb
.colorptr
= NULL
;
624 rmesa
->vb
.floatcolorptr
= ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
];
625 rmesa
->vb
.specptr
= NULL
;
626 rmesa
->vb
.floatspecptr
= ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR1
];
627 rmesa
->vb
.texcoordptr
[0] = ctx
->Current
.Attrib
[VERT_ATTRIB_TEX0
];
628 rmesa
->vb
.texcoordptr
[1] = ctx
->Current
.Attrib
[VERT_ATTRIB_TEX1
];
630 /* Run through and initialize the vertex components in the order
631 * the hardware understands:
633 if (ind
& RADEON_CP_VC_FRMT_N0
) {
634 rmesa
->vb
.normalptr
= &rmesa
->vb
.vertex
[rmesa
->vb
.vertex_size
].f
;
635 rmesa
->vb
.vertex_size
+= 3;
636 rmesa
->vb
.normalptr
[0] = ctx
->Current
.Attrib
[VERT_ATTRIB_NORMAL
][0];
637 rmesa
->vb
.normalptr
[1] = ctx
->Current
.Attrib
[VERT_ATTRIB_NORMAL
][1];
638 rmesa
->vb
.normalptr
[2] = ctx
->Current
.Attrib
[VERT_ATTRIB_NORMAL
][2];
641 if (ind
& RADEON_CP_VC_FRMT_PKCOLOR
) {
642 rmesa
->vb
.colorptr
= &rmesa
->vb
.vertex
[rmesa
->vb
.vertex_size
].color
;
643 rmesa
->vb
.vertex_size
+= 1;
644 UNCLAMPED_FLOAT_TO_CHAN( rmesa
->vb
.colorptr
->red
, ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][0] );
645 UNCLAMPED_FLOAT_TO_CHAN( rmesa
->vb
.colorptr
->green
, ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][1] );
646 UNCLAMPED_FLOAT_TO_CHAN( rmesa
->vb
.colorptr
->blue
, ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][2] );
647 UNCLAMPED_FLOAT_TO_CHAN( rmesa
->vb
.colorptr
->alpha
, ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][3] );
650 if (ind
& RADEON_CP_VC_FRMT_FPCOLOR
) {
651 assert(!(ind
& RADEON_CP_VC_FRMT_PKCOLOR
));
652 rmesa
->vb
.floatcolorptr
= &rmesa
->vb
.vertex
[rmesa
->vb
.vertex_size
].f
;
653 rmesa
->vb
.vertex_size
+= 3;
654 rmesa
->vb
.floatcolorptr
[0] = ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][0];
655 rmesa
->vb
.floatcolorptr
[1] = ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][1];
656 rmesa
->vb
.floatcolorptr
[2] = ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][2];
658 if (ind
& RADEON_CP_VC_FRMT_FPALPHA
) {
659 rmesa
->vb
.vertex_size
+= 1;
660 rmesa
->vb
.floatcolorptr
[3] = ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][3];
664 if (ind
& RADEON_CP_VC_FRMT_PKSPEC
) {
665 rmesa
->vb
.specptr
= &rmesa
->vb
.vertex
[rmesa
->vb
.vertex_size
].color
;
666 rmesa
->vb
.vertex_size
+= 1;
667 UNCLAMPED_FLOAT_TO_CHAN( rmesa
->vb
.specptr
->red
, ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR1
][0] );
668 UNCLAMPED_FLOAT_TO_CHAN( rmesa
->vb
.specptr
->green
, ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR1
][1] );
669 UNCLAMPED_FLOAT_TO_CHAN( rmesa
->vb
.specptr
->blue
, ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR1
][2] );
672 if (ind
& RADEON_CP_VC_FRMT_ST0
) {
673 rmesa
->vb
.texcoordptr
[0] = &rmesa
->vb
.vertex
[rmesa
->vb
.vertex_size
].f
;
674 rmesa
->vb
.vertex_size
+= 2;
675 rmesa
->vb
.texcoordptr
[0][0] = ctx
->Current
.Attrib
[VERT_ATTRIB_TEX0
][0];
676 rmesa
->vb
.texcoordptr
[0][1] = ctx
->Current
.Attrib
[VERT_ATTRIB_TEX0
][1];
679 if (ind
& RADEON_CP_VC_FRMT_ST1
) {
680 rmesa
->vb
.texcoordptr
[1] = &rmesa
->vb
.vertex
[rmesa
->vb
.vertex_size
].f
;
681 rmesa
->vb
.vertex_size
+= 2;
682 rmesa
->vb
.texcoordptr
[1][0] = ctx
->Current
.Attrib
[VERT_ATTRIB_TEX1
][0];
683 rmesa
->vb
.texcoordptr
[1][1] = ctx
->Current
.Attrib
[VERT_ATTRIB_TEX1
][1];
686 if (rmesa
->vb
.installed_vertex_format
!= rmesa
->vb
.vertex_format
) {
687 if (RADEON_DEBUG
& DEBUG_VFMT
)
688 fprintf(stderr
, "reinstall on vertex_format change\n");
689 _mesa_install_exec_vtxfmt( ctx
, &rmesa
->vb
.vtxfmt
);
690 rmesa
->vb
.installed_vertex_format
= rmesa
->vb
.vertex_format
;
693 if (RADEON_DEBUG
& DEBUG_VFMT
)
694 fprintf(stderr
, "%s -- success\n", __FUNCTION__
);
699 void radeonVtxfmtInvalidate( GLcontext
*ctx
)
701 radeonContextPtr rmesa
= RADEON_CONTEXT( ctx
);
703 rmesa
->vb
.recheck
= GL_TRUE
;
704 rmesa
->vb
.fell_back
= GL_FALSE
;
708 static void radeonVtxfmtValidate( GLcontext
*ctx
)
710 radeonContextPtr rmesa
= RADEON_CONTEXT( ctx
);
712 if (RADEON_DEBUG
& DEBUG_VFMT
)
713 fprintf(stderr
, "%s\n", __FUNCTION__
);
715 if (ctx
->Driver
.NeedFlush
)
716 ctx
->Driver
.FlushVertices( ctx
, ctx
->Driver
.NeedFlush
);
718 rmesa
->vb
.recheck
= GL_FALSE
;
720 if (check_vtx_fmt( ctx
)) {
721 if (!rmesa
->vb
.installed
) {
722 if (RADEON_DEBUG
& DEBUG_VFMT
)
723 fprintf(stderr
, "reinstall (new install)\n");
725 _mesa_install_exec_vtxfmt( ctx
, &rmesa
->vb
.vtxfmt
);
726 ctx
->Driver
.FlushVertices
= radeonVtxfmtFlushVertices
;
727 rmesa
->vb
.installed
= GL_TRUE
;
729 else if (RADEON_DEBUG
& DEBUG_VFMT
)
730 fprintf(stderr
, "%s: already installed", __FUNCTION__
);
733 if (RADEON_DEBUG
& DEBUG_VFMT
)
734 fprintf(stderr
, "%s: failed\n", __FUNCTION__
);
736 if (rmesa
->vb
.installed
) {
737 if (rmesa
->dma
.flush
)
738 rmesa
->dma
.flush( rmesa
);
739 _tnl_wakeup_exec( ctx
);
740 ctx
->Driver
.FlushVertices
= radeonFlushVertices
;
741 rmesa
->vb
.installed
= GL_FALSE
;
750 static void radeon_Materialfv( GLenum face
, GLenum pname
,
751 const GLfloat
*params
)
753 GET_CURRENT_CONTEXT(ctx
);
754 radeonContextPtr rmesa
= RADEON_CONTEXT( ctx
);
756 if (RADEON_DEBUG
& DEBUG_VFMT
)
757 fprintf(stderr
, "%s\n", __FUNCTION__
);
759 if (rmesa
->vb
.prim
[0] != GL_POLYGON
+1) {
760 VFMT_FALLBACK( __FUNCTION__
);
761 GL_CALL(Materialfv
)( face
, pname
, params
);
764 _mesa_noop_Materialfv( face
, pname
, params
);
765 radeonUpdateMaterial( ctx
);
771 static void radeon_Begin( GLenum mode
)
773 GET_CURRENT_CONTEXT(ctx
);
774 radeonContextPtr rmesa
= RADEON_CONTEXT(ctx
);
776 if (RADEON_DEBUG
& DEBUG_VFMT
)
777 fprintf(stderr
, "%s( %s )\n", __FUNCTION__
,
778 _mesa_lookup_enum_by_nr( mode
));
780 if (mode
> GL_POLYGON
) {
781 _mesa_error( ctx
, GL_INVALID_ENUM
, "glBegin" );
785 if (rmesa
->vb
.prim
[0] != GL_POLYGON
+1) {
786 _mesa_error( ctx
, GL_INVALID_OPERATION
, "glBegin" );
791 _mesa_update_state( ctx
);
793 if (rmesa
->NewGLState
)
794 radeonValidateState( ctx
);
796 if (rmesa
->vb
.recheck
)
797 radeonVtxfmtValidate( ctx
);
799 if (!rmesa
->vb
.installed
) {
800 GL_CALL(Begin
)( mode
);
805 if (rmesa
->dma
.flush
&& rmesa
->vb
.counter
< 12) {
806 if (RADEON_DEBUG
& DEBUG_VFMT
)
807 fprintf(stderr
, "%s: flush almost-empty buffers\n", __FUNCTION__
);
808 flush_prims( rmesa
);
811 /* Need to arrange to save vertices here? Or always copy from dma (yuk)?
813 if (!rmesa
->dma
.flush
) {
814 if (rmesa
->dma
.current
.ptr
+ 12*rmesa
->vb
.vertex_size
*4 >
815 rmesa
->dma
.current
.end
) {
816 RADEON_NEWPRIM( rmesa
);
817 radeonRefillCurrentDmaRegion( rmesa
);
820 rmesa
->vb
.dmaptr
= (int *)(rmesa
->dma
.current
.address
+ rmesa
->dma
.current
.ptr
);
821 rmesa
->vb
.counter
= (rmesa
->dma
.current
.end
- rmesa
->dma
.current
.ptr
) /
822 (rmesa
->vb
.vertex_size
* 4);
824 rmesa
->vb
.initial_counter
= rmesa
->vb
.counter
;
825 rmesa
->vb
.notify
= wrap_buffer
;
826 rmesa
->dma
.flush
= flush_prims
;
827 ctx
->Driver
.NeedFlush
|= FLUSH_STORED_VERTICES
;
831 rmesa
->vb
.prim
[0] = mode
;
832 start_prim( rmesa
, mode
| PRIM_BEGIN
);
837 static void radeon_End( void )
839 GET_CURRENT_CONTEXT(ctx
);
840 radeonContextPtr rmesa
= RADEON_CONTEXT(ctx
);
842 if (RADEON_DEBUG
& DEBUG_VFMT
)
843 fprintf(stderr
, "%s\n", __FUNCTION__
);
845 if (rmesa
->vb
.prim
[0] == GL_POLYGON
+1) {
846 _mesa_error( ctx
, GL_INVALID_OPERATION
, "glEnd" );
850 note_last_prim( rmesa
, PRIM_END
);
851 rmesa
->vb
.prim
[0] = GL_POLYGON
+1;
855 /* Fallback on difficult entrypoints:
857 #define PRE_LOOPBACK( FUNC ) \
859 if (RADEON_DEBUG & DEBUG_VFMT) \
860 fprintf(stderr, "%s\n", __FUNCTION__); \
861 VFMT_FALLBACK( __FUNCTION__ ); \
863 #define TAG(x) radeon_fallback_##x
864 #include "vtxfmt_tmp.h"
868 static GLboolean
radeonNotifyBegin( GLcontext
*ctx
, GLenum p
)
870 radeonContextPtr rmesa
= RADEON_CONTEXT( ctx
);
872 if (RADEON_DEBUG
& DEBUG_VFMT
)
873 fprintf(stderr
, "%s\n", __FUNCTION__
);
875 assert(!rmesa
->vb
.installed
);
878 _mesa_update_state( ctx
);
880 if (rmesa
->NewGLState
)
881 radeonValidateState( ctx
);
883 if (ctx
->Driver
.NeedFlush
)
884 ctx
->Driver
.FlushVertices( ctx
, ctx
->Driver
.NeedFlush
);
886 if (rmesa
->vb
.recheck
)
887 radeonVtxfmtValidate( ctx
);
889 if (!rmesa
->vb
.installed
) {
890 if (RADEON_DEBUG
& DEBUG_VFMT
)
891 fprintf(stderr
, "%s -- failed\n", __FUNCTION__
);
899 static void radeonVtxfmtFlushVertices( GLcontext
*ctx
, GLuint flags
)
901 radeonContextPtr rmesa
= RADEON_CONTEXT( ctx
);
903 if (RADEON_DEBUG
& DEBUG_VFMT
)
904 fprintf(stderr
, "%s\n", __FUNCTION__
);
906 assert(rmesa
->vb
.installed
);
908 if (flags
& FLUSH_UPDATE_CURRENT
) {
909 radeon_copy_to_current( ctx
);
910 if (RADEON_DEBUG
& DEBUG_VFMT
)
911 fprintf(stderr
, "reinstall on update_current\n");
912 _mesa_install_exec_vtxfmt( ctx
, &rmesa
->vb
.vtxfmt
);
913 ctx
->Driver
.NeedFlush
&= ~FLUSH_UPDATE_CURRENT
;
916 if (flags
& FLUSH_STORED_VERTICES
) {
917 radeonContextPtr rmesa
= RADEON_CONTEXT( ctx
);
918 assert (rmesa
->dma
.flush
== 0 ||
919 rmesa
->dma
.flush
== flush_prims
);
920 if (rmesa
->dma
.flush
== flush_prims
)
921 flush_prims( RADEON_CONTEXT( ctx
) );
922 ctx
->Driver
.NeedFlush
&= ~FLUSH_STORED_VERTICES
;
928 /* At this point, don't expect very many versions of each function to
929 * be generated, so not concerned about freeing them?
933 void radeonVtxfmtInit( GLcontext
*ctx
, GLboolean useCodegen
)
935 radeonContextPtr rmesa
= RADEON_CONTEXT( ctx
);
936 GLvertexformat
*vfmt
= &(rmesa
->vb
.vtxfmt
);
938 MEMSET( vfmt
, 0, sizeof(GLvertexformat
) );
940 /* Hook in chooser functions for codegen, etc:
942 radeonVtxfmtInitChoosers( vfmt
);
944 /* Handled fully in supported states, but no codegen:
946 vfmt
->Materialfv
= radeon_Materialfv
;
947 vfmt
->ArrayElement
= _ae_loopback_array_elt
; /* generic helper */
948 vfmt
->Rectf
= _mesa_noop_Rectf
; /* generic helper */
949 vfmt
->Begin
= radeon_Begin
;
950 vfmt
->End
= radeon_End
;
952 /* Fallback for performance reasons: (Fix with cva/elt path here and
953 * dmatmp2.h style primitive-merging)
955 * These should call NotifyBegin(), as should _tnl_EvalMesh, to allow
958 vfmt
->DrawArrays
= radeon_fallback_DrawArrays
;
959 vfmt
->DrawElements
= radeon_fallback_DrawElements
;
960 vfmt
->DrawRangeElements
= radeon_fallback_DrawRangeElements
;
963 /* Not active in supported states; just keep ctx->Current uptodate:
965 vfmt
->FogCoordfvEXT
= _mesa_noop_FogCoordfvEXT
;
966 vfmt
->FogCoordfEXT
= _mesa_noop_FogCoordfEXT
;
967 vfmt
->EdgeFlag
= _mesa_noop_EdgeFlag
;
968 vfmt
->EdgeFlagv
= _mesa_noop_EdgeFlagv
;
969 vfmt
->Indexf
= _mesa_noop_Indexf
;
970 vfmt
->Indexfv
= _mesa_noop_Indexfv
;
973 /* Active but unsupported -- fallback if we receive these:
975 vfmt
->CallList
= radeon_fallback_CallList
;
976 vfmt
->CallLists
= radeon_fallback_CallLists
;
977 vfmt
->EvalCoord1f
= radeon_fallback_EvalCoord1f
;
978 vfmt
->EvalCoord1fv
= radeon_fallback_EvalCoord1fv
;
979 vfmt
->EvalCoord2f
= radeon_fallback_EvalCoord2f
;
980 vfmt
->EvalCoord2fv
= radeon_fallback_EvalCoord2fv
;
981 vfmt
->EvalMesh1
= radeon_fallback_EvalMesh1
;
982 vfmt
->EvalMesh2
= radeon_fallback_EvalMesh2
;
983 vfmt
->EvalPoint1
= radeon_fallback_EvalPoint1
;
984 vfmt
->EvalPoint2
= radeon_fallback_EvalPoint2
;
985 vfmt
->TexCoord3f
= radeon_fallback_TexCoord3f
;
986 vfmt
->TexCoord3fv
= radeon_fallback_TexCoord3fv
;
987 vfmt
->TexCoord4f
= radeon_fallback_TexCoord4f
;
988 vfmt
->TexCoord4fv
= radeon_fallback_TexCoord4fv
;
989 vfmt
->MultiTexCoord3fARB
= radeon_fallback_MultiTexCoord3fARB
;
990 vfmt
->MultiTexCoord3fvARB
= radeon_fallback_MultiTexCoord3fvARB
;
991 vfmt
->MultiTexCoord4fARB
= radeon_fallback_MultiTexCoord4fARB
;
992 vfmt
->MultiTexCoord4fvARB
= radeon_fallback_MultiTexCoord4fvARB
;
993 vfmt
->Vertex4f
= radeon_fallback_Vertex4f
;
994 vfmt
->Vertex4fv
= radeon_fallback_Vertex4fv
;
995 vfmt
->VertexAttrib1fNV
= radeon_fallback_VertexAttrib1fNV
;
996 vfmt
->VertexAttrib1fvNV
= radeon_fallback_VertexAttrib1fvNV
;
997 vfmt
->VertexAttrib2fNV
= radeon_fallback_VertexAttrib2fNV
;
998 vfmt
->VertexAttrib2fvNV
= radeon_fallback_VertexAttrib2fvNV
;
999 vfmt
->VertexAttrib3fNV
= radeon_fallback_VertexAttrib3fNV
;
1000 vfmt
->VertexAttrib3fvNV
= radeon_fallback_VertexAttrib3fvNV
;
1001 vfmt
->VertexAttrib4fNV
= radeon_fallback_VertexAttrib4fNV
;
1002 vfmt
->VertexAttrib4fvNV
= radeon_fallback_VertexAttrib4fvNV
;
1004 (void)radeon_fallback_vtxfmt
;
1006 TNL_CONTEXT(ctx
)->Driver
.NotifyBegin
= radeonNotifyBegin
;
1008 rmesa
->vb
.enabled
= 1;
1009 rmesa
->vb
.prim
= &ctx
->Driver
.CurrentExecPrimitive
;
1010 rmesa
->vb
.primflags
= 0;
1012 make_empty_list( &rmesa
->vb
.dfn_cache
.Vertex2f
);
1013 make_empty_list( &rmesa
->vb
.dfn_cache
.Vertex2fv
);
1014 make_empty_list( &rmesa
->vb
.dfn_cache
.Vertex3f
);
1015 make_empty_list( &rmesa
->vb
.dfn_cache
.Vertex3fv
);
1016 make_empty_list( &rmesa
->vb
.dfn_cache
.Color4ub
);
1017 make_empty_list( &rmesa
->vb
.dfn_cache
.Color4ubv
);
1018 make_empty_list( &rmesa
->vb
.dfn_cache
.Color3ub
);
1019 make_empty_list( &rmesa
->vb
.dfn_cache
.Color3ubv
);
1020 make_empty_list( &rmesa
->vb
.dfn_cache
.Color4f
);
1021 make_empty_list( &rmesa
->vb
.dfn_cache
.Color4fv
);
1022 make_empty_list( &rmesa
->vb
.dfn_cache
.Color3f
);
1023 make_empty_list( &rmesa
->vb
.dfn_cache
.Color3fv
);
1024 make_empty_list( &rmesa
->vb
.dfn_cache
.SecondaryColor3fEXT
);
1025 make_empty_list( &rmesa
->vb
.dfn_cache
.SecondaryColor3fvEXT
);
1026 make_empty_list( &rmesa
->vb
.dfn_cache
.SecondaryColor3ubEXT
);
1027 make_empty_list( &rmesa
->vb
.dfn_cache
.SecondaryColor3ubvEXT
);
1028 make_empty_list( &rmesa
->vb
.dfn_cache
.Normal3f
);
1029 make_empty_list( &rmesa
->vb
.dfn_cache
.Normal3fv
);
1030 make_empty_list( &rmesa
->vb
.dfn_cache
.TexCoord2f
);
1031 make_empty_list( &rmesa
->vb
.dfn_cache
.TexCoord2fv
);
1032 make_empty_list( &rmesa
->vb
.dfn_cache
.TexCoord1f
);
1033 make_empty_list( &rmesa
->vb
.dfn_cache
.TexCoord1fv
);
1034 make_empty_list( &rmesa
->vb
.dfn_cache
.MultiTexCoord2fARB
);
1035 make_empty_list( &rmesa
->vb
.dfn_cache
.MultiTexCoord2fvARB
);
1036 make_empty_list( &rmesa
->vb
.dfn_cache
.MultiTexCoord1fARB
);
1037 make_empty_list( &rmesa
->vb
.dfn_cache
.MultiTexCoord1fvARB
);
1039 radeonInitCodegen( &rmesa
->vb
.codegen
, useCodegen
);
1042 static void free_funcs( struct dynfn
*l
)
1044 struct dynfn
*f
, *tmp
;
1045 foreach_s (f
, tmp
, l
) {
1046 remove_from_list( f
);
1047 ALIGN_FREE( f
->code
);
1054 void radeonVtxfmtMakeCurrent( GLcontext
*ctx
)
1059 void radeonVtxfmtDestroy( GLcontext
*ctx
)
1061 radeonContextPtr rmesa
= RADEON_CONTEXT( ctx
);
1063 count_funcs( rmesa
);
1064 free_funcs( &rmesa
->vb
.dfn_cache
.Vertex2f
);
1065 free_funcs( &rmesa
->vb
.dfn_cache
.Vertex2fv
);
1066 free_funcs( &rmesa
->vb
.dfn_cache
.Vertex3f
);
1067 free_funcs( &rmesa
->vb
.dfn_cache
.Vertex3fv
);
1068 free_funcs( &rmesa
->vb
.dfn_cache
.Color4ub
);
1069 free_funcs( &rmesa
->vb
.dfn_cache
.Color4ubv
);
1070 free_funcs( &rmesa
->vb
.dfn_cache
.Color3ub
);
1071 free_funcs( &rmesa
->vb
.dfn_cache
.Color3ubv
);
1072 free_funcs( &rmesa
->vb
.dfn_cache
.Color4f
);
1073 free_funcs( &rmesa
->vb
.dfn_cache
.Color4fv
);
1074 free_funcs( &rmesa
->vb
.dfn_cache
.Color3f
);
1075 free_funcs( &rmesa
->vb
.dfn_cache
.Color3fv
);
1076 free_funcs( &rmesa
->vb
.dfn_cache
.SecondaryColor3ubEXT
);
1077 free_funcs( &rmesa
->vb
.dfn_cache
.SecondaryColor3ubvEXT
);
1078 free_funcs( &rmesa
->vb
.dfn_cache
.SecondaryColor3fEXT
);
1079 free_funcs( &rmesa
->vb
.dfn_cache
.SecondaryColor3fvEXT
);
1080 free_funcs( &rmesa
->vb
.dfn_cache
.Normal3f
);
1081 free_funcs( &rmesa
->vb
.dfn_cache
.Normal3fv
);
1082 free_funcs( &rmesa
->vb
.dfn_cache
.TexCoord2f
);
1083 free_funcs( &rmesa
->vb
.dfn_cache
.TexCoord2fv
);
1084 free_funcs( &rmesa
->vb
.dfn_cache
.TexCoord1f
);
1085 free_funcs( &rmesa
->vb
.dfn_cache
.TexCoord1fv
);
1086 free_funcs( &rmesa
->vb
.dfn_cache
.MultiTexCoord2fARB
);
1087 free_funcs( &rmesa
->vb
.dfn_cache
.MultiTexCoord2fvARB
);
1088 free_funcs( &rmesa
->vb
.dfn_cache
.MultiTexCoord1fARB
);
1089 free_funcs( &rmesa
->vb
.dfn_cache
.MultiTexCoord1fvARB
);