projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
free rs300 and ban r350(according to r300.sf.net)
[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 (ctx->Fog.Enabled && (ctx->Fog.FogCoordinateSource == GL_FOG_COORD)))
554 return GL_FALSE;
555
556 if (ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT)
557 ctx->Driver.FlushVertices( ctx, FLUSH_UPDATE_CURRENT );
558
559 /* Make all this event-driven:
560 */
561 if (ctx->Light.Enabled) {
562 ind |= RADEON_CP_VC_FRMT_N0;
563
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
567 * directly.
568 */
569 if (ctx->Light.ColorMaterialEnabled) {
570 ind |= (RADEON_CP_VC_FRMT_FPCOLOR |
571 RADEON_CP_VC_FRMT_FPALPHA);
572 }
573 else
574 ind |= RADEON_CP_VC_FRMT_PKCOLOR; /* for alpha? */
575 }
576 else {
577 /* TODO: make this data driven?
578 */
579 ind |= RADEON_CP_VC_FRMT_PKCOLOR;
580
581 if (ctx->_TriangleCaps & DD_SEPARATE_SPECULAR) {
582 ind |= RADEON_CP_VC_FRMT_PKSPEC;
583 }
584 }
585
586 if ( ctx->Fog.FogCoordinateSource == GL_FOG_COORD ) {
587 ind |= RADEON_CP_VC_FRMT_PKSPEC;
588 }
589
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;
595 }
596 } else {
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);
600 return GL_FALSE;
601 }
602 ind |= RADEON_ST_BIT(unit);
603 }
604 }
605 }
606
607 if (RADEON_DEBUG & (DEBUG_VFMT|DEBUG_STATE))
608 fprintf(stderr, "%s: format: 0x%x\n", __FUNCTION__, ind );
609
610 RADEON_NEWPRIM(rmesa);
611 rmesa->vb.vertex_format = ind;
612 rmesa->vb.vertex_size = 3;
613 rmesa->vb.prim = &ctx->Driver.CurrentExecPrimitive;
614
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 */
624
625 /* Run through and initialize the vertex components in the order
626 * the hardware understands:
627 */
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];
634 }
635
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] );
643 }
644
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];
652
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];
656 }
657 }
658
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] );
665 /* fog ??? */
666 /* UNCLAMPED_FLOAT_TO_CHAN( rmesa->vb.specptr->alpha,
667 radeonComputeFogFactor(ctx->Current.Attrib[VERT_ATTRIB_FOG][0]) ); */
668 }
669
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];
676 }
677 }
678
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;
684 }
685
686 if (RADEON_DEBUG & DEBUG_VFMT)
687 fprintf(stderr, "%s -- success\n", __FUNCTION__);
688
689 return GL_TRUE;
690 }
691
692 void radeonVtxfmtInvalidate( GLcontext *ctx )
693 {
694 radeonContextPtr rmesa = RADEON_CONTEXT( ctx );
695
696 rmesa->vb.recheck = GL_TRUE;
697 rmesa->vb.fell_back = GL_FALSE;
698 }
699
700
701 static void radeonVtxfmtValidate( GLcontext *ctx )
702 {
703 radeonContextPtr rmesa = RADEON_CONTEXT( ctx );
704
705 if (RADEON_DEBUG & DEBUG_VFMT)
706 fprintf(stderr, "%s\n", __FUNCTION__);
707
708 if (ctx->Driver.NeedFlush)
709 ctx->Driver.FlushVertices( ctx, ctx->Driver.NeedFlush );
710
711 rmesa->vb.recheck = GL_FALSE;
712
713 if (check_vtx_fmt( ctx )) {
714 if (!rmesa->vb.installed) {
715 if (RADEON_DEBUG & DEBUG_VFMT)
716 fprintf(stderr, "reinstall (new install)\n");
717
718 _mesa_install_exec_vtxfmt( ctx, &rmesa->vb.vtxfmt );
719 ctx->Driver.FlushVertices = radeonVtxfmtFlushVertices;
720 rmesa->vb.installed = GL_TRUE;
721 }
722 else if (RADEON_DEBUG & DEBUG_VFMT)
723 fprintf(stderr, "%s: already installed", __FUNCTION__);
724 }
725 else {
726 if (RADEON_DEBUG & DEBUG_VFMT)
727 fprintf(stderr, "%s: failed\n", __FUNCTION__);
728
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;
735 }
736 }
737 }
738
739
740
741 /* Materials:
742 */
743 static void radeon_Materialfv( GLenum face, GLenum pname,
744 const GLfloat *params )
745 {
746 GET_CURRENT_CONTEXT(ctx);
747 radeonContextPtr rmesa = RADEON_CONTEXT( ctx );
748
749 if (RADEON_DEBUG & DEBUG_VFMT)
750 fprintf(stderr, "%s\n", __FUNCTION__);
751
752 if (rmesa->vb.prim[0] != GL_POLYGON+1) {
753 VFMT_FALLBACK( __FUNCTION__ );
754 CALL_Materialfv(GET_DISPATCH(), (face, pname, params));
755 return;
756 }
757 _mesa_noop_Materialfv( face, pname, params );
758 radeonUpdateMaterial( ctx );
759 }
760
761
762 /* Begin/End
763 */
764 static void radeon_Begin( GLenum mode )
765 {
766 GET_CURRENT_CONTEXT(ctx);
767 radeonContextPtr rmesa = RADEON_CONTEXT(ctx);
768
769 if (RADEON_DEBUG & DEBUG_VFMT)
770 fprintf(stderr, "%s( %s )\n", __FUNCTION__,
771 _mesa_lookup_enum_by_nr( mode ));
772
773 if (mode > GL_POLYGON) {
774 _mesa_error( ctx, GL_INVALID_ENUM, "glBegin" );
775 return;
776 }
777
778 if (rmesa->vb.prim[0] != GL_POLYGON+1) {
779 _mesa_error( ctx, GL_INVALID_OPERATION, "glBegin" );
780 return;
781 }
782
783 if (ctx->NewState)
784 _mesa_update_state( ctx );
785
786 if (rmesa->NewGLState)
787 radeonValidateState( ctx );
788
789 if (rmesa->vb.recheck)
790 radeonVtxfmtValidate( ctx );
791
792 if (!rmesa->vb.installed) {
793 CALL_Begin(GET_DISPATCH(), (mode));
794 return;
795 }
796
797
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 );
802 }
803
804 /* Need to arrange to save vertices here? Or always copy from dma (yuk)?
805 */
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 );
812 }
813
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);
817 rmesa->vb.counter--;
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;
822 }
823
824
825 rmesa->vb.prim[0] = mode;
826 start_prim( rmesa, mode | PRIM_BEGIN );
827 }
828
829
830
831 static void radeon_End( void )
832 {
833 GET_CURRENT_CONTEXT(ctx);
834 radeonContextPtr rmesa = RADEON_CONTEXT(ctx);
835
836 if (RADEON_DEBUG & DEBUG_VFMT)
837 fprintf(stderr, "%s\n", __FUNCTION__);
838
839 if (rmesa->vb.prim[0] == GL_POLYGON+1) {
840 _mesa_error( ctx, GL_INVALID_OPERATION, "glEnd" );
841 return;
842 }
843
844 note_last_prim( rmesa, PRIM_END );
845 rmesa->vb.prim[0] = GL_POLYGON+1;
846 }
847
848
849 /* Fallback on difficult entrypoints:
850 */
851 #define PRE_LOOPBACK( FUNC ) \
852 do { \
853 if (RADEON_DEBUG & DEBUG_VFMT) \
854 fprintf(stderr, "%s\n", __FUNCTION__); \
855 VFMT_FALLBACK( __FUNCTION__ ); \
856 } while (0)
857 #define TAG(x) radeon_fallback_##x
858 #include "vtxfmt_tmp.h"
859
860
861
862 static GLboolean radeonNotifyBegin( GLcontext *ctx, GLenum p )
863 {
864 radeonContextPtr rmesa = RADEON_CONTEXT( ctx );
865
866 if (RADEON_DEBUG & DEBUG_VFMT)
867 fprintf(stderr, "%s\n", __FUNCTION__);
868
869 assert(!rmesa->vb.installed);
870
871 if (ctx->NewState)
872 _mesa_update_state( ctx );
873
874 if (rmesa->NewGLState)
875 radeonValidateState( ctx );
876
877 if (ctx->Driver.NeedFlush)
878 ctx->Driver.FlushVertices( ctx, ctx->Driver.NeedFlush );
879
880 if (rmesa->vb.recheck)
881 radeonVtxfmtValidate( ctx );
882
883 if (!rmesa->vb.installed) {
884 if (RADEON_DEBUG & DEBUG_VFMT)
885 fprintf(stderr, "%s -- failed\n", __FUNCTION__);
886 return GL_FALSE;
887 }
888
889 radeon_Begin( p );
890 return GL_TRUE;
891 }
892
893 static void radeonVtxfmtFlushVertices( GLcontext *ctx, GLuint flags )
894 {
895 radeonContextPtr rmesa = RADEON_CONTEXT( ctx );
896
897 if (RADEON_DEBUG & DEBUG_VFMT)
898 fprintf(stderr, "%s\n", __FUNCTION__);
899
900 assert(rmesa->vb.installed);
901
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;
908 }
909
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;
917 }
918 }
919
920
921
922 /* At this point, don't expect very many versions of each function to
923 * be generated, so not concerned about freeing them?
924 */
925
926
927 void radeonVtxfmtInit( GLcontext *ctx, GLboolean useCodegen )
928 {
929 radeonContextPtr rmesa = RADEON_CONTEXT( ctx );
930 GLvertexformat *vfmt = &(rmesa->vb.vtxfmt);
931
932 MEMSET( vfmt, 0, sizeof(GLvertexformat) );
933
934 /* Hook in chooser functions for codegen, etc:
935 */
936 radeonVtxfmtInitChoosers( vfmt );
937
938 /* Handled fully in supported states, but no codegen:
939 */
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;
945
946 /* Fallback for performance reasons: (Fix with cva/elt path here and
947 * dmatmp2.h style primitive-merging)
948 *
949 * These should call NotifyBegin(), as should _tnl_EvalMesh, to allow
950 * a driver-hook.
951 */
952 vfmt->DrawArrays = radeon_fallback_DrawArrays;
953 vfmt->DrawElements = radeon_fallback_DrawElements;
954 vfmt->DrawRangeElements = radeon_fallback_DrawRangeElements;
955
956
957 /* Not active in supported states; just keep ctx->Current uptodate:
958 */
959 vfmt->EdgeFlag = _mesa_noop_EdgeFlag;
960 vfmt->EdgeFlagv = _mesa_noop_EdgeFlagv;
961 vfmt->Indexf = _mesa_noop_Indexf;
962 vfmt->Indexfv = _mesa_noop_Indexfv;
963
964
965 /* Active but unsupported -- fallback if we receive these:
966 */
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;
997
998 (void)radeon_fallback_vtxfmt;
999
1000 TNL_CONTEXT(ctx)->Driver.NotifyBegin = radeonNotifyBegin;
1001
1002 rmesa->vb.enabled = 1;
1003 rmesa->vb.prim = &ctx->Driver.CurrentExecPrimitive;
1004 rmesa->vb.primflags = 0;
1005
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 );
1032
1033 radeonInitCodegen( &rmesa->vb.codegen, useCodegen );
1034 }
1035
1036 static void free_funcs( struct dynfn *l )
1037 {
1038 struct dynfn *f, *tmp;
1039 foreach_s (f, tmp, l) {
1040 remove_from_list( f );
1041 _mesa_exec_free( f->code );
1042 _mesa_free( f );
1043 }
1044 }
1045
1046
1047
1048 void radeonVtxfmtMakeCurrent( GLcontext *ctx )
1049 {
1050 }
1051
1052
1053 void radeonVtxfmtDestroy( GLcontext *ctx )
1054 {
1055 radeonContextPtr rmesa = RADEON_CONTEXT( ctx );
1056
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 );
1084 }
1085