projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
fix some obvious typos in radeon_reg.h (only currently unused bits affected)
[mesa.git] / src / mesa / drivers / dri / radeon / radeon_vtxfmt.c
1 /* $XFree86: xc/lib/GL/mesa/src/drv/radeon/radeon_vtxfmt.c,v 1.6 2003/05/06 23:52:08 daenzer Exp $ */
2 /**************************************************************************
3
4 Copyright 2000, 2001 ATI Technologies Inc., Ontario, Canada, and
5 Tungsten Graphics Inc., Cedar Park, Texas.
6
7 All Rights Reserved.
8
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:
16
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.
20
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.
28
29 **************************************************************************/
30
31 /*
32 * Authors:
33 * Keith Whitwell <keith@tungstengraphics.com>
34 */
35 #include "glheader.h"
36 #include "imports.h"
37 #include "api_noop.h"
38 #include "api_arrayelt.h"
39 #include "context.h"
40 #include "mtypes.h"
41 #include "enums.h"
42 #include "glapi.h"
43 #include "colormac.h"
44 #include "light.h"
45 #include "state.h"
46 #include "vtxfmt.h"
47
48 #include "tnl/tnl.h"
49 #include "tnl/t_context.h"
50 #include "tnl/t_array_api.h"
51
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"
59
60 #define VERT_ATTRIB_TEX(u) (VERT_ATTRIB_TEX0 + (u))
61
62 #include "dispatch.h"
63
64 static void radeonVtxfmtFlushVertices( GLcontext *, GLuint );
65
66 static void count_func( const char *name, struct dynfn *l )
67 {
68 int i = 0;
69 struct dynfn *f;
70 foreach (f, l) i++;
71 if (i) fprintf(stderr, "%s: %d\n", name, i );
72 }
73
74 static void count_funcs( radeonContextPtr rmesa )
75 {
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 );
102 }
103
104
105 void radeon_copy_to_current( GLcontext *ctx )
106 {
107 GLuint unit;
108 radeonContextPtr rmesa = RADEON_CONTEXT(ctx);
109
110 assert(ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT);
111
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];
116 }
117
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 );
123 }
124
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];
129 }
130
131 if (rmesa->vb.vertex_format & RADEON_CP_VC_FRMT_FPALPHA)
132 ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3] = rmesa->vb.floatcolorptr[3];
133
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 );
138 }
139
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;
146 }
147 }
148
149 ctx->Driver.NeedFlush &= ~FLUSH_UPDATE_CURRENT;
150 }
151
152 static GLboolean discreet_gl_prim[GL_POLYGON+1] = {
153 1, /* 0 points */
154 1, /* 1 lines */
155 0, /* 2 line_strip */
156 0, /* 3 line_loop */
157 1, /* 4 tris */
158 0, /* 5 tri_fan */
159 0, /* 6 tri_strip */
160 1, /* 7 quads */
161 0, /* 8 quadstrip */
162 0, /* 9 poly */
163 };
164
165 static void flush_prims( radeonContextPtr rmesa )
166 {
167 int i,j;
168 struct radeon_dma_region tmp = rmesa->dma.current;
169
170 tmp.buf->refcount++;
171 tmp.aos_size = rmesa->vb.vertex_size;
172 tmp.aos_stride = rmesa->vb.vertex_size;
173 tmp.aos_start = GET_START(&tmp);
174
175 rmesa->dma.current.ptr = rmesa->dma.current.start +=
176 (rmesa->vb.initial_counter - rmesa->vb.counter) * rmesa->vb.vertex_size * 4;
177
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;
182
183 /* Optimize the primitive list:
184 */
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;
189
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;
193 }
194 else {
195 j++;
196 if (j != i) rmesa->vb.primlist[j] = rmesa->vb.primlist[i];
197 }
198 }
199 rmesa->vb.nrprims = j+1;
200 }
201
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 &
206 PRIM_MODE_MASK ),
207 rmesa->vb.primlist[i].start,
208 rmesa->vb.primlist[i].end);
209
210 radeonEmitPrimitive( rmesa->glCtx,
211 rmesa->vb.primlist[i].start,
212 rmesa->vb.primlist[i].end,
213 rmesa->vb.primlist[i].prim );
214 }
215
216 rmesa->vb.nrprims = 0;
217 radeonReleaseDmaRegion( rmesa, &tmp, __FUNCTION__ );
218 }
219
220
221 static void start_prim( radeonContextPtr rmesa, GLuint mode )
222 {
223 if (RADEON_DEBUG & DEBUG_VFMT)
224 fprintf(stderr, "%s %d\n", __FUNCTION__, rmesa->vb.initial_counter - rmesa->vb.counter);
225
226 rmesa->vb.primlist[rmesa->vb.nrprims].start = rmesa->vb.initial_counter - rmesa->vb.counter;
227 rmesa->vb.primlist[rmesa->vb.nrprims].prim = mode;
228 }
229
230 static void note_last_prim( radeonContextPtr rmesa, GLuint flags )
231 {
232 if (RADEON_DEBUG & DEBUG_VFMT)
233 fprintf(stderr, "%s %d\n", __FUNCTION__, rmesa->vb.initial_counter - rmesa->vb.counter);
234
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;
238
239 if (++(rmesa->vb.nrprims) == RADEON_MAX_PRIMS)
240 flush_prims( rmesa );
241 }
242 }
243
244
245 static void copy_vertex( radeonContextPtr rmesa, GLuint n, GLfloat *dst )
246 {
247 GLuint i;
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);
252
253 if (RADEON_DEBUG & DEBUG_VFMT)
254 fprintf(stderr, "copy_vertex %d\n", rmesa->vb.primlist[rmesa->vb.nrprims].start + n);
255
256 for (i = 0 ; i < rmesa->vb.vertex_size; i++) {
257 dst[i] = src[i];
258 }
259 }
260
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.
264 */
265 static GLuint copy_dma_verts( radeonContextPtr rmesa, GLfloat (*tmp)[RADEON_MAX_VERTEX_SIZE] )
266 {
267 GLuint ovf, i;
268 GLuint nr = (rmesa->vb.initial_counter - rmesa->vb.counter) - rmesa->vb.primlist[rmesa->vb.nrprims].start;
269
270 if (RADEON_DEBUG & DEBUG_VFMT)
271 fprintf(stderr, "%s %d verts\n", __FUNCTION__, nr);
272
273 switch( rmesa->vb.prim[0] )
274 {
275 case GL_POINTS:
276 return 0;
277 case GL_LINES:
278 ovf = nr&1;
279 for (i = 0 ; i < ovf ; i++)
280 copy_vertex( rmesa, nr-ovf+i, tmp[i] );
281 return i;
282 case GL_TRIANGLES:
283 ovf = nr%3;
284 for (i = 0 ; i < ovf ; i++)
285 copy_vertex( rmesa, nr-ovf+i, tmp[i] );
286 return i;
287 case GL_QUADS:
288 ovf = nr&3;
289 for (i = 0 ; i < ovf ; i++)
290 copy_vertex( rmesa, nr-ovf+i, tmp[i] );
291 return i;
292 case GL_LINE_STRIP:
293 if (nr == 0)
294 return 0;
295 copy_vertex( rmesa, nr-1, tmp[0] );
296 return 1;
297 case GL_LINE_LOOP:
298 case GL_TRIANGLE_FAN:
299 case GL_POLYGON:
300 if (nr == 0)
301 return 0;
302 else if (nr == 1) {
303 copy_vertex( rmesa, 0, tmp[0] );
304 return 1;
305 } else {
306 copy_vertex( rmesa, 0, tmp[0] );
307 copy_vertex( rmesa, nr-1, tmp[1] );
308 return 2;
309 }
310 case GL_TRIANGLE_STRIP:
311 ovf = MIN2(nr, 2);
312 for (i = 0 ; i < ovf ; i++)
313 copy_vertex( rmesa, nr-ovf+i, tmp[i] );
314 return i;
315 case GL_QUAD_STRIP:
316 switch (nr) {
317 case 0: ovf = 0; break;
318 case 1: ovf = 1; break;
319 default: ovf = 2 + (nr&1); break;
320 }
321 for (i = 0 ; i < ovf ; i++)
322 copy_vertex( rmesa, nr-ovf+i, tmp[i] );
323 return i;
324 default:
325 assert(0);
326 return 0;
327 }
328 }
329
330 static void VFMT_FALLBACK_OUTSIDE_BEGIN_END( const char *caller )
331 {
332 GET_CURRENT_CONTEXT(ctx);
333 radeonContextPtr rmesa = RADEON_CONTEXT(ctx);
334
335 if (RADEON_DEBUG & (DEBUG_VFMT|DEBUG_FALLBACKS))
336 fprintf(stderr, "%s from %s\n", __FUNCTION__, caller);
337
338 if (ctx->Driver.NeedFlush)
339 radeonVtxfmtFlushVertices( ctx, ctx->Driver.NeedFlush );
340
341 if (ctx->NewState)
342 _mesa_update_state( ctx ); /* clear state so fell_back sticks */
343
344 _tnl_wakeup_exec( ctx );
345 ctx->Driver.FlushVertices = radeonFlushVertices;
346
347 assert( rmesa->dma.flush == 0 );
348 rmesa->vb.fell_back = GL_TRUE;
349 rmesa->vb.installed = GL_FALSE;
350 }
351
352
353 static void VFMT_FALLBACK( const char *caller )
354 {
355 GET_CURRENT_CONTEXT(ctx);
356 radeonContextPtr rmesa = RADEON_CONTEXT(ctx);
357 GLfloat tmp[3][RADEON_MAX_VERTEX_SIZE];
358 GLuint i, prim;
359 GLuint ind = rmesa->vb.vertex_format;
360 GLuint nrverts;
361 GLfloat alpha = 1.0;
362 GLuint unit;
363
364 if (RADEON_DEBUG & (DEBUG_FALLBACKS|DEBUG_VFMT))
365 fprintf(stderr, "%s from %s\n", __FUNCTION__, caller);
366
367 if (rmesa->vb.prim[0] == GL_POLYGON+1) {
368 VFMT_FALLBACK_OUTSIDE_BEGIN_END( __FUNCTION__ );
369 return;
370 }
371
372 /* Copy vertices out of dma:
373 */
374 nrverts = copy_dma_verts( rmesa, tmp );
375
376 /* Finish the prim at this point:
377 */
378 note_last_prim( rmesa, 0 );
379 flush_prims( rmesa );
380
381 /* Update ctx->Driver.CurrentExecPrimitive and swap in swtnl.
382 */
383 prim = rmesa->vb.prim[0];
384 ctx->Driver.CurrentExecPrimitive = GL_POLYGON+1;
385 _tnl_wakeup_exec( ctx );
386 ctx->Driver.FlushVertices = radeonFlushVertices;
387
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));
392
393 if (rmesa->vb.installed_color_3f_sz == 4)
394 alpha = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3];
395
396 /* Replay saved vertices
397 */
398 for (i = 0 ; i < nrverts; i++) {
399 GLuint offset = 3;
400 if (ind & RADEON_CP_VC_FRMT_N0) {
401 CALL_Normal3fv(GET_DISPATCH(), (&tmp[i][offset]));
402 offset += 3;
403 }
404
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));
408 offset++;
409 }
410 else if (ind & RADEON_CP_VC_FRMT_FPALPHA) {
411 CALL_Color4fv(GET_DISPATCH(), (&tmp[i][offset]));
412 offset+=4;
413 }
414 else if (ind & RADEON_CP_VC_FRMT_FPCOLOR) {
415 CALL_Color3fv(GET_DISPATCH(), (&tmp[i][offset]));
416 offset+=3;
417 }
418
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));
422 offset++;
423 }
424
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]));
428 offset += 2;
429 }
430 }
431 CALL_Vertex3fv(GET_DISPATCH(), (&tmp[i][0]));
432 }
433
434 /* Replay current vertex
435 */
436 if (ind & RADEON_CP_VC_FRMT_N0)
437 CALL_Normal3fv(GET_DISPATCH(), (rmesa->vb.normalptr));
438
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],
449 alpha));
450 else
451 CALL_Color3fv(GET_DISPATCH(), (rmesa->vb.floatcolorptr));
452 }
453
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));
458
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]));
463 }
464 }
465 }
466
467
468
469 static void wrap_buffer( void )
470 {
471 GET_CURRENT_CONTEXT(ctx);
472 radeonContextPtr rmesa = RADEON_CONTEXT(ctx);
473 GLfloat tmp[3][RADEON_MAX_VERTEX_SIZE];
474 GLuint i, nrverts;
475
476 if (RADEON_DEBUG & (DEBUG_VFMT|DEBUG_PRIMS))
477 fprintf(stderr, "%s %d\n", __FUNCTION__, rmesa->vb.initial_counter - rmesa->vb.counter);
478
479 /* Don't deal with parity.
480 */
481 if ((((rmesa->vb.initial_counter - rmesa->vb.counter) -
482 rmesa->vb.primlist[rmesa->vb.nrprims].start) & 1)) {
483 rmesa->vb.counter++;
484 rmesa->vb.initial_counter++;
485 return;
486 }
487
488 /* Copy vertices out of dma:
489 */
490 if (rmesa->vb.prim[0] == GL_POLYGON+1)
491 nrverts = 0;
492 else {
493 nrverts = copy_dma_verts( rmesa, tmp );
494
495 if (RADEON_DEBUG & DEBUG_VFMT)
496 fprintf(stderr, "%d vertices to copy\n", nrverts);
497
498 /* Finish the prim at this point:
499 */
500 note_last_prim( rmesa, 0 );
501 }
502
503 /* Fire any buffered primitives
504 */
505 flush_prims( rmesa );
506
507 /* Get new buffer
508 */
509 radeonRefillCurrentDmaRegion( rmesa );
510
511 /* Reset counter, dmaptr
512 */
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);
516 rmesa->vb.counter--;
517 rmesa->vb.initial_counter = rmesa->vb.counter;
518 rmesa->vb.notify = wrap_buffer;
519
520 rmesa->dma.flush = flush_prims;
521
522 /* Restart wrapped primitive:
523 */
524 if (rmesa->vb.prim[0] != GL_POLYGON+1)
525 start_prim( rmesa, rmesa->vb.prim[0] );
526
527 /* Reemit saved vertices
528 */
529 for (i = 0 ; i < nrverts; i++) {
530 if (RADEON_DEBUG & DEBUG_VERTS) {
531 int j;
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]);
536 }
537
538 memcpy( rmesa->vb.dmaptr, tmp[i], rmesa->vb.vertex_size * 4 );
539 rmesa->vb.dmaptr += rmesa->vb.vertex_size;
540 rmesa->vb.counter--;
541 }
542 }
543
544
545
546 static GLboolean check_vtx_fmt( GLcontext *ctx )
547 {
548 radeonContextPtr rmesa = RADEON_CONTEXT(ctx);
549 GLuint ind = RADEON_CP_VC_FRMT_Z;
550 GLuint unit;
551
552 if (rmesa->TclFallback || rmesa->vb.fell_back || ctx->CompileFlag)
553 return GL_FALSE;
554
555 if (ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT)
556 ctx->Driver.FlushVertices( ctx, FLUSH_UPDATE_CURRENT );
557
558 /* Make all this event-driven:
559 */
560 if (ctx->Light.Enabled) {
561 ind |= RADEON_CP_VC_FRMT_N0;
562
563 /* TODO: make this data driven: If we receive only ubytes, send
564 * color as ubytes. Also check if converting (with free
565 * checking for overflow) is cheaper than sending floats
566 * directly.
567 */
568 if (ctx->Light.ColorMaterialEnabled) {
569 ind |= (RADEON_CP_VC_FRMT_FPCOLOR |
570 RADEON_CP_VC_FRMT_FPALPHA);
571 }
572 else
573 ind |= RADEON_CP_VC_FRMT_PKCOLOR; /* for alpha? */
574 }
575 else {
576 /* TODO: make this data driven?
577 */
578 ind |= RADEON_CP_VC_FRMT_PKCOLOR;
579
580 if (ctx->_TriangleCaps & DD_SEPARATE_SPECULAR) {
581 ind |= RADEON_CP_VC_FRMT_PKSPEC;
582 }
583 }
584
585 for (unit = 0 ; unit < ctx->Const.MaxTextureUnits; unit++) {
586 if (ctx->Texture.Unit[unit]._ReallyEnabled) {
587 if (ctx->Texture.Unit[unit].TexGenEnabled) {
588 if (rmesa->TexGenNeedNormals[unit]) {
589 ind |= RADEON_CP_VC_FRMT_N0;
590 }
591 } else {
592 if (ctx->Current.Attrib[VERT_ATTRIB_TEX(unit)][3] != 1.0) {
593 if (RADEON_DEBUG & (DEBUG_VFMT|DEBUG_FALLBACKS))
594 fprintf(stderr, "%s: q%u\n", __FUNCTION__, unit);
595 return GL_FALSE;
596 }
597 ind |= RADEON_ST_BIT(unit);
598 }
599 }
600 }
601
602 if (RADEON_DEBUG & (DEBUG_VFMT|DEBUG_STATE))
603 fprintf(stderr, "%s: format: 0x%x\n", __FUNCTION__, ind );
604
605 RADEON_NEWPRIM(rmesa);
606 rmesa->vb.vertex_format = ind;
607 rmesa->vb.vertex_size = 3;
608 rmesa->vb.prim = &ctx->Driver.CurrentExecPrimitive;
609
610 rmesa->vb.normalptr = ctx->Current.Attrib[VERT_ATTRIB_NORMAL];
611 rmesa->vb.colorptr = NULL;
612 rmesa->vb.floatcolorptr = ctx->Current.Attrib[VERT_ATTRIB_COLOR0];
613 rmesa->vb.specptr = NULL;
614 rmesa->vb.floatspecptr = ctx->Current.Attrib[VERT_ATTRIB_COLOR1];
615 rmesa->vb.texcoordptr[0] = ctx->Current.Attrib[VERT_ATTRIB_TEX0];
616 rmesa->vb.texcoordptr[1] = ctx->Current.Attrib[VERT_ATTRIB_TEX1];
617 rmesa->vb.texcoordptr[2] = ctx->Current.Attrib[VERT_ATTRIB_TEX2];
618 rmesa->vb.texcoordptr[3] = ctx->Current.Attrib[VERT_ATTRIB_TEX0]; /* dummy */
619
620 /* Run through and initialize the vertex components in the order
621 * the hardware understands:
622 */
623 if (ind & RADEON_CP_VC_FRMT_N0) {
624 rmesa->vb.normalptr = &rmesa->vb.vertex[rmesa->vb.vertex_size].f;
625 rmesa->vb.vertex_size += 3;
626 rmesa->vb.normalptr[0] = ctx->Current.Attrib[VERT_ATTRIB_NORMAL][0];
627 rmesa->vb.normalptr[1] = ctx->Current.Attrib[VERT_ATTRIB_NORMAL][1];
628 rmesa->vb.normalptr[2] = ctx->Current.Attrib[VERT_ATTRIB_NORMAL][2];
629 }
630
631 if (ind & RADEON_CP_VC_FRMT_PKCOLOR) {
632 rmesa->vb.colorptr = &rmesa->vb.vertex[rmesa->vb.vertex_size].color;
633 rmesa->vb.vertex_size += 1;
634 UNCLAMPED_FLOAT_TO_CHAN( rmesa->vb.colorptr->red, ctx->Current.Attrib[VERT_ATTRIB_COLOR0][0] );
635 UNCLAMPED_FLOAT_TO_CHAN( rmesa->vb.colorptr->green, ctx->Current.Attrib[VERT_ATTRIB_COLOR0][1] );
636 UNCLAMPED_FLOAT_TO_CHAN( rmesa->vb.colorptr->blue, ctx->Current.Attrib[VERT_ATTRIB_COLOR0][2] );
637 UNCLAMPED_FLOAT_TO_CHAN( rmesa->vb.colorptr->alpha, ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3] );
638 }
639
640 if (ind & RADEON_CP_VC_FRMT_FPCOLOR) {
641 assert(!(ind & RADEON_CP_VC_FRMT_PKCOLOR));
642 rmesa->vb.floatcolorptr = &rmesa->vb.vertex[rmesa->vb.vertex_size].f;
643 rmesa->vb.vertex_size += 3;
644 rmesa->vb.floatcolorptr[0] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][0];
645 rmesa->vb.floatcolorptr[1] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][1];
646 rmesa->vb.floatcolorptr[2] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][2];
647
648 if (ind & RADEON_CP_VC_FRMT_FPALPHA) {
649 rmesa->vb.vertex_size += 1;
650 rmesa->vb.floatcolorptr[3] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3];
651 }
652 }
653
654 if (ind & RADEON_CP_VC_FRMT_PKSPEC) {
655 rmesa->vb.specptr = &rmesa->vb.vertex[rmesa->vb.vertex_size].color;
656 rmesa->vb.vertex_size += 1;
657 UNCLAMPED_FLOAT_TO_CHAN( rmesa->vb.specptr->red, ctx->Current.Attrib[VERT_ATTRIB_COLOR1][0] );
658 UNCLAMPED_FLOAT_TO_CHAN( rmesa->vb.specptr->green, ctx->Current.Attrib[VERT_ATTRIB_COLOR1][1] );
659 UNCLAMPED_FLOAT_TO_CHAN( rmesa->vb.specptr->blue, ctx->Current.Attrib[VERT_ATTRIB_COLOR1][2] );
660 }
661
662 for (unit = 0 ; unit < ctx->Const.MaxTextureUnits; unit++) {
663 if (ind & RADEON_ST_BIT(unit)) {
664 rmesa->vb.texcoordptr[unit] = &rmesa->vb.vertex[rmesa->vb.vertex_size].f;
665 rmesa->vb.vertex_size += 2;
666 rmesa->vb.texcoordptr[unit][0] = ctx->Current.Attrib[VERT_ATTRIB_TEX(unit)][0];
667 rmesa->vb.texcoordptr[unit][1] = ctx->Current.Attrib[VERT_ATTRIB_TEX(unit)][1];
668 }
669 }
670
671 if (rmesa->vb.installed_vertex_format != rmesa->vb.vertex_format) {
672 if (RADEON_DEBUG & DEBUG_VFMT)
673 fprintf(stderr, "reinstall on vertex_format change\n");
674 _mesa_install_exec_vtxfmt( ctx, &rmesa->vb.vtxfmt );
675 rmesa->vb.installed_vertex_format = rmesa->vb.vertex_format;
676 }
677
678 if (RADEON_DEBUG & DEBUG_VFMT)
679 fprintf(stderr, "%s -- success\n", __FUNCTION__);
680
681 return GL_TRUE;
682 }
683
684 void radeonVtxfmtInvalidate( GLcontext *ctx )
685 {
686 radeonContextPtr rmesa = RADEON_CONTEXT( ctx );
687
688 rmesa->vb.recheck = GL_TRUE;
689 rmesa->vb.fell_back = GL_FALSE;
690 }
691
692
693 static void radeonVtxfmtValidate( GLcontext *ctx )
694 {
695 radeonContextPtr rmesa = RADEON_CONTEXT( ctx );
696
697 if (RADEON_DEBUG & DEBUG_VFMT)
698 fprintf(stderr, "%s\n", __FUNCTION__);
699
700 if (ctx->Driver.NeedFlush)
701 ctx->Driver.FlushVertices( ctx, ctx->Driver.NeedFlush );
702
703 rmesa->vb.recheck = GL_FALSE;
704
705 if (check_vtx_fmt( ctx )) {
706 if (!rmesa->vb.installed) {
707 if (RADEON_DEBUG & DEBUG_VFMT)
708 fprintf(stderr, "reinstall (new install)\n");
709
710 _mesa_install_exec_vtxfmt( ctx, &rmesa->vb.vtxfmt );
711 ctx->Driver.FlushVertices = radeonVtxfmtFlushVertices;
712 rmesa->vb.installed = GL_TRUE;
713 }
714 else if (RADEON_DEBUG & DEBUG_VFMT)
715 fprintf(stderr, "%s: already installed", __FUNCTION__);
716 }
717 else {
718 if (RADEON_DEBUG & DEBUG_VFMT)
719 fprintf(stderr, "%s: failed\n", __FUNCTION__);
720
721 if (rmesa->vb.installed) {
722 if (rmesa->dma.flush)
723 rmesa->dma.flush( rmesa );
724 _tnl_wakeup_exec( ctx );
725 ctx->Driver.FlushVertices = radeonFlushVertices;
726 rmesa->vb.installed = GL_FALSE;
727 }
728 }
729 }
730
731
732
733 /* Materials:
734 */
735 static void radeon_Materialfv( GLenum face, GLenum pname,
736 const GLfloat *params )
737 {
738 GET_CURRENT_CONTEXT(ctx);
739 radeonContextPtr rmesa = RADEON_CONTEXT( ctx );
740
741 if (RADEON_DEBUG & DEBUG_VFMT)
742 fprintf(stderr, "%s\n", __FUNCTION__);
743
744 if (rmesa->vb.prim[0] != GL_POLYGON+1) {
745 VFMT_FALLBACK( __FUNCTION__ );
746 CALL_Materialfv(GET_DISPATCH(), (face, pname, params));
747 return;
748 }
749 _mesa_noop_Materialfv( face, pname, params );
750 radeonUpdateMaterial( ctx );
751 }
752
753
754 /* Begin/End
755 */
756 static void radeon_Begin( GLenum mode )
757 {
758 GET_CURRENT_CONTEXT(ctx);
759 radeonContextPtr rmesa = RADEON_CONTEXT(ctx);
760
761 if (RADEON_DEBUG & DEBUG_VFMT)
762 fprintf(stderr, "%s( %s )\n", __FUNCTION__,
763 _mesa_lookup_enum_by_nr( mode ));
764
765 if (mode > GL_POLYGON) {
766 _mesa_error( ctx, GL_INVALID_ENUM, "glBegin" );
767 return;
768 }
769
770 if (rmesa->vb.prim[0] != GL_POLYGON+1) {
771 _mesa_error( ctx, GL_INVALID_OPERATION, "glBegin" );
772 return;
773 }
774
775 if (ctx->NewState)
776 _mesa_update_state( ctx );
777
778 if (rmesa->NewGLState)
779 radeonValidateState( ctx );
780
781 if (rmesa->vb.recheck)
782 radeonVtxfmtValidate( ctx );
783
784 if (!rmesa->vb.installed) {
785 CALL_Begin(GET_DISPATCH(), (mode));
786 return;
787 }
788
789
790 if (rmesa->dma.flush && rmesa->vb.counter < 12) {
791 if (RADEON_DEBUG & DEBUG_VFMT)
792 fprintf(stderr, "%s: flush almost-empty buffers\n", __FUNCTION__);
793 flush_prims( rmesa );
794 }
795
796 /* Need to arrange to save vertices here? Or always copy from dma (yuk)?
797 */
798 if (!rmesa->dma.flush) {
799 /* FIXME: what are these constants? */
800 if (rmesa->dma.current.ptr + 12*rmesa->vb.vertex_size*4 >
801 rmesa->dma.current.end) {
802 RADEON_NEWPRIM( rmesa );
803 radeonRefillCurrentDmaRegion( rmesa );
804 }
805
806 rmesa->vb.dmaptr = (int *)(rmesa->dma.current.address + rmesa->dma.current.ptr);
807 rmesa->vb.counter = (rmesa->dma.current.end - rmesa->dma.current.ptr) /
808 (rmesa->vb.vertex_size * 4);
809 rmesa->vb.counter--;
810 rmesa->vb.initial_counter = rmesa->vb.counter;
811 rmesa->vb.notify = wrap_buffer;
812 rmesa->dma.flush = flush_prims;
813 ctx->Driver.NeedFlush |= FLUSH_STORED_VERTICES;
814 }
815
816
817 rmesa->vb.prim[0] = mode;
818 start_prim( rmesa, mode | PRIM_BEGIN );
819 }
820
821
822
823 static void radeon_End( void )
824 {
825 GET_CURRENT_CONTEXT(ctx);
826 radeonContextPtr rmesa = RADEON_CONTEXT(ctx);
827
828 if (RADEON_DEBUG & DEBUG_VFMT)
829 fprintf(stderr, "%s\n", __FUNCTION__);
830
831 if (rmesa->vb.prim[0] == GL_POLYGON+1) {
832 _mesa_error( ctx, GL_INVALID_OPERATION, "glEnd" );
833 return;
834 }
835
836 note_last_prim( rmesa, PRIM_END );
837 rmesa->vb.prim[0] = GL_POLYGON+1;
838 }
839
840
841 /* Fallback on difficult entrypoints:
842 */
843 #define PRE_LOOPBACK( FUNC ) \
844 do { \
845 if (RADEON_DEBUG & DEBUG_VFMT) \
846 fprintf(stderr, "%s\n", __FUNCTION__); \
847 VFMT_FALLBACK( __FUNCTION__ ); \
848 } while (0)
849 #define TAG(x) radeon_fallback_##x
850 #include "vtxfmt_tmp.h"
851
852
853
854 static GLboolean radeonNotifyBegin( GLcontext *ctx, GLenum p )
855 {
856 radeonContextPtr rmesa = RADEON_CONTEXT( ctx );
857
858 if (RADEON_DEBUG & DEBUG_VFMT)
859 fprintf(stderr, "%s\n", __FUNCTION__);
860
861 assert(!rmesa->vb.installed);
862
863 if (ctx->NewState)
864 _mesa_update_state( ctx );
865
866 if (rmesa->NewGLState)
867 radeonValidateState( ctx );
868
869 if (ctx->Driver.NeedFlush)
870 ctx->Driver.FlushVertices( ctx, ctx->Driver.NeedFlush );
871
872 if (rmesa->vb.recheck)
873 radeonVtxfmtValidate( ctx );
874
875 if (!rmesa->vb.installed) {
876 if (RADEON_DEBUG & DEBUG_VFMT)
877 fprintf(stderr, "%s -- failed\n", __FUNCTION__);
878 return GL_FALSE;
879 }
880
881 radeon_Begin( p );
882 return GL_TRUE;
883 }
884
885 static void radeonVtxfmtFlushVertices( GLcontext *ctx, GLuint flags )
886 {
887 radeonContextPtr rmesa = RADEON_CONTEXT( ctx );
888
889 if (RADEON_DEBUG & DEBUG_VFMT)
890 fprintf(stderr, "%s\n", __FUNCTION__);
891
892 assert(rmesa->vb.installed);
893
894 if (flags & FLUSH_UPDATE_CURRENT) {
895 radeon_copy_to_current( ctx );
896 if (RADEON_DEBUG & DEBUG_VFMT)
897 fprintf(stderr, "reinstall on update_current\n");
898 _mesa_install_exec_vtxfmt( ctx, &rmesa->vb.vtxfmt );
899 ctx->Driver.NeedFlush &= ~FLUSH_UPDATE_CURRENT;
900 }
901
902 if (flags & FLUSH_STORED_VERTICES) {
903 radeonContextPtr rmesa = RADEON_CONTEXT( ctx );
904 assert (rmesa->dma.flush == 0 ||
905 rmesa->dma.flush == flush_prims);
906 if (rmesa->dma.flush == flush_prims)
907 flush_prims( RADEON_CONTEXT( ctx ) );
908 ctx->Driver.NeedFlush &= ~FLUSH_STORED_VERTICES;
909 }
910 }
911
912
913
914 /* At this point, don't expect very many versions of each function to
915 * be generated, so not concerned about freeing them?
916 */
917
918
919 void radeonVtxfmtInit( GLcontext *ctx, GLboolean useCodegen )
920 {
921 radeonContextPtr rmesa = RADEON_CONTEXT( ctx );
922 GLvertexformat *vfmt = &(rmesa->vb.vtxfmt);
923
924 MEMSET( vfmt, 0, sizeof(GLvertexformat) );
925
926 /* Hook in chooser functions for codegen, etc:
927 */
928 radeonVtxfmtInitChoosers( vfmt );
929
930 /* Handled fully in supported states, but no codegen:
931 */
932 vfmt->Materialfv = radeon_Materialfv;
933 vfmt->ArrayElement = _ae_loopback_array_elt; /* generic helper */
934 vfmt->Rectf = _mesa_noop_Rectf; /* generic helper */
935 vfmt->Begin = radeon_Begin;
936 vfmt->End = radeon_End;
937
938 /* Fallback for performance reasons: (Fix with cva/elt path here and
939 * dmatmp2.h style primitive-merging)
940 *
941 * These should call NotifyBegin(), as should _tnl_EvalMesh, to allow
942 * a driver-hook.
943 */
944 vfmt->DrawArrays = radeon_fallback_DrawArrays;
945 vfmt->DrawElements = radeon_fallback_DrawElements;
946 vfmt->DrawRangeElements = radeon_fallback_DrawRangeElements;
947
948
949 /* Not active in supported states; just keep ctx->Current uptodate:
950 */
951 vfmt->FogCoordfvEXT = _mesa_noop_FogCoordfvEXT;
952 vfmt->FogCoordfEXT = _mesa_noop_FogCoordfEXT;
953 vfmt->EdgeFlag = _mesa_noop_EdgeFlag;
954 vfmt->EdgeFlagv = _mesa_noop_EdgeFlagv;
955 vfmt->Indexf = _mesa_noop_Indexf;
956 vfmt->Indexfv = _mesa_noop_Indexfv;
957
958
959 /* Active but unsupported -- fallback if we receive these:
960 */
961 vfmt->CallList = radeon_fallback_CallList;
962 vfmt->CallLists = radeon_fallback_CallLists;
963 vfmt->EvalCoord1f = radeon_fallback_EvalCoord1f;
964 vfmt->EvalCoord1fv = radeon_fallback_EvalCoord1fv;
965 vfmt->EvalCoord2f = radeon_fallback_EvalCoord2f;
966 vfmt->EvalCoord2fv = radeon_fallback_EvalCoord2fv;
967 vfmt->EvalMesh1 = radeon_fallback_EvalMesh1;
968 vfmt->EvalMesh2 = radeon_fallback_EvalMesh2;
969 vfmt->EvalPoint1 = radeon_fallback_EvalPoint1;
970 vfmt->EvalPoint2 = radeon_fallback_EvalPoint2;
971 vfmt->TexCoord3f = radeon_fallback_TexCoord3f;
972 vfmt->TexCoord3fv = radeon_fallback_TexCoord3fv;
973 vfmt->TexCoord4f = radeon_fallback_TexCoord4f;
974 vfmt->TexCoord4fv = radeon_fallback_TexCoord4fv;
975 vfmt->MultiTexCoord3fARB = radeon_fallback_MultiTexCoord3fARB;
976 vfmt->MultiTexCoord3fvARB = radeon_fallback_MultiTexCoord3fvARB;
977 vfmt->MultiTexCoord4fARB = radeon_fallback_MultiTexCoord4fARB;
978 vfmt->MultiTexCoord4fvARB = radeon_fallback_MultiTexCoord4fvARB;
979 vfmt->Vertex4f = radeon_fallback_Vertex4f;
980 vfmt->Vertex4fv = radeon_fallback_Vertex4fv;
981 vfmt->VertexAttrib1fNV = radeon_fallback_VertexAttrib1fNV;
982 vfmt->VertexAttrib1fvNV = radeon_fallback_VertexAttrib1fvNV;
983 vfmt->VertexAttrib2fNV = radeon_fallback_VertexAttrib2fNV;
984 vfmt->VertexAttrib2fvNV = radeon_fallback_VertexAttrib2fvNV;
985 vfmt->VertexAttrib3fNV = radeon_fallback_VertexAttrib3fNV;
986 vfmt->VertexAttrib3fvNV = radeon_fallback_VertexAttrib3fvNV;
987 vfmt->VertexAttrib4fNV = radeon_fallback_VertexAttrib4fNV;
988 vfmt->VertexAttrib4fvNV = radeon_fallback_VertexAttrib4fvNV;
989
990 (void)radeon_fallback_vtxfmt;
991
992 TNL_CONTEXT(ctx)->Driver.NotifyBegin = radeonNotifyBegin;
993
994 rmesa->vb.enabled = 1;
995 rmesa->vb.prim = &ctx->Driver.CurrentExecPrimitive;
996 rmesa->vb.primflags = 0;
997
998 make_empty_list( &rmesa->vb.dfn_cache.Vertex2f );
999 make_empty_list( &rmesa->vb.dfn_cache.Vertex2fv );
1000 make_empty_list( &rmesa->vb.dfn_cache.Vertex3f );
1001 make_empty_list( &rmesa->vb.dfn_cache.Vertex3fv );
1002 make_empty_list( &rmesa->vb.dfn_cache.Color4ub );
1003 make_empty_list( &rmesa->vb.dfn_cache.Color4ubv );
1004 make_empty_list( &rmesa->vb.dfn_cache.Color3ub );
1005 make_empty_list( &rmesa->vb.dfn_cache.Color3ubv );
1006 make_empty_list( &rmesa->vb.dfn_cache.Color4f );
1007 make_empty_list( &rmesa->vb.dfn_cache.Color4fv );
1008 make_empty_list( &rmesa->vb.dfn_cache.Color3f );
1009 make_empty_list( &rmesa->vb.dfn_cache.Color3fv );
1010 make_empty_list( &rmesa->vb.dfn_cache.SecondaryColor3fEXT );
1011 make_empty_list( &rmesa->vb.dfn_cache.SecondaryColor3fvEXT );
1012 make_empty_list( &rmesa->vb.dfn_cache.SecondaryColor3ubEXT );
1013 make_empty_list( &rmesa->vb.dfn_cache.SecondaryColor3ubvEXT );
1014 make_empty_list( &rmesa->vb.dfn_cache.Normal3f );
1015 make_empty_list( &rmesa->vb.dfn_cache.Normal3fv );
1016 make_empty_list( &rmesa->vb.dfn_cache.TexCoord2f );
1017 make_empty_list( &rmesa->vb.dfn_cache.TexCoord2fv );
1018 make_empty_list( &rmesa->vb.dfn_cache.TexCoord1f );
1019 make_empty_list( &rmesa->vb.dfn_cache.TexCoord1fv );
1020 make_empty_list( &rmesa->vb.dfn_cache.MultiTexCoord2fARB );
1021 make_empty_list( &rmesa->vb.dfn_cache.MultiTexCoord2fvARB );
1022 make_empty_list( &rmesa->vb.dfn_cache.MultiTexCoord1fARB );
1023 make_empty_list( &rmesa->vb.dfn_cache.MultiTexCoord1fvARB );
1024
1025 radeonInitCodegen( &rmesa->vb.codegen, useCodegen );
1026 }
1027
1028 static void free_funcs( struct dynfn *l )
1029 {
1030 struct dynfn *f, *tmp;
1031 foreach_s (f, tmp, l) {
1032 remove_from_list( f );
1033 ALIGN_FREE( f->code );
1034 FREE( f );
1035 }
1036 }
1037
1038
1039
1040 void radeonVtxfmtMakeCurrent( GLcontext *ctx )
1041 {
1042 }
1043
1044
1045 void radeonVtxfmtDestroy( GLcontext *ctx )
1046 {
1047 radeonContextPtr rmesa = RADEON_CONTEXT( ctx );
1048
1049 count_funcs( rmesa );
1050 free_funcs( &rmesa->vb.dfn_cache.Vertex2f );
1051 free_funcs( &rmesa->vb.dfn_cache.Vertex2fv );
1052 free_funcs( &rmesa->vb.dfn_cache.Vertex3f );
1053 free_funcs( &rmesa->vb.dfn_cache.Vertex3fv );
1054 free_funcs( &rmesa->vb.dfn_cache.Color4ub );
1055 free_funcs( &rmesa->vb.dfn_cache.Color4ubv );
1056 free_funcs( &rmesa->vb.dfn_cache.Color3ub );
1057 free_funcs( &rmesa->vb.dfn_cache.Color3ubv );
1058 free_funcs( &rmesa->vb.dfn_cache.Color4f );
1059 free_funcs( &rmesa->vb.dfn_cache.Color4fv );
1060 free_funcs( &rmesa->vb.dfn_cache.Color3f );
1061 free_funcs( &rmesa->vb.dfn_cache.Color3fv );
1062 free_funcs( &rmesa->vb.dfn_cache.SecondaryColor3ubEXT );
1063 free_funcs( &rmesa->vb.dfn_cache.SecondaryColor3ubvEXT );
1064 free_funcs( &rmesa->vb.dfn_cache.SecondaryColor3fEXT );
1065 free_funcs( &rmesa->vb.dfn_cache.SecondaryColor3fvEXT );
1066 free_funcs( &rmesa->vb.dfn_cache.Normal3f );
1067 free_funcs( &rmesa->vb.dfn_cache.Normal3fv );
1068 free_funcs( &rmesa->vb.dfn_cache.TexCoord2f );
1069 free_funcs( &rmesa->vb.dfn_cache.TexCoord2fv );
1070 free_funcs( &rmesa->vb.dfn_cache.TexCoord1f );
1071 free_funcs( &rmesa->vb.dfn_cache.TexCoord1fv );
1072 free_funcs( &rmesa->vb.dfn_cache.MultiTexCoord2fARB );
1073 free_funcs( &rmesa->vb.dfn_cache.MultiTexCoord2fvARB );
1074 free_funcs( &rmesa->vb.dfn_cache.MultiTexCoord1fARB );
1075 free_funcs( &rmesa->vb.dfn_cache.MultiTexCoord1fvARB );
1076 }
1077