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 #define VERT_ATTRIB_TEX(u) (VERT_ATTRIB_TEX0 + (u))
64 static void radeonVtxfmtFlushVertices( GLcontext
*, GLuint
);
66 static void count_func( const char *name
, struct dynfn
*l
)
71 if (i
) fprintf(stderr
, "%s: %d\n", name
, i
);
74 static void count_funcs( radeonContextPtr rmesa
)
76 count_func( "Vertex2f", &rmesa
->vb
.dfn_cache
.Vertex2f
);
77 count_func( "Vertex2fv", &rmesa
->vb
.dfn_cache
.Vertex2fv
);
78 count_func( "Vertex3f", &rmesa
->vb
.dfn_cache
.Vertex3f
);
79 count_func( "Vertex3fv", &rmesa
->vb
.dfn_cache
.Vertex3fv
);
80 count_func( "Color4ub", &rmesa
->vb
.dfn_cache
.Color4ub
);
81 count_func( "Color4ubv", &rmesa
->vb
.dfn_cache
.Color4ubv
);
82 count_func( "Color3ub", &rmesa
->vb
.dfn_cache
.Color3ub
);
83 count_func( "Color3ubv", &rmesa
->vb
.dfn_cache
.Color3ubv
);
84 count_func( "Color4f", &rmesa
->vb
.dfn_cache
.Color4f
);
85 count_func( "Color4fv", &rmesa
->vb
.dfn_cache
.Color4fv
);
86 count_func( "Color3f", &rmesa
->vb
.dfn_cache
.Color3f
);
87 count_func( "Color3fv", &rmesa
->vb
.dfn_cache
.Color3fv
);
88 count_func( "SecondaryColor3f", &rmesa
->vb
.dfn_cache
.SecondaryColor3fEXT
);
89 count_func( "SecondaryColor3fv", &rmesa
->vb
.dfn_cache
.SecondaryColor3fvEXT
);
90 count_func( "SecondaryColor3ub", &rmesa
->vb
.dfn_cache
.SecondaryColor3ubEXT
);
91 count_func( "SecondaryColor3ubv", &rmesa
->vb
.dfn_cache
.SecondaryColor3ubvEXT
);
92 count_func( "Normal3f", &rmesa
->vb
.dfn_cache
.Normal3f
);
93 count_func( "Normal3fv", &rmesa
->vb
.dfn_cache
.Normal3fv
);
94 count_func( "TexCoord2f", &rmesa
->vb
.dfn_cache
.TexCoord2f
);
95 count_func( "TexCoord2fv", &rmesa
->vb
.dfn_cache
.TexCoord2fv
);
96 count_func( "TexCoord1f", &rmesa
->vb
.dfn_cache
.TexCoord1f
);
97 count_func( "TexCoord1fv", &rmesa
->vb
.dfn_cache
.TexCoord1fv
);
98 count_func( "MultiTexCoord2fARB", &rmesa
->vb
.dfn_cache
.MultiTexCoord2fARB
);
99 count_func( "MultiTexCoord2fvARB", &rmesa
->vb
.dfn_cache
.MultiTexCoord2fvARB
);
100 count_func( "MultiTexCoord1fARB", &rmesa
->vb
.dfn_cache
.MultiTexCoord1fARB
);
101 count_func( "MultiTexCoord1fvARB", &rmesa
->vb
.dfn_cache
.MultiTexCoord1fvARB
);
105 void radeon_copy_to_current( GLcontext
*ctx
)
108 radeonContextPtr rmesa
= RADEON_CONTEXT(ctx
);
110 assert(ctx
->Driver
.NeedFlush
& FLUSH_UPDATE_CURRENT
);
112 if (rmesa
->vb
.vertex_format
& RADEON_CP_VC_FRMT_N0
) {
113 ctx
->Current
.Attrib
[VERT_ATTRIB_NORMAL
][0] = rmesa
->vb
.normalptr
[0];
114 ctx
->Current
.Attrib
[VERT_ATTRIB_NORMAL
][1] = rmesa
->vb
.normalptr
[1];
115 ctx
->Current
.Attrib
[VERT_ATTRIB_NORMAL
][2] = rmesa
->vb
.normalptr
[2];
118 if (rmesa
->vb
.vertex_format
& RADEON_CP_VC_FRMT_PKCOLOR
) {
119 ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][0] = UBYTE_TO_FLOAT( rmesa
->vb
.colorptr
->red
);
120 ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][1] = UBYTE_TO_FLOAT( rmesa
->vb
.colorptr
->green
);
121 ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][2] = UBYTE_TO_FLOAT( rmesa
->vb
.colorptr
->blue
);
122 ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][3] = UBYTE_TO_FLOAT( rmesa
->vb
.colorptr
->alpha
);
125 if (rmesa
->vb
.vertex_format
& RADEON_CP_VC_FRMT_FPCOLOR
) {
126 ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][0] = rmesa
->vb
.floatcolorptr
[0];
127 ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][1] = rmesa
->vb
.floatcolorptr
[1];
128 ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][2] = rmesa
->vb
.floatcolorptr
[2];
131 if (rmesa
->vb
.vertex_format
& RADEON_CP_VC_FRMT_FPALPHA
)
132 ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][3] = rmesa
->vb
.floatcolorptr
[3];
134 if (rmesa
->vb
.vertex_format
& RADEON_CP_VC_FRMT_PKSPEC
) {
135 ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR1
][0] = UBYTE_TO_FLOAT( rmesa
->vb
.specptr
->red
);
136 ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR1
][1] = UBYTE_TO_FLOAT( rmesa
->vb
.specptr
->green
);
137 ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR1
][2] = UBYTE_TO_FLOAT( rmesa
->vb
.specptr
->blue
);
140 for (unit
= 0 ; unit
< ctx
->Const
.MaxTextureUnits
; unit
++) {
141 if (rmesa
->vb
.vertex_format
& RADEON_ST_BIT(unit
)) {
142 ctx
->Current
.Attrib
[VERT_ATTRIB_TEX(unit
)][0] = rmesa
->vb
.texcoordptr
[unit
][0];
143 ctx
->Current
.Attrib
[VERT_ATTRIB_TEX(unit
)][1] = rmesa
->vb
.texcoordptr
[unit
][1];
144 ctx
->Current
.Attrib
[VERT_ATTRIB_TEX(unit
)][2] = 0.0F
;
145 ctx
->Current
.Attrib
[VERT_ATTRIB_TEX(unit
)][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
= NULL
;
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
)[RADEON_MAX_VERTEX_SIZE
] )
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
);
357 GLfloat tmp
[3][RADEON_MAX_VERTEX_SIZE
];
359 GLuint ind
= rmesa
->vb
.vertex_format
;
364 if (RADEON_DEBUG
& (DEBUG_FALLBACKS
|DEBUG_VFMT
))
365 fprintf(stderr
, "%s from %s\n", __FUNCTION__
, caller
);
367 if (rmesa
->vb
.prim
[0] == GL_POLYGON
+1) {
368 VFMT_FALLBACK_OUTSIDE_BEGIN_END( __FUNCTION__
);
372 /* Copy vertices out of dma:
374 nrverts
= copy_dma_verts( rmesa
, tmp
);
376 /* Finish the prim at this point:
378 note_last_prim( rmesa
, 0 );
379 flush_prims( rmesa
);
381 /* Update ctx->Driver.CurrentExecPrimitive and swap in swtnl.
383 prim
= rmesa
->vb
.prim
[0];
384 ctx
->Driver
.CurrentExecPrimitive
= GL_POLYGON
+1;
385 _tnl_wakeup_exec( ctx
);
386 ctx
->Driver
.FlushVertices
= radeonFlushVertices
;
388 assert(rmesa
->dma
.flush
== 0);
389 rmesa
->vb
.fell_back
= GL_TRUE
;
390 rmesa
->vb
.installed
= GL_FALSE
;
391 CALL_Begin(GET_DISPATCH(), (prim
));
393 if (rmesa
->vb
.installed_color_3f_sz
== 4)
394 alpha
= ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][3];
396 /* Replay saved vertices
398 for (i
= 0 ; i
< nrverts
; i
++) {
400 if (ind
& RADEON_CP_VC_FRMT_N0
) {
401 CALL_Normal3fv(GET_DISPATCH(), (&tmp
[i
][offset
]));
405 if (ind
& RADEON_CP_VC_FRMT_PKCOLOR
) {
406 radeon_color_t
*col
= (radeon_color_t
*)&tmp
[i
][offset
];
407 CALL_Color4ub(GET_DISPATCH(), (col
->red
, col
->green
, col
->blue
, col
->alpha
));
410 else if (ind
& RADEON_CP_VC_FRMT_FPALPHA
) {
411 CALL_Color4fv(GET_DISPATCH(), (&tmp
[i
][offset
]));
414 else if (ind
& RADEON_CP_VC_FRMT_FPCOLOR
) {
415 CALL_Color3fv(GET_DISPATCH(), (&tmp
[i
][offset
]));
419 if (ind
& RADEON_CP_VC_FRMT_PKSPEC
) {
420 radeon_color_t
*spec
= (radeon_color_t
*)&tmp
[i
][offset
];
421 CALL_SecondaryColor3ubEXT(GET_DISPATCH(), (spec
->red
, spec
->green
, spec
->blue
));
425 for (unit
= 0 ; unit
< ctx
->Const
.MaxTextureUnits
; unit
++) {
426 if (ind
& RADEON_ST_BIT(unit
)) {
427 CALL_MultiTexCoord2fvARB(GET_DISPATCH(), ((GL_TEXTURE0
+ unit
), &tmp
[i
][offset
]));
431 CALL_Vertex3fv(GET_DISPATCH(), (&tmp
[i
][0]));
434 /* Replay current vertex
436 if (ind
& RADEON_CP_VC_FRMT_N0
)
437 CALL_Normal3fv(GET_DISPATCH(), (rmesa
->vb
.normalptr
));
439 if (ind
& RADEON_CP_VC_FRMT_PKCOLOR
)
440 CALL_Color4ub(GET_DISPATCH(), (rmesa
->vb
.colorptr
->red
, rmesa
->vb
.colorptr
->green
,
441 rmesa
->vb
.colorptr
->blue
, rmesa
->vb
.colorptr
->alpha
));
442 else if (ind
& RADEON_CP_VC_FRMT_FPALPHA
)
443 CALL_Color4fv(GET_DISPATCH(), (rmesa
->vb
.floatcolorptr
));
444 else if (ind
& RADEON_CP_VC_FRMT_FPCOLOR
) {
445 if (rmesa
->vb
.installed_color_3f_sz
== 4 && alpha
!= 1.0)
446 CALL_Color4f(GET_DISPATCH(), (rmesa
->vb
.floatcolorptr
[0],
447 rmesa
->vb
.floatcolorptr
[1],
448 rmesa
->vb
.floatcolorptr
[2],
451 CALL_Color3fv(GET_DISPATCH(), (rmesa
->vb
.floatcolorptr
));
454 if (ind
& RADEON_CP_VC_FRMT_PKSPEC
)
455 CALL_SecondaryColor3ubEXT(GET_DISPATCH(), (rmesa
->vb
.specptr
->red
,
456 rmesa
->vb
.specptr
->green
,
457 rmesa
->vb
.specptr
->blue
));
459 for (unit
= 0 ; unit
< ctx
->Const
.MaxTextureUnits
; unit
++) {
460 if (ind
& RADEON_ST_BIT(unit
)) {
461 CALL_MultiTexCoord2fvARB(GET_DISPATCH(), ((GL_TEXTURE0
+ unit
),
462 rmesa
->vb
.texcoordptr
[unit
]));
469 static void wrap_buffer( void )
471 GET_CURRENT_CONTEXT(ctx
);
472 radeonContextPtr rmesa
= RADEON_CONTEXT(ctx
);
473 GLfloat tmp
[3][RADEON_MAX_VERTEX_SIZE
];
476 if (RADEON_DEBUG
& (DEBUG_VFMT
|DEBUG_PRIMS
))
477 fprintf(stderr
, "%s %d\n", __FUNCTION__
, rmesa
->vb
.initial_counter
- rmesa
->vb
.counter
);
479 /* Don't deal with parity.
481 if ((((rmesa
->vb
.initial_counter
- rmesa
->vb
.counter
) -
482 rmesa
->vb
.primlist
[rmesa
->vb
.nrprims
].start
) & 1)) {
484 rmesa
->vb
.initial_counter
++;
488 /* Copy vertices out of dma:
490 if (rmesa
->vb
.prim
[0] == GL_POLYGON
+1)
493 nrverts
= copy_dma_verts( rmesa
, tmp
);
495 if (RADEON_DEBUG
& DEBUG_VFMT
)
496 fprintf(stderr
, "%d vertices to copy\n", nrverts
);
498 /* Finish the prim at this point:
500 note_last_prim( rmesa
, 0 );
503 /* Fire any buffered primitives
505 flush_prims( rmesa
);
509 radeonRefillCurrentDmaRegion( rmesa
);
511 /* Reset counter, dmaptr
513 rmesa
->vb
.dmaptr
= (int *)(rmesa
->dma
.current
.ptr
+ rmesa
->dma
.current
.address
);
514 rmesa
->vb
.counter
= (rmesa
->dma
.current
.end
- rmesa
->dma
.current
.ptr
) /
515 (rmesa
->vb
.vertex_size
* 4);
517 rmesa
->vb
.initial_counter
= rmesa
->vb
.counter
;
518 rmesa
->vb
.notify
= wrap_buffer
;
520 rmesa
->dma
.flush
= flush_prims
;
522 /* Restart wrapped primitive:
524 if (rmesa
->vb
.prim
[0] != GL_POLYGON
+1)
525 start_prim( rmesa
, rmesa
->vb
.prim
[0] );
527 /* Reemit saved vertices
529 for (i
= 0 ; i
< nrverts
; i
++) {
530 if (RADEON_DEBUG
& DEBUG_VERTS
) {
532 fprintf(stderr
, "re-emit vertex %d to %p\n", i
, (void *)rmesa
->vb
.dmaptr
);
533 if (RADEON_DEBUG
& DEBUG_VERBOSE
)
534 for (j
= 0 ; j
< rmesa
->vb
.vertex_size
; j
++)
535 fprintf(stderr
, "\t%08x/%f\n", *(int*)&tmp
[i
][j
], tmp
[i
][j
]);
538 memcpy( rmesa
->vb
.dmaptr
, tmp
[i
], rmesa
->vb
.vertex_size
* 4 );
539 rmesa
->vb
.dmaptr
+= rmesa
->vb
.vertex_size
;
546 static GLboolean
check_vtx_fmt( GLcontext
*ctx
)
548 radeonContextPtr rmesa
= RADEON_CONTEXT(ctx
);
549 GLuint ind
= RADEON_CP_VC_FRMT_Z
;
552 if (rmesa
->TclFallback
|| rmesa
->vb
.fell_back
|| ctx
->CompileFlag
||
553 (ctx
->Fog
.Enabled
&& (ctx
->Fog
.FogCoordinateSource
== GL_FOG_COORD
)))
556 if (ctx
->Driver
.NeedFlush
& FLUSH_UPDATE_CURRENT
)
557 ctx
->Driver
.FlushVertices( ctx
, FLUSH_UPDATE_CURRENT
);
559 /* Make all this event-driven:
561 if (ctx
->Light
.Enabled
) {
562 ind
|= RADEON_CP_VC_FRMT_N0
;
564 /* TODO: make this data driven: If we receive only ubytes, send
565 * color as ubytes. Also check if converting (with free
566 * checking for overflow) is cheaper than sending floats
569 if (ctx
->Light
.ColorMaterialEnabled
) {
570 ind
|= (RADEON_CP_VC_FRMT_FPCOLOR
|
571 RADEON_CP_VC_FRMT_FPALPHA
);
574 ind
|= RADEON_CP_VC_FRMT_PKCOLOR
; /* for alpha? */
577 /* TODO: make this data driven?
579 ind
|= RADEON_CP_VC_FRMT_PKCOLOR
;
581 if (ctx
->_TriangleCaps
& DD_SEPARATE_SPECULAR
) {
582 ind
|= RADEON_CP_VC_FRMT_PKSPEC
;
586 if ( ctx
->Fog
.FogCoordinateSource
== GL_FOG_COORD
) {
587 ind
|= RADEON_CP_VC_FRMT_PKSPEC
;
590 for (unit
= 0 ; unit
< ctx
->Const
.MaxTextureUnits
; unit
++) {
591 if (ctx
->Texture
.Unit
[unit
]._ReallyEnabled
) {
592 if (ctx
->Texture
.Unit
[unit
].TexGenEnabled
) {
593 if (rmesa
->TexGenNeedNormals
[unit
]) {
594 ind
|= RADEON_CP_VC_FRMT_N0
;
597 if (ctx
->Current
.Attrib
[VERT_ATTRIB_TEX(unit
)][3] != 1.0) {
598 if (RADEON_DEBUG
& (DEBUG_VFMT
|DEBUG_FALLBACKS
))
599 fprintf(stderr
, "%s: q%u\n", __FUNCTION__
, unit
);
602 ind
|= RADEON_ST_BIT(unit
);
607 if (RADEON_DEBUG
& (DEBUG_VFMT
|DEBUG_STATE
))
608 fprintf(stderr
, "%s: format: 0x%x\n", __FUNCTION__
, ind
);
610 RADEON_NEWPRIM(rmesa
);
611 rmesa
->vb
.vertex_format
= ind
;
612 rmesa
->vb
.vertex_size
= 3;
613 rmesa
->vb
.prim
= &ctx
->Driver
.CurrentExecPrimitive
;
615 rmesa
->vb
.normalptr
= ctx
->Current
.Attrib
[VERT_ATTRIB_NORMAL
];
616 rmesa
->vb
.colorptr
= NULL
;
617 rmesa
->vb
.floatcolorptr
= ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
];
618 rmesa
->vb
.specptr
= NULL
;
619 rmesa
->vb
.floatspecptr
= ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR1
];
620 rmesa
->vb
.texcoordptr
[0] = ctx
->Current
.Attrib
[VERT_ATTRIB_TEX0
];
621 rmesa
->vb
.texcoordptr
[1] = ctx
->Current
.Attrib
[VERT_ATTRIB_TEX1
];
622 rmesa
->vb
.texcoordptr
[2] = ctx
->Current
.Attrib
[VERT_ATTRIB_TEX2
];
623 rmesa
->vb
.texcoordptr
[3] = ctx
->Current
.Attrib
[VERT_ATTRIB_TEX0
]; /* dummy */
625 /* Run through and initialize the vertex components in the order
626 * the hardware understands:
628 if (ind
& RADEON_CP_VC_FRMT_N0
) {
629 rmesa
->vb
.normalptr
= &rmesa
->vb
.vertex
[rmesa
->vb
.vertex_size
].f
;
630 rmesa
->vb
.vertex_size
+= 3;
631 rmesa
->vb
.normalptr
[0] = ctx
->Current
.Attrib
[VERT_ATTRIB_NORMAL
][0];
632 rmesa
->vb
.normalptr
[1] = ctx
->Current
.Attrib
[VERT_ATTRIB_NORMAL
][1];
633 rmesa
->vb
.normalptr
[2] = ctx
->Current
.Attrib
[VERT_ATTRIB_NORMAL
][2];
636 if (ind
& RADEON_CP_VC_FRMT_PKCOLOR
) {
637 rmesa
->vb
.colorptr
= &rmesa
->vb
.vertex
[rmesa
->vb
.vertex_size
].color
;
638 rmesa
->vb
.vertex_size
+= 1;
639 UNCLAMPED_FLOAT_TO_CHAN( rmesa
->vb
.colorptr
->red
, ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][0] );
640 UNCLAMPED_FLOAT_TO_CHAN( rmesa
->vb
.colorptr
->green
, ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][1] );
641 UNCLAMPED_FLOAT_TO_CHAN( rmesa
->vb
.colorptr
->blue
, ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][2] );
642 UNCLAMPED_FLOAT_TO_CHAN( rmesa
->vb
.colorptr
->alpha
, ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][3] );
645 if (ind
& RADEON_CP_VC_FRMT_FPCOLOR
) {
646 assert(!(ind
& RADEON_CP_VC_FRMT_PKCOLOR
));
647 rmesa
->vb
.floatcolorptr
= &rmesa
->vb
.vertex
[rmesa
->vb
.vertex_size
].f
;
648 rmesa
->vb
.vertex_size
+= 3;
649 rmesa
->vb
.floatcolorptr
[0] = ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][0];
650 rmesa
->vb
.floatcolorptr
[1] = ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][1];
651 rmesa
->vb
.floatcolorptr
[2] = ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][2];
653 if (ind
& RADEON_CP_VC_FRMT_FPALPHA
) {
654 rmesa
->vb
.vertex_size
+= 1;
655 rmesa
->vb
.floatcolorptr
[3] = ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][3];
659 if (ind
& RADEON_CP_VC_FRMT_PKSPEC
) {
660 rmesa
->vb
.specptr
= &rmesa
->vb
.vertex
[rmesa
->vb
.vertex_size
].color
;
661 rmesa
->vb
.vertex_size
+= 1;
662 UNCLAMPED_FLOAT_TO_CHAN( rmesa
->vb
.specptr
->red
, ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR1
][0] );
663 UNCLAMPED_FLOAT_TO_CHAN( rmesa
->vb
.specptr
->green
, ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR1
][1] );
664 UNCLAMPED_FLOAT_TO_CHAN( rmesa
->vb
.specptr
->blue
, ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR1
][2] );
666 /* UNCLAMPED_FLOAT_TO_CHAN( rmesa->vb.specptr->alpha,
667 radeonComputeFogFactor(ctx->Current.Attrib[VERT_ATTRIB_FOG][0]) ); */
670 for (unit
= 0 ; unit
< ctx
->Const
.MaxTextureUnits
; unit
++) {
671 if (ind
& RADEON_ST_BIT(unit
)) {
672 rmesa
->vb
.texcoordptr
[unit
] = &rmesa
->vb
.vertex
[rmesa
->vb
.vertex_size
].f
;
673 rmesa
->vb
.vertex_size
+= 2;
674 rmesa
->vb
.texcoordptr
[unit
][0] = ctx
->Current
.Attrib
[VERT_ATTRIB_TEX(unit
)][0];
675 rmesa
->vb
.texcoordptr
[unit
][1] = ctx
->Current
.Attrib
[VERT_ATTRIB_TEX(unit
)][1];
679 if (rmesa
->vb
.installed_vertex_format
!= rmesa
->vb
.vertex_format
) {
680 if (RADEON_DEBUG
& DEBUG_VFMT
)
681 fprintf(stderr
, "reinstall on vertex_format change\n");
682 _mesa_install_exec_vtxfmt( ctx
, &rmesa
->vb
.vtxfmt
);
683 rmesa
->vb
.installed_vertex_format
= rmesa
->vb
.vertex_format
;
686 if (RADEON_DEBUG
& DEBUG_VFMT
)
687 fprintf(stderr
, "%s -- success\n", __FUNCTION__
);
692 void radeonVtxfmtInvalidate( GLcontext
*ctx
)
694 radeonContextPtr rmesa
= RADEON_CONTEXT( ctx
);
696 rmesa
->vb
.recheck
= GL_TRUE
;
697 rmesa
->vb
.fell_back
= GL_FALSE
;
701 static void radeonVtxfmtValidate( GLcontext
*ctx
)
703 radeonContextPtr rmesa
= RADEON_CONTEXT( ctx
);
705 if (RADEON_DEBUG
& DEBUG_VFMT
)
706 fprintf(stderr
, "%s\n", __FUNCTION__
);
708 if (ctx
->Driver
.NeedFlush
)
709 ctx
->Driver
.FlushVertices( ctx
, ctx
->Driver
.NeedFlush
);
711 rmesa
->vb
.recheck
= GL_FALSE
;
713 if (check_vtx_fmt( ctx
)) {
714 if (!rmesa
->vb
.installed
) {
715 if (RADEON_DEBUG
& DEBUG_VFMT
)
716 fprintf(stderr
, "reinstall (new install)\n");
718 _mesa_install_exec_vtxfmt( ctx
, &rmesa
->vb
.vtxfmt
);
719 ctx
->Driver
.FlushVertices
= radeonVtxfmtFlushVertices
;
720 rmesa
->vb
.installed
= GL_TRUE
;
722 else if (RADEON_DEBUG
& DEBUG_VFMT
)
723 fprintf(stderr
, "%s: already installed", __FUNCTION__
);
726 if (RADEON_DEBUG
& DEBUG_VFMT
)
727 fprintf(stderr
, "%s: failed\n", __FUNCTION__
);
729 if (rmesa
->vb
.installed
) {
730 if (rmesa
->dma
.flush
)
731 rmesa
->dma
.flush( rmesa
);
732 _tnl_wakeup_exec( ctx
);
733 ctx
->Driver
.FlushVertices
= radeonFlushVertices
;
734 rmesa
->vb
.installed
= GL_FALSE
;
743 static void radeon_Materialfv( GLenum face
, GLenum pname
,
744 const GLfloat
*params
)
746 GET_CURRENT_CONTEXT(ctx
);
747 radeonContextPtr rmesa
= RADEON_CONTEXT( ctx
);
749 if (RADEON_DEBUG
& DEBUG_VFMT
)
750 fprintf(stderr
, "%s\n", __FUNCTION__
);
752 if (rmesa
->vb
.prim
[0] != GL_POLYGON
+1) {
753 VFMT_FALLBACK( __FUNCTION__
);
754 CALL_Materialfv(GET_DISPATCH(), (face
, pname
, params
));
757 _mesa_noop_Materialfv( face
, pname
, params
);
758 radeonUpdateMaterial( ctx
);
764 static void radeon_Begin( GLenum mode
)
766 GET_CURRENT_CONTEXT(ctx
);
767 radeonContextPtr rmesa
= RADEON_CONTEXT(ctx
);
769 if (RADEON_DEBUG
& DEBUG_VFMT
)
770 fprintf(stderr
, "%s( %s )\n", __FUNCTION__
,
771 _mesa_lookup_enum_by_nr( mode
));
773 if (mode
> GL_POLYGON
) {
774 _mesa_error( ctx
, GL_INVALID_ENUM
, "glBegin" );
778 if (rmesa
->vb
.prim
[0] != GL_POLYGON
+1) {
779 _mesa_error( ctx
, GL_INVALID_OPERATION
, "glBegin" );
784 _mesa_update_state( ctx
);
786 if (rmesa
->NewGLState
)
787 radeonValidateState( ctx
);
789 if (rmesa
->vb
.recheck
)
790 radeonVtxfmtValidate( ctx
);
792 if (!rmesa
->vb
.installed
) {
793 CALL_Begin(GET_DISPATCH(), (mode
));
798 if (rmesa
->dma
.flush
&& rmesa
->vb
.counter
< 12) {
799 if (RADEON_DEBUG
& DEBUG_VFMT
)
800 fprintf(stderr
, "%s: flush almost-empty buffers\n", __FUNCTION__
);
801 flush_prims( rmesa
);
804 /* Need to arrange to save vertices here? Or always copy from dma (yuk)?
806 if (!rmesa
->dma
.flush
) {
807 /* FIXME: what are these constants? */
808 if (rmesa
->dma
.current
.ptr
+ 12*rmesa
->vb
.vertex_size
*4 >
809 rmesa
->dma
.current
.end
) {
810 RADEON_NEWPRIM( rmesa
);
811 radeonRefillCurrentDmaRegion( rmesa
);
814 rmesa
->vb
.dmaptr
= (int *)(rmesa
->dma
.current
.address
+ rmesa
->dma
.current
.ptr
);
815 rmesa
->vb
.counter
= (rmesa
->dma
.current
.end
- rmesa
->dma
.current
.ptr
) /
816 (rmesa
->vb
.vertex_size
* 4);
818 rmesa
->vb
.initial_counter
= rmesa
->vb
.counter
;
819 rmesa
->vb
.notify
= wrap_buffer
;
820 rmesa
->dma
.flush
= flush_prims
;
821 ctx
->Driver
.NeedFlush
|= FLUSH_STORED_VERTICES
;
825 rmesa
->vb
.prim
[0] = mode
;
826 start_prim( rmesa
, mode
| PRIM_BEGIN
);
831 static void radeon_End( void )
833 GET_CURRENT_CONTEXT(ctx
);
834 radeonContextPtr rmesa
= RADEON_CONTEXT(ctx
);
836 if (RADEON_DEBUG
& DEBUG_VFMT
)
837 fprintf(stderr
, "%s\n", __FUNCTION__
);
839 if (rmesa
->vb
.prim
[0] == GL_POLYGON
+1) {
840 _mesa_error( ctx
, GL_INVALID_OPERATION
, "glEnd" );
844 note_last_prim( rmesa
, PRIM_END
);
845 rmesa
->vb
.prim
[0] = GL_POLYGON
+1;
849 /* Fallback on difficult entrypoints:
851 #define PRE_LOOPBACK( FUNC ) \
853 if (RADEON_DEBUG & DEBUG_VFMT) \
854 fprintf(stderr, "%s\n", __FUNCTION__); \
855 VFMT_FALLBACK( __FUNCTION__ ); \
857 #define TAG(x) radeon_fallback_##x
858 #include "vtxfmt_tmp.h"
862 static GLboolean
radeonNotifyBegin( GLcontext
*ctx
, GLenum p
)
864 radeonContextPtr rmesa
= RADEON_CONTEXT( ctx
);
866 if (RADEON_DEBUG
& DEBUG_VFMT
)
867 fprintf(stderr
, "%s\n", __FUNCTION__
);
869 assert(!rmesa
->vb
.installed
);
872 _mesa_update_state( ctx
);
874 if (rmesa
->NewGLState
)
875 radeonValidateState( ctx
);
877 if (ctx
->Driver
.NeedFlush
)
878 ctx
->Driver
.FlushVertices( ctx
, ctx
->Driver
.NeedFlush
);
880 if (rmesa
->vb
.recheck
)
881 radeonVtxfmtValidate( ctx
);
883 if (!rmesa
->vb
.installed
) {
884 if (RADEON_DEBUG
& DEBUG_VFMT
)
885 fprintf(stderr
, "%s -- failed\n", __FUNCTION__
);
893 static void radeonVtxfmtFlushVertices( GLcontext
*ctx
, GLuint flags
)
895 radeonContextPtr rmesa
= RADEON_CONTEXT( ctx
);
897 if (RADEON_DEBUG
& DEBUG_VFMT
)
898 fprintf(stderr
, "%s\n", __FUNCTION__
);
900 assert(rmesa
->vb
.installed
);
902 if (flags
& FLUSH_UPDATE_CURRENT
) {
903 radeon_copy_to_current( ctx
);
904 if (RADEON_DEBUG
& DEBUG_VFMT
)
905 fprintf(stderr
, "reinstall on update_current\n");
906 _mesa_install_exec_vtxfmt( ctx
, &rmesa
->vb
.vtxfmt
);
907 ctx
->Driver
.NeedFlush
&= ~FLUSH_UPDATE_CURRENT
;
910 if (flags
& FLUSH_STORED_VERTICES
) {
911 radeonContextPtr rmesa
= RADEON_CONTEXT( ctx
);
912 assert (rmesa
->dma
.flush
== 0 ||
913 rmesa
->dma
.flush
== flush_prims
);
914 if (rmesa
->dma
.flush
== flush_prims
)
915 flush_prims( RADEON_CONTEXT( ctx
) );
916 ctx
->Driver
.NeedFlush
&= ~FLUSH_STORED_VERTICES
;
922 /* At this point, don't expect very many versions of each function to
923 * be generated, so not concerned about freeing them?
927 void radeonVtxfmtInit( GLcontext
*ctx
, GLboolean useCodegen
)
929 radeonContextPtr rmesa
= RADEON_CONTEXT( ctx
);
930 GLvertexformat
*vfmt
= &(rmesa
->vb
.vtxfmt
);
932 MEMSET( vfmt
, 0, sizeof(GLvertexformat
) );
934 /* Hook in chooser functions for codegen, etc:
936 radeonVtxfmtInitChoosers( vfmt
);
938 /* Handled fully in supported states, but no codegen:
940 vfmt
->Materialfv
= radeon_Materialfv
;
941 vfmt
->ArrayElement
= _ae_loopback_array_elt
; /* generic helper */
942 vfmt
->Rectf
= _mesa_noop_Rectf
; /* generic helper */
943 vfmt
->Begin
= radeon_Begin
;
944 vfmt
->End
= radeon_End
;
946 /* Fallback for performance reasons: (Fix with cva/elt path here and
947 * dmatmp2.h style primitive-merging)
949 * These should call NotifyBegin(), as should _tnl_EvalMesh, to allow
952 vfmt
->DrawArrays
= radeon_fallback_DrawArrays
;
953 vfmt
->DrawElements
= radeon_fallback_DrawElements
;
954 vfmt
->DrawRangeElements
= radeon_fallback_DrawRangeElements
;
957 /* Not active in supported states; just keep ctx->Current uptodate:
959 vfmt
->EdgeFlag
= _mesa_noop_EdgeFlag
;
960 vfmt
->EdgeFlagv
= _mesa_noop_EdgeFlagv
;
961 vfmt
->Indexf
= _mesa_noop_Indexf
;
962 vfmt
->Indexfv
= _mesa_noop_Indexfv
;
965 /* Active but unsupported -- fallback if we receive these:
967 vfmt
->CallList
= radeon_fallback_CallList
;
968 vfmt
->CallLists
= radeon_fallback_CallLists
;
969 vfmt
->EvalCoord1f
= radeon_fallback_EvalCoord1f
;
970 vfmt
->EvalCoord1fv
= radeon_fallback_EvalCoord1fv
;
971 vfmt
->EvalCoord2f
= radeon_fallback_EvalCoord2f
;
972 vfmt
->EvalCoord2fv
= radeon_fallback_EvalCoord2fv
;
973 vfmt
->EvalMesh1
= radeon_fallback_EvalMesh1
;
974 vfmt
->EvalMesh2
= radeon_fallback_EvalMesh2
;
975 vfmt
->EvalPoint1
= radeon_fallback_EvalPoint1
;
976 vfmt
->EvalPoint2
= radeon_fallback_EvalPoint2
;
977 vfmt
->TexCoord3f
= radeon_fallback_TexCoord3f
;
978 vfmt
->TexCoord3fv
= radeon_fallback_TexCoord3fv
;
979 vfmt
->TexCoord4f
= radeon_fallback_TexCoord4f
;
980 vfmt
->TexCoord4fv
= radeon_fallback_TexCoord4fv
;
981 vfmt
->MultiTexCoord3fARB
= radeon_fallback_MultiTexCoord3fARB
;
982 vfmt
->MultiTexCoord3fvARB
= radeon_fallback_MultiTexCoord3fvARB
;
983 vfmt
->MultiTexCoord4fARB
= radeon_fallback_MultiTexCoord4fARB
;
984 vfmt
->MultiTexCoord4fvARB
= radeon_fallback_MultiTexCoord4fvARB
;
985 vfmt
->Vertex4f
= radeon_fallback_Vertex4f
;
986 vfmt
->Vertex4fv
= radeon_fallback_Vertex4fv
;
987 vfmt
->VertexAttrib1fNV
= radeon_fallback_VertexAttrib1fNV
;
988 vfmt
->VertexAttrib1fvNV
= radeon_fallback_VertexAttrib1fvNV
;
989 vfmt
->VertexAttrib2fNV
= radeon_fallback_VertexAttrib2fNV
;
990 vfmt
->VertexAttrib2fvNV
= radeon_fallback_VertexAttrib2fvNV
;
991 vfmt
->VertexAttrib3fNV
= radeon_fallback_VertexAttrib3fNV
;
992 vfmt
->VertexAttrib3fvNV
= radeon_fallback_VertexAttrib3fvNV
;
993 vfmt
->VertexAttrib4fNV
= radeon_fallback_VertexAttrib4fNV
;
994 vfmt
->VertexAttrib4fvNV
= radeon_fallback_VertexAttrib4fvNV
;
995 vfmt
->FogCoordfEXT
= radeon_fallback_FogCoordfEXT
;
996 vfmt
->FogCoordfvEXT
= radeon_fallback_FogCoordfvEXT
;
998 (void)radeon_fallback_vtxfmt
;
1000 TNL_CONTEXT(ctx
)->Driver
.NotifyBegin
= radeonNotifyBegin
;
1002 rmesa
->vb
.enabled
= 1;
1003 rmesa
->vb
.prim
= &ctx
->Driver
.CurrentExecPrimitive
;
1004 rmesa
->vb
.primflags
= 0;
1006 make_empty_list( &rmesa
->vb
.dfn_cache
.Vertex2f
);
1007 make_empty_list( &rmesa
->vb
.dfn_cache
.Vertex2fv
);
1008 make_empty_list( &rmesa
->vb
.dfn_cache
.Vertex3f
);
1009 make_empty_list( &rmesa
->vb
.dfn_cache
.Vertex3fv
);
1010 make_empty_list( &rmesa
->vb
.dfn_cache
.Color4ub
);
1011 make_empty_list( &rmesa
->vb
.dfn_cache
.Color4ubv
);
1012 make_empty_list( &rmesa
->vb
.dfn_cache
.Color3ub
);
1013 make_empty_list( &rmesa
->vb
.dfn_cache
.Color3ubv
);
1014 make_empty_list( &rmesa
->vb
.dfn_cache
.Color4f
);
1015 make_empty_list( &rmesa
->vb
.dfn_cache
.Color4fv
);
1016 make_empty_list( &rmesa
->vb
.dfn_cache
.Color3f
);
1017 make_empty_list( &rmesa
->vb
.dfn_cache
.Color3fv
);
1018 make_empty_list( &rmesa
->vb
.dfn_cache
.SecondaryColor3fEXT
);
1019 make_empty_list( &rmesa
->vb
.dfn_cache
.SecondaryColor3fvEXT
);
1020 make_empty_list( &rmesa
->vb
.dfn_cache
.SecondaryColor3ubEXT
);
1021 make_empty_list( &rmesa
->vb
.dfn_cache
.SecondaryColor3ubvEXT
);
1022 make_empty_list( &rmesa
->vb
.dfn_cache
.Normal3f
);
1023 make_empty_list( &rmesa
->vb
.dfn_cache
.Normal3fv
);
1024 make_empty_list( &rmesa
->vb
.dfn_cache
.TexCoord2f
);
1025 make_empty_list( &rmesa
->vb
.dfn_cache
.TexCoord2fv
);
1026 make_empty_list( &rmesa
->vb
.dfn_cache
.TexCoord1f
);
1027 make_empty_list( &rmesa
->vb
.dfn_cache
.TexCoord1fv
);
1028 make_empty_list( &rmesa
->vb
.dfn_cache
.MultiTexCoord2fARB
);
1029 make_empty_list( &rmesa
->vb
.dfn_cache
.MultiTexCoord2fvARB
);
1030 make_empty_list( &rmesa
->vb
.dfn_cache
.MultiTexCoord1fARB
);
1031 make_empty_list( &rmesa
->vb
.dfn_cache
.MultiTexCoord1fvARB
);
1033 radeonInitCodegen( &rmesa
->vb
.codegen
, useCodegen
);
1036 static void free_funcs( struct dynfn
*l
)
1038 struct dynfn
*f
, *tmp
;
1039 foreach_s (f
, tmp
, l
) {
1040 remove_from_list( f
);
1041 _mesa_exec_free( f
->code
);
1048 void radeonVtxfmtMakeCurrent( GLcontext
*ctx
)
1053 void radeonVtxfmtDestroy( GLcontext
*ctx
)
1055 radeonContextPtr rmesa
= RADEON_CONTEXT( ctx
);
1057 count_funcs( rmesa
);
1058 free_funcs( &rmesa
->vb
.dfn_cache
.Vertex2f
);
1059 free_funcs( &rmesa
->vb
.dfn_cache
.Vertex2fv
);
1060 free_funcs( &rmesa
->vb
.dfn_cache
.Vertex3f
);
1061 free_funcs( &rmesa
->vb
.dfn_cache
.Vertex3fv
);
1062 free_funcs( &rmesa
->vb
.dfn_cache
.Color4ub
);
1063 free_funcs( &rmesa
->vb
.dfn_cache
.Color4ubv
);
1064 free_funcs( &rmesa
->vb
.dfn_cache
.Color3ub
);
1065 free_funcs( &rmesa
->vb
.dfn_cache
.Color3ubv
);
1066 free_funcs( &rmesa
->vb
.dfn_cache
.Color4f
);
1067 free_funcs( &rmesa
->vb
.dfn_cache
.Color4fv
);
1068 free_funcs( &rmesa
->vb
.dfn_cache
.Color3f
);
1069 free_funcs( &rmesa
->vb
.dfn_cache
.Color3fv
);
1070 free_funcs( &rmesa
->vb
.dfn_cache
.SecondaryColor3ubEXT
);
1071 free_funcs( &rmesa
->vb
.dfn_cache
.SecondaryColor3ubvEXT
);
1072 free_funcs( &rmesa
->vb
.dfn_cache
.SecondaryColor3fEXT
);
1073 free_funcs( &rmesa
->vb
.dfn_cache
.SecondaryColor3fvEXT
);
1074 free_funcs( &rmesa
->vb
.dfn_cache
.Normal3f
);
1075 free_funcs( &rmesa
->vb
.dfn_cache
.Normal3fv
);
1076 free_funcs( &rmesa
->vb
.dfn_cache
.TexCoord2f
);
1077 free_funcs( &rmesa
->vb
.dfn_cache
.TexCoord2fv
);
1078 free_funcs( &rmesa
->vb
.dfn_cache
.TexCoord1f
);
1079 free_funcs( &rmesa
->vb
.dfn_cache
.TexCoord1fv
);
1080 free_funcs( &rmesa
->vb
.dfn_cache
.MultiTexCoord2fARB
);
1081 free_funcs( &rmesa
->vb
.dfn_cache
.MultiTexCoord2fvARB
);
1082 free_funcs( &rmesa
->vb
.dfn_cache
.MultiTexCoord1fARB
);
1083 free_funcs( &rmesa
->vb
.dfn_cache
.MultiTexCoord1fvARB
);