projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Minor driver cleanup. Remove unnecessery/unneded radeon/r200AllocDmaRegionVerts funct...
[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 #include "dispatch.h"
61
62 static void radeonVtxfmtFlushVertices( GLcontext *, GLuint );
63
64 static void count_func( const char *name, struct dynfn *l )
65 {
66 int i = 0;
67 struct dynfn *f;
68 foreach (f, l) i++;
69 if (i) fprintf(stderr, "%s: %d\n", name, i );
70 }
71
72 static void count_funcs( radeonContextPtr rmesa )
73 {
74 count_func( "Vertex2f", &rmesa->vb.dfn_cache.Vertex2f );
75 count_func( "Vertex2fv", &rmesa->vb.dfn_cache.Vertex2fv );
76 count_func( "Vertex3f", &rmesa->vb.dfn_cache.Vertex3f );
77 count_func( "Vertex3fv", &rmesa->vb.dfn_cache.Vertex3fv );
78 count_func( "Color4ub", &rmesa->vb.dfn_cache.Color4ub );
79 count_func( "Color4ubv", &rmesa->vb.dfn_cache.Color4ubv );
80 count_func( "Color3ub", &rmesa->vb.dfn_cache.Color3ub );
81 count_func( "Color3ubv", &rmesa->vb.dfn_cache.Color3ubv );
82 count_func( "Color4f", &rmesa->vb.dfn_cache.Color4f );
83 count_func( "Color4fv", &rmesa->vb.dfn_cache.Color4fv );
84 count_func( "Color3f", &rmesa->vb.dfn_cache.Color3f );
85 count_func( "Color3fv", &rmesa->vb.dfn_cache.Color3fv );
86 count_func( "SecondaryColor3f", &rmesa->vb.dfn_cache.SecondaryColor3fEXT );
87 count_func( "SecondaryColor3fv", &rmesa->vb.dfn_cache.SecondaryColor3fvEXT );
88 count_func( "SecondaryColor3ub", &rmesa->vb.dfn_cache.SecondaryColor3ubEXT );
89 count_func( "SecondaryColor3ubv", &rmesa->vb.dfn_cache.SecondaryColor3ubvEXT );
90 count_func( "Normal3f", &rmesa->vb.dfn_cache.Normal3f );
91 count_func( "Normal3fv", &rmesa->vb.dfn_cache.Normal3fv );
92 count_func( "TexCoord2f", &rmesa->vb.dfn_cache.TexCoord2f );
93 count_func( "TexCoord2fv", &rmesa->vb.dfn_cache.TexCoord2fv );
94 count_func( "TexCoord1f", &rmesa->vb.dfn_cache.TexCoord1f );
95 count_func( "TexCoord1fv", &rmesa->vb.dfn_cache.TexCoord1fv );
96 count_func( "MultiTexCoord2fARB", &rmesa->vb.dfn_cache.MultiTexCoord2fARB );
97 count_func( "MultiTexCoord2fvARB", &rmesa->vb.dfn_cache.MultiTexCoord2fvARB );
98 count_func( "MultiTexCoord1fARB", &rmesa->vb.dfn_cache.MultiTexCoord1fARB );
99 count_func( "MultiTexCoord1fvARB", &rmesa->vb.dfn_cache.MultiTexCoord1fvARB );
100 }
101
102
103 void radeon_copy_to_current( GLcontext *ctx )
104 {
105 radeonContextPtr rmesa = RADEON_CONTEXT(ctx);
106
107 assert(ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT);
108
109 if (rmesa->vb.vertex_format & RADEON_CP_VC_FRMT_N0) {
110 ctx->Current.Attrib[VERT_ATTRIB_NORMAL][0] = rmesa->vb.normalptr[0];
111 ctx->Current.Attrib[VERT_ATTRIB_NORMAL][1] = rmesa->vb.normalptr[1];
112 ctx->Current.Attrib[VERT_ATTRIB_NORMAL][2] = rmesa->vb.normalptr[2];
113 }
114
115 if (rmesa->vb.vertex_format & RADEON_CP_VC_FRMT_PKCOLOR) {
116 ctx->Current.Attrib[VERT_ATTRIB_COLOR0][0] = UBYTE_TO_FLOAT( rmesa->vb.colorptr->red );
117 ctx->Current.Attrib[VERT_ATTRIB_COLOR0][1] = UBYTE_TO_FLOAT( rmesa->vb.colorptr->green );
118 ctx->Current.Attrib[VERT_ATTRIB_COLOR0][2] = UBYTE_TO_FLOAT( rmesa->vb.colorptr->blue );
119 ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3] = UBYTE_TO_FLOAT( rmesa->vb.colorptr->alpha );
120 }
121
122 if (rmesa->vb.vertex_format & RADEON_CP_VC_FRMT_FPCOLOR) {
123 ctx->Current.Attrib[VERT_ATTRIB_COLOR0][0] = rmesa->vb.floatcolorptr[0];
124 ctx->Current.Attrib[VERT_ATTRIB_COLOR0][1] = rmesa->vb.floatcolorptr[1];
125 ctx->Current.Attrib[VERT_ATTRIB_COLOR0][2] = rmesa->vb.floatcolorptr[2];
126 }
127
128 if (rmesa->vb.vertex_format & RADEON_CP_VC_FRMT_FPALPHA)
129 ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3] = rmesa->vb.floatcolorptr[3];
130
131 if (rmesa->vb.vertex_format & RADEON_CP_VC_FRMT_PKSPEC) {
132 ctx->Current.Attrib[VERT_ATTRIB_COLOR1][0] = UBYTE_TO_FLOAT( rmesa->vb.specptr->red );
133 ctx->Current.Attrib[VERT_ATTRIB_COLOR1][1] = UBYTE_TO_FLOAT( rmesa->vb.specptr->green );
134 ctx->Current.Attrib[VERT_ATTRIB_COLOR1][2] = UBYTE_TO_FLOAT( rmesa->vb.specptr->blue );
135 }
136
137 if (rmesa->vb.vertex_format & RADEON_CP_VC_FRMT_ST0) {
138 ctx->Current.Attrib[VERT_ATTRIB_TEX0][0] = rmesa->vb.texcoordptr[0][0];
139 ctx->Current.Attrib[VERT_ATTRIB_TEX0][1] = rmesa->vb.texcoordptr[0][1];
140 ctx->Current.Attrib[VERT_ATTRIB_TEX0][2] = 0.0F;
141 ctx->Current.Attrib[VERT_ATTRIB_TEX0][3] = 1.0F;
142 }
143
144 if (rmesa->vb.vertex_format & RADEON_CP_VC_FRMT_ST1) {
145 ctx->Current.Attrib[VERT_ATTRIB_TEX1][0] = rmesa->vb.texcoordptr[1][0];
146 ctx->Current.Attrib[VERT_ATTRIB_TEX1][1] = rmesa->vb.texcoordptr[1][1];
147 ctx->Current.Attrib[VERT_ATTRIB_TEX1][2] = 0.0F;
148 ctx->Current.Attrib[VERT_ATTRIB_TEX1][3] = 1.0F;
149 }
150
151 ctx->Driver.NeedFlush &= ~FLUSH_UPDATE_CURRENT;
152 }
153
154 static GLboolean discreet_gl_prim[GL_POLYGON+1] = {
155 1, /* 0 points */
156 1, /* 1 lines */
157 0, /* 2 line_strip */
158 0, /* 3 line_loop */
159 1, /* 4 tris */
160 0, /* 5 tri_fan */
161 0, /* 6 tri_strip */
162 1, /* 7 quads */
163 0, /* 8 quadstrip */
164 0, /* 9 poly */
165 };
166
167 static void flush_prims( radeonContextPtr rmesa )
168 {
169 int i,j;
170 struct radeon_dma_region tmp = rmesa->dma.current;
171
172 tmp.buf->refcount++;
173 tmp.aos_size = rmesa->vb.vertex_size;
174 tmp.aos_stride = rmesa->vb.vertex_size;
175 tmp.aos_start = GET_START(&tmp);
176
177 rmesa->dma.current.ptr = rmesa->dma.current.start +=
178 (rmesa->vb.initial_counter - rmesa->vb.counter) * rmesa->vb.vertex_size * 4;
179
180 rmesa->tcl.vertex_format = rmesa->vb.vertex_format;
181 rmesa->tcl.aos_components[0] = &tmp;
182 rmesa->tcl.nr_aos_components = 1;
183 rmesa->dma.flush = NULL;
184
185 /* Optimize the primitive list:
186 */
187 if (rmesa->vb.nrprims > 1) {
188 for (j = 0, i = 1 ; i < rmesa->vb.nrprims; i++) {
189 int pj = rmesa->vb.primlist[j].prim & 0xf;
190 int pi = rmesa->vb.primlist[i].prim & 0xf;
191
192 if (pj == pi && discreet_gl_prim[pj] &&
193 rmesa->vb.primlist[i].start == rmesa->vb.primlist[j].end) {
194 rmesa->vb.primlist[j].end = rmesa->vb.primlist[i].end;
195 }
196 else {
197 j++;
198 if (j != i) rmesa->vb.primlist[j] = rmesa->vb.primlist[i];
199 }
200 }
201 rmesa->vb.nrprims = j+1;
202 }
203
204 for (i = 0 ; i < rmesa->vb.nrprims; i++) {
205 if (RADEON_DEBUG & DEBUG_PRIMS)
206 fprintf(stderr, "vtxfmt prim %d: %s %d..%d\n", i,
207 _mesa_lookup_enum_by_nr( rmesa->vb.primlist[i].prim &
208 PRIM_MODE_MASK ),
209 rmesa->vb.primlist[i].start,
210 rmesa->vb.primlist[i].end);
211
212 radeonEmitPrimitive( rmesa->glCtx,
213 rmesa->vb.primlist[i].start,
214 rmesa->vb.primlist[i].end,
215 rmesa->vb.primlist[i].prim );
216 }
217
218 rmesa->vb.nrprims = 0;
219 radeonReleaseDmaRegion( rmesa, &tmp, __FUNCTION__ );
220 }
221
222
223 static void start_prim( radeonContextPtr rmesa, GLuint mode )
224 {
225 if (RADEON_DEBUG & DEBUG_VFMT)
226 fprintf(stderr, "%s %d\n", __FUNCTION__, rmesa->vb.initial_counter - rmesa->vb.counter);
227
228 rmesa->vb.primlist[rmesa->vb.nrprims].start = rmesa->vb.initial_counter - rmesa->vb.counter;
229 rmesa->vb.primlist[rmesa->vb.nrprims].prim = mode;
230 }
231
232 static void note_last_prim( radeonContextPtr rmesa, GLuint flags )
233 {
234 if (RADEON_DEBUG & DEBUG_VFMT)
235 fprintf(stderr, "%s %d\n", __FUNCTION__, rmesa->vb.initial_counter - rmesa->vb.counter);
236
237 if (rmesa->vb.prim[0] != GL_POLYGON+1) {
238 rmesa->vb.primlist[rmesa->vb.nrprims].prim |= flags;
239 rmesa->vb.primlist[rmesa->vb.nrprims].end = rmesa->vb.initial_counter - rmesa->vb.counter;
240
241 if (++(rmesa->vb.nrprims) == RADEON_MAX_PRIMS)
242 flush_prims( rmesa );
243 }
244 }
245
246
247 static void copy_vertex( radeonContextPtr rmesa, GLuint n, GLfloat *dst )
248 {
249 GLuint i;
250 GLfloat *src = (GLfloat *)(rmesa->dma.current.address +
251 rmesa->dma.current.ptr +
252 (rmesa->vb.primlist[rmesa->vb.nrprims].start + n) *
253 rmesa->vb.vertex_size * 4);
254
255 if (RADEON_DEBUG & DEBUG_VFMT)
256 fprintf(stderr, "copy_vertex %d\n", rmesa->vb.primlist[rmesa->vb.nrprims].start + n);
257
258 for (i = 0 ; i < rmesa->vb.vertex_size; i++) {
259 dst[i] = src[i];
260 }
261 }
262
263 /* NOTE: This actually reads the copied vertices back from uncached
264 * memory. Could also use the counter/notify mechanism to populate
265 * tmp on the fly as vertices are generated.
266 */
267 static GLuint copy_dma_verts( radeonContextPtr rmesa, GLfloat (*tmp)[15] )
268 {
269 GLuint ovf, i;
270 GLuint nr = (rmesa->vb.initial_counter - rmesa->vb.counter) - rmesa->vb.primlist[rmesa->vb.nrprims].start;
271
272 if (RADEON_DEBUG & DEBUG_VFMT)
273 fprintf(stderr, "%s %d verts\n", __FUNCTION__, nr);
274
275 switch( rmesa->vb.prim[0] )
276 {
277 case GL_POINTS:
278 return 0;
279 case GL_LINES:
280 ovf = nr&1;
281 for (i = 0 ; i < ovf ; i++)
282 copy_vertex( rmesa, nr-ovf+i, tmp[i] );
283 return i;
284 case GL_TRIANGLES:
285 ovf = nr%3;
286 for (i = 0 ; i < ovf ; i++)
287 copy_vertex( rmesa, nr-ovf+i, tmp[i] );
288 return i;
289 case GL_QUADS:
290 ovf = nr&3;
291 for (i = 0 ; i < ovf ; i++)
292 copy_vertex( rmesa, nr-ovf+i, tmp[i] );
293 return i;
294 case GL_LINE_STRIP:
295 if (nr == 0)
296 return 0;
297 copy_vertex( rmesa, nr-1, tmp[0] );
298 return 1;
299 case GL_LINE_LOOP:
300 case GL_TRIANGLE_FAN:
301 case GL_POLYGON:
302 if (nr == 0)
303 return 0;
304 else if (nr == 1) {
305 copy_vertex( rmesa, 0, tmp[0] );
306 return 1;
307 } else {
308 copy_vertex( rmesa, 0, tmp[0] );
309 copy_vertex( rmesa, nr-1, tmp[1] );
310 return 2;
311 }
312 case GL_TRIANGLE_STRIP:
313 ovf = MIN2(nr, 2);
314 for (i = 0 ; i < ovf ; i++)
315 copy_vertex( rmesa, nr-ovf+i, tmp[i] );
316 return i;
317 case GL_QUAD_STRIP:
318 switch (nr) {
319 case 0: ovf = 0; break;
320 case 1: ovf = 1; break;
321 default: ovf = 2 + (nr&1); break;
322 }
323 for (i = 0 ; i < ovf ; i++)
324 copy_vertex( rmesa, nr-ovf+i, tmp[i] );
325 return i;
326 default:
327 assert(0);
328 return 0;
329 }
330 }
331
332 static void VFMT_FALLBACK_OUTSIDE_BEGIN_END( const char *caller )
333 {
334 GET_CURRENT_CONTEXT(ctx);
335 radeonContextPtr rmesa = RADEON_CONTEXT(ctx);
336
337 if (RADEON_DEBUG & (DEBUG_VFMT|DEBUG_FALLBACKS))
338 fprintf(stderr, "%s from %s\n", __FUNCTION__, caller);
339
340 if (ctx->Driver.NeedFlush)
341 radeonVtxfmtFlushVertices( ctx, ctx->Driver.NeedFlush );
342
343 if (ctx->NewState)
344 _mesa_update_state( ctx ); /* clear state so fell_back sticks */
345
346 _tnl_wakeup_exec( ctx );
347 ctx->Driver.FlushVertices = radeonFlushVertices;
348
349 assert( rmesa->dma.flush == 0 );
350 rmesa->vb.fell_back = GL_TRUE;
351 rmesa->vb.installed = GL_FALSE;
352 }
353
354
355 static void VFMT_FALLBACK( const char *caller )
356 {
357 GET_CURRENT_CONTEXT(ctx);
358 radeonContextPtr rmesa = RADEON_CONTEXT(ctx);
359 GLfloat tmp[3][15];
360 GLuint i, prim;
361 GLuint ind = rmesa->vb.vertex_format;
362 GLuint nrverts;
363 GLfloat alpha = 1.0;
364
365 if (RADEON_DEBUG & (DEBUG_FALLBACKS|DEBUG_VFMT))
366 fprintf(stderr, "%s from %s\n", __FUNCTION__, caller);
367
368 if (rmesa->vb.prim[0] == GL_POLYGON+1) {
369 VFMT_FALLBACK_OUTSIDE_BEGIN_END( __FUNCTION__ );
370 return;
371 }
372
373 /* Copy vertices out of dma:
374 */
375 nrverts = copy_dma_verts( rmesa, tmp );
376
377 /* Finish the prim at this point:
378 */
379 note_last_prim( rmesa, 0 );
380 flush_prims( rmesa );
381
382 /* Update ctx->Driver.CurrentExecPrimitive and swap in swtnl.
383 */
384 prim = rmesa->vb.prim[0];
385 ctx->Driver.CurrentExecPrimitive = GL_POLYGON+1;
386 _tnl_wakeup_exec( ctx );
387 ctx->Driver.FlushVertices = radeonFlushVertices;
388
389 assert(rmesa->dma.flush == 0);
390 rmesa->vb.fell_back = GL_TRUE;
391 rmesa->vb.installed = GL_FALSE;
392 CALL_Begin(GET_DISPATCH(), (prim));
393
394 if (rmesa->vb.installed_color_3f_sz == 4)
395 alpha = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3];
396
397 /* Replay saved vertices
398 */
399 for (i = 0 ; i < nrverts; i++) {
400 GLuint offset = 3;
401 if (ind & RADEON_CP_VC_FRMT_N0) {
402 CALL_Normal3fv(GET_DISPATCH(), (&tmp[i][offset]));
403 offset += 3;
404 }
405
406 if (ind & RADEON_CP_VC_FRMT_PKCOLOR) {
407 radeon_color_t *col = (radeon_color_t *)&tmp[i][offset];
408 CALL_Color4ub(GET_DISPATCH(), (col->red, col->green, col->blue, col->alpha));
409 offset++;
410 }
411 else if (ind & RADEON_CP_VC_FRMT_FPALPHA) {
412 CALL_Color4fv(GET_DISPATCH(), (&tmp[i][offset]));
413 offset+=4;
414 }
415 else if (ind & RADEON_CP_VC_FRMT_FPCOLOR) {
416 CALL_Color3fv(GET_DISPATCH(), (&tmp[i][offset]));
417 offset+=3;
418 }
419
420 if (ind & RADEON_CP_VC_FRMT_PKSPEC) {
421 radeon_color_t *spec = (radeon_color_t *)&tmp[i][offset];
422 CALL_SecondaryColor3ubEXT(GET_DISPATCH(), (spec->red, spec->green, spec->blue));
423 offset++;
424 }
425
426 if (ind & RADEON_CP_VC_FRMT_ST0) {
427 CALL_TexCoord2fv(GET_DISPATCH(), (&tmp[i][offset]));
428 offset += 2;
429 }
430
431 if (ind & RADEON_CP_VC_FRMT_ST1) {
432 CALL_MultiTexCoord2fvARB(GET_DISPATCH(), (GL_TEXTURE1_ARB, &tmp[i][offset]));
433 offset += 2;
434 }
435 CALL_Vertex3fv(GET_DISPATCH(), (&tmp[i][0]));
436 }
437
438 /* Replay current vertex
439 */
440 if (ind & RADEON_CP_VC_FRMT_N0)
441 CALL_Normal3fv(GET_DISPATCH(), (rmesa->vb.normalptr));
442
443 if (ind & RADEON_CP_VC_FRMT_PKCOLOR)
444 CALL_Color4ub(GET_DISPATCH(), (rmesa->vb.colorptr->red, rmesa->vb.colorptr->green, rmesa->vb.colorptr->blue, rmesa->vb.colorptr->alpha));
445 else if (ind & RADEON_CP_VC_FRMT_FPALPHA)
446 CALL_Color4fv(GET_DISPATCH(), (rmesa->vb.floatcolorptr));
447 else if (ind & RADEON_CP_VC_FRMT_FPCOLOR) {
448 if (rmesa->vb.installed_color_3f_sz == 4 && alpha != 1.0)
449 CALL_Color4f(GET_DISPATCH(), (rmesa->vb.floatcolorptr[0],
450 rmesa->vb.floatcolorptr[1],
451 rmesa->vb.floatcolorptr[2],
452 alpha));
453 else
454 CALL_Color3fv(GET_DISPATCH(), (rmesa->vb.floatcolorptr));
455 }
456
457 if (ind & RADEON_CP_VC_FRMT_PKSPEC)
458 CALL_SecondaryColor3ubEXT(GET_DISPATCH(), (rmesa->vb.specptr->red, rmesa->vb.specptr->green, rmesa->vb.specptr->blue));
459
460 if (ind & RADEON_CP_VC_FRMT_ST0)
461 CALL_TexCoord2fv(GET_DISPATCH(), (rmesa->vb.texcoordptr[0]));
462
463 if (ind & RADEON_CP_VC_FRMT_ST1)
464 CALL_MultiTexCoord2fvARB(GET_DISPATCH(), (GL_TEXTURE1_ARB, rmesa->vb.texcoordptr[1]));
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][15];
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
551 if (rmesa->TclFallback || rmesa->vb.fell_back || ctx->CompileFlag)
552 return GL_FALSE;
553
554 if (ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT)
555 ctx->Driver.FlushVertices( ctx, FLUSH_UPDATE_CURRENT );
556
557 /* Make all this event-driven:
558 */
559 if (ctx->Light.Enabled) {
560 ind |= RADEON_CP_VC_FRMT_N0;
561
562 /* TODO: make this data driven: If we receive only ubytes, send
563 * color as ubytes. Also check if converting (with free
564 * checking for overflow) is cheaper than sending floats
565 * directly.
566 */
567 if (ctx->Light.ColorMaterialEnabled) {
568 ind |= (RADEON_CP_VC_FRMT_FPCOLOR |
569 RADEON_CP_VC_FRMT_FPALPHA);
570 }
571 else
572 ind |= RADEON_CP_VC_FRMT_PKCOLOR; /* for alpha? */
573 }
574 else {
575 /* TODO: make this data driven?
576 */
577 ind |= RADEON_CP_VC_FRMT_PKCOLOR;
578
579 if (ctx->_TriangleCaps & DD_SEPARATE_SPECULAR) {
580 ind |= RADEON_CP_VC_FRMT_PKSPEC;
581 }
582 }
583
584 if (ctx->Texture.Unit[0]._ReallyEnabled) {
585 if (ctx->Texture.Unit[0].TexGenEnabled) {
586 if (rmesa->TexGenNeedNormals[0]) {
587 ind |= RADEON_CP_VC_FRMT_N0;
588 }
589 } else {
590 if (ctx->Current.Attrib[VERT_ATTRIB_TEX0][2] != 0.0F ||
591 ctx->Current.Attrib[VERT_ATTRIB_TEX0][3] != 1.0) {
592 if (RADEON_DEBUG & (DEBUG_VFMT|DEBUG_FALLBACKS))
593 fprintf(stderr, "%s: rq0\n", __FUNCTION__);
594 return GL_FALSE;
595 }
596 ind |= RADEON_CP_VC_FRMT_ST0;
597 }
598 }
599
600 if (ctx->Texture.Unit[1]._ReallyEnabled) {
601 if (ctx->Texture.Unit[1].TexGenEnabled) {
602 if (rmesa->TexGenNeedNormals[1]) {
603 ind |= RADEON_CP_VC_FRMT_N0;
604 }
605 } else {
606 if (ctx->Current.Attrib[VERT_ATTRIB_TEX1][2] != 0.0F ||
607 ctx->Current.Attrib[VERT_ATTRIB_TEX1][3] != 1.0) {
608 if (RADEON_DEBUG & (DEBUG_VFMT|DEBUG_FALLBACKS))
609 fprintf(stderr, "%s: rq1\n", __FUNCTION__);
610 return GL_FALSE;
611 }
612 ind |= RADEON_CP_VC_FRMT_ST1;
613 }
614 }
615
616 if (RADEON_DEBUG & (DEBUG_VFMT|DEBUG_STATE))
617 fprintf(stderr, "%s: format: 0x%x\n", __FUNCTION__, ind );
618
619 RADEON_NEWPRIM(rmesa);
620 rmesa->vb.vertex_format = ind;
621 rmesa->vb.vertex_size = 3;
622 rmesa->vb.prim = &ctx->Driver.CurrentExecPrimitive;
623
624 rmesa->vb.normalptr = ctx->Current.Attrib[VERT_ATTRIB_NORMAL];
625 rmesa->vb.colorptr = NULL;
626 rmesa->vb.floatcolorptr = ctx->Current.Attrib[VERT_ATTRIB_COLOR0];
627 rmesa->vb.specptr = NULL;
628 rmesa->vb.floatspecptr = ctx->Current.Attrib[VERT_ATTRIB_COLOR1];
629 rmesa->vb.texcoordptr[0] = ctx->Current.Attrib[VERT_ATTRIB_TEX0];
630 rmesa->vb.texcoordptr[1] = ctx->Current.Attrib[VERT_ATTRIB_TEX1];
631
632 /* Run through and initialize the vertex components in the order
633 * the hardware understands:
634 */
635 if (ind & RADEON_CP_VC_FRMT_N0) {
636 rmesa->vb.normalptr = &rmesa->vb.vertex[rmesa->vb.vertex_size].f;
637 rmesa->vb.vertex_size += 3;
638 rmesa->vb.normalptr[0] = ctx->Current.Attrib[VERT_ATTRIB_NORMAL][0];
639 rmesa->vb.normalptr[1] = ctx->Current.Attrib[VERT_ATTRIB_NORMAL][1];
640 rmesa->vb.normalptr[2] = ctx->Current.Attrib[VERT_ATTRIB_NORMAL][2];
641 }
642
643 if (ind & RADEON_CP_VC_FRMT_PKCOLOR) {
644 rmesa->vb.colorptr = &rmesa->vb.vertex[rmesa->vb.vertex_size].color;
645 rmesa->vb.vertex_size += 1;
646 UNCLAMPED_FLOAT_TO_CHAN( rmesa->vb.colorptr->red, ctx->Current.Attrib[VERT_ATTRIB_COLOR0][0] );
647 UNCLAMPED_FLOAT_TO_CHAN( rmesa->vb.colorptr->green, ctx->Current.Attrib[VERT_ATTRIB_COLOR0][1] );
648 UNCLAMPED_FLOAT_TO_CHAN( rmesa->vb.colorptr->blue, ctx->Current.Attrib[VERT_ATTRIB_COLOR0][2] );
649 UNCLAMPED_FLOAT_TO_CHAN( rmesa->vb.colorptr->alpha, ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3] );
650 }
651
652 if (ind & RADEON_CP_VC_FRMT_FPCOLOR) {
653 assert(!(ind & RADEON_CP_VC_FRMT_PKCOLOR));
654 rmesa->vb.floatcolorptr = &rmesa->vb.vertex[rmesa->vb.vertex_size].f;
655 rmesa->vb.vertex_size += 3;
656 rmesa->vb.floatcolorptr[0] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][0];
657 rmesa->vb.floatcolorptr[1] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][1];
658 rmesa->vb.floatcolorptr[2] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][2];
659
660 if (ind & RADEON_CP_VC_FRMT_FPALPHA) {
661 rmesa->vb.vertex_size += 1;
662 rmesa->vb.floatcolorptr[3] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3];
663 }
664 }
665
666 if (ind & RADEON_CP_VC_FRMT_PKSPEC) {
667 rmesa->vb.specptr = &rmesa->vb.vertex[rmesa->vb.vertex_size].color;
668 rmesa->vb.vertex_size += 1;
669 UNCLAMPED_FLOAT_TO_CHAN( rmesa->vb.specptr->red, ctx->Current.Attrib[VERT_ATTRIB_COLOR1][0] );
670 UNCLAMPED_FLOAT_TO_CHAN( rmesa->vb.specptr->green, ctx->Current.Attrib[VERT_ATTRIB_COLOR1][1] );
671 UNCLAMPED_FLOAT_TO_CHAN( rmesa->vb.specptr->blue, ctx->Current.Attrib[VERT_ATTRIB_COLOR1][2] );
672 }
673
674 if (ind & RADEON_CP_VC_FRMT_ST0) {
675 rmesa->vb.texcoordptr[0] = &rmesa->vb.vertex[rmesa->vb.vertex_size].f;
676 rmesa->vb.vertex_size += 2;
677 rmesa->vb.texcoordptr[0][0] = ctx->Current.Attrib[VERT_ATTRIB_TEX0][0];
678 rmesa->vb.texcoordptr[0][1] = ctx->Current.Attrib[VERT_ATTRIB_TEX0][1];
679 }
680
681 if (ind & RADEON_CP_VC_FRMT_ST1) {
682 rmesa->vb.texcoordptr[1] = &rmesa->vb.vertex[rmesa->vb.vertex_size].f;
683 rmesa->vb.vertex_size += 2;
684 rmesa->vb.texcoordptr[1][0] = ctx->Current.Attrib[VERT_ATTRIB_TEX1][0];
685 rmesa->vb.texcoordptr[1][1] = ctx->Current.Attrib[VERT_ATTRIB_TEX1][1];
686 }
687
688 if (rmesa->vb.installed_vertex_format != rmesa->vb.vertex_format) {
689 if (RADEON_DEBUG & DEBUG_VFMT)
690 fprintf(stderr, "reinstall on vertex_format change\n");
691 _mesa_install_exec_vtxfmt( ctx, &rmesa->vb.vtxfmt );
692 rmesa->vb.installed_vertex_format = rmesa->vb.vertex_format;
693 }
694
695 if (RADEON_DEBUG & DEBUG_VFMT)
696 fprintf(stderr, "%s -- success\n", __FUNCTION__);
697
698 return GL_TRUE;
699 }
700
701 void radeonVtxfmtInvalidate( GLcontext *ctx )
702 {
703 radeonContextPtr rmesa = RADEON_CONTEXT( ctx );
704
705 rmesa->vb.recheck = GL_TRUE;
706 rmesa->vb.fell_back = GL_FALSE;
707 }
708
709
710 static void radeonVtxfmtValidate( GLcontext *ctx )
711 {
712 radeonContextPtr rmesa = RADEON_CONTEXT( ctx );
713
714 if (RADEON_DEBUG & DEBUG_VFMT)
715 fprintf(stderr, "%s\n", __FUNCTION__);
716
717 if (ctx->Driver.NeedFlush)
718 ctx->Driver.FlushVertices( ctx, ctx->Driver.NeedFlush );
719
720 rmesa->vb.recheck = GL_FALSE;
721
722 if (check_vtx_fmt( ctx )) {
723 if (!rmesa->vb.installed) {
724 if (RADEON_DEBUG & DEBUG_VFMT)
725 fprintf(stderr, "reinstall (new install)\n");
726
727 _mesa_install_exec_vtxfmt( ctx, &rmesa->vb.vtxfmt );
728 ctx->Driver.FlushVertices = radeonVtxfmtFlushVertices;
729 rmesa->vb.installed = GL_TRUE;
730 }
731 else if (RADEON_DEBUG & DEBUG_VFMT)
732 fprintf(stderr, "%s: already installed", __FUNCTION__);
733 }
734 else {
735 if (RADEON_DEBUG & DEBUG_VFMT)
736 fprintf(stderr, "%s: failed\n", __FUNCTION__);
737
738 if (rmesa->vb.installed) {
739 if (rmesa->dma.flush)
740 rmesa->dma.flush( rmesa );
741 _tnl_wakeup_exec( ctx );
742 ctx->Driver.FlushVertices = radeonFlushVertices;
743 rmesa->vb.installed = GL_FALSE;
744 }
745 }
746 }
747
748
749
750 /* Materials:
751 */
752 static void radeon_Materialfv( GLenum face, GLenum pname,
753 const GLfloat *params )
754 {
755 GET_CURRENT_CONTEXT(ctx);
756 radeonContextPtr rmesa = RADEON_CONTEXT( ctx );
757
758 if (RADEON_DEBUG & DEBUG_VFMT)
759 fprintf(stderr, "%s\n", __FUNCTION__);
760
761 if (rmesa->vb.prim[0] != GL_POLYGON+1) {
762 VFMT_FALLBACK( __FUNCTION__ );
763 CALL_Materialfv(GET_DISPATCH(), (face, pname, params));
764 return;
765 }
766 _mesa_noop_Materialfv( face, pname, params );
767 radeonUpdateMaterial( ctx );
768 }
769
770
771 /* Begin/End
772 */
773 static void radeon_Begin( GLenum mode )
774 {
775 GET_CURRENT_CONTEXT(ctx);
776 radeonContextPtr rmesa = RADEON_CONTEXT(ctx);
777
778 if (RADEON_DEBUG & DEBUG_VFMT)
779 fprintf(stderr, "%s( %s )\n", __FUNCTION__,
780 _mesa_lookup_enum_by_nr( mode ));
781
782 if (mode > GL_POLYGON) {
783 _mesa_error( ctx, GL_INVALID_ENUM, "glBegin" );
784 return;
785 }
786
787 if (rmesa->vb.prim[0] != GL_POLYGON+1) {
788 _mesa_error( ctx, GL_INVALID_OPERATION, "glBegin" );
789 return;
790 }
791
792 if (ctx->NewState)
793 _mesa_update_state( ctx );
794
795 if (rmesa->NewGLState)
796 radeonValidateState( ctx );
797
798 if (rmesa->vb.recheck)
799 radeonVtxfmtValidate( ctx );
800
801 if (!rmesa->vb.installed) {
802 CALL_Begin(GET_DISPATCH(), (mode));
803 return;
804 }
805
806
807 if (rmesa->dma.flush && rmesa->vb.counter < 12) {
808 if (RADEON_DEBUG & DEBUG_VFMT)
809 fprintf(stderr, "%s: flush almost-empty buffers\n", __FUNCTION__);
810 flush_prims( rmesa );
811 }
812
813 /* Need to arrange to save vertices here? Or always copy from dma (yuk)?
814 */
815 if (!rmesa->dma.flush) {
816 if (rmesa->dma.current.ptr + 12*rmesa->vb.vertex_size*4 >
817 rmesa->dma.current.end) {
818 RADEON_NEWPRIM( rmesa );
819 radeonRefillCurrentDmaRegion( rmesa );
820 }
821
822 rmesa->vb.dmaptr = (int *)(rmesa->dma.current.address + rmesa->dma.current.ptr);
823 rmesa->vb.counter = (rmesa->dma.current.end - rmesa->dma.current.ptr) /
824 (rmesa->vb.vertex_size * 4);
825 rmesa->vb.counter--;
826 rmesa->vb.initial_counter = rmesa->vb.counter;
827 rmesa->vb.notify = wrap_buffer;
828 rmesa->dma.flush = flush_prims;
829 ctx->Driver.NeedFlush |= FLUSH_STORED_VERTICES;
830 }
831
832
833 rmesa->vb.prim[0] = mode;
834 start_prim( rmesa, mode | PRIM_BEGIN );
835 }
836
837
838
839 static void radeon_End( void )
840 {
841 GET_CURRENT_CONTEXT(ctx);
842 radeonContextPtr rmesa = RADEON_CONTEXT(ctx);
843
844 if (RADEON_DEBUG & DEBUG_VFMT)
845 fprintf(stderr, "%s\n", __FUNCTION__);
846
847 if (rmesa->vb.prim[0] == GL_POLYGON+1) {
848 _mesa_error( ctx, GL_INVALID_OPERATION, "glEnd" );
849 return;
850 }
851
852 note_last_prim( rmesa, PRIM_END );
853 rmesa->vb.prim[0] = GL_POLYGON+1;
854 }
855
856
857 /* Fallback on difficult entrypoints:
858 */
859 #define PRE_LOOPBACK( FUNC ) \
860 do { \
861 if (RADEON_DEBUG & DEBUG_VFMT) \
862 fprintf(stderr, "%s\n", __FUNCTION__); \
863 VFMT_FALLBACK( __FUNCTION__ ); \
864 } while (0)
865 #define TAG(x) radeon_fallback_##x
866 #include "vtxfmt_tmp.h"
867
868
869
870 static GLboolean radeonNotifyBegin( GLcontext *ctx, GLenum p )
871 {
872 radeonContextPtr rmesa = RADEON_CONTEXT( ctx );
873
874 if (RADEON_DEBUG & DEBUG_VFMT)
875 fprintf(stderr, "%s\n", __FUNCTION__);
876
877 assert(!rmesa->vb.installed);
878
879 if (ctx->NewState)
880 _mesa_update_state( ctx );
881
882 if (rmesa->NewGLState)
883 radeonValidateState( ctx );
884
885 if (ctx->Driver.NeedFlush)
886 ctx->Driver.FlushVertices( ctx, ctx->Driver.NeedFlush );
887
888 if (rmesa->vb.recheck)
889 radeonVtxfmtValidate( ctx );
890
891 if (!rmesa->vb.installed) {
892 if (RADEON_DEBUG & DEBUG_VFMT)
893 fprintf(stderr, "%s -- failed\n", __FUNCTION__);
894 return GL_FALSE;
895 }
896
897 radeon_Begin( p );
898 return GL_TRUE;
899 }
900
901 static void radeonVtxfmtFlushVertices( GLcontext *ctx, GLuint flags )
902 {
903 radeonContextPtr rmesa = RADEON_CONTEXT( ctx );
904
905 if (RADEON_DEBUG & DEBUG_VFMT)
906 fprintf(stderr, "%s\n", __FUNCTION__);
907
908 assert(rmesa->vb.installed);
909
910 if (flags & FLUSH_UPDATE_CURRENT) {
911 radeon_copy_to_current( ctx );
912 if (RADEON_DEBUG & DEBUG_VFMT)
913 fprintf(stderr, "reinstall on update_current\n");
914 _mesa_install_exec_vtxfmt( ctx, &rmesa->vb.vtxfmt );
915 ctx->Driver.NeedFlush &= ~FLUSH_UPDATE_CURRENT;
916 }
917
918 if (flags & FLUSH_STORED_VERTICES) {
919 radeonContextPtr rmesa = RADEON_CONTEXT( ctx );
920 assert (rmesa->dma.flush == 0 ||
921 rmesa->dma.flush == flush_prims);
922 if (rmesa->dma.flush == flush_prims)
923 flush_prims( RADEON_CONTEXT( ctx ) );
924 ctx->Driver.NeedFlush &= ~FLUSH_STORED_VERTICES;
925 }
926 }
927
928
929
930 /* At this point, don't expect very many versions of each function to
931 * be generated, so not concerned about freeing them?
932 */
933
934
935 void radeonVtxfmtInit( GLcontext *ctx, GLboolean useCodegen )
936 {
937 radeonContextPtr rmesa = RADEON_CONTEXT( ctx );
938 GLvertexformat *vfmt = &(rmesa->vb.vtxfmt);
939
940 MEMSET( vfmt, 0, sizeof(GLvertexformat) );
941
942 /* Hook in chooser functions for codegen, etc:
943 */
944 radeonVtxfmtInitChoosers( vfmt );
945
946 /* Handled fully in supported states, but no codegen:
947 */
948 vfmt->Materialfv = radeon_Materialfv;
949 vfmt->ArrayElement = _ae_loopback_array_elt; /* generic helper */
950 vfmt->Rectf = _mesa_noop_Rectf; /* generic helper */
951 vfmt->Begin = radeon_Begin;
952 vfmt->End = radeon_End;
953
954 /* Fallback for performance reasons: (Fix with cva/elt path here and
955 * dmatmp2.h style primitive-merging)
956 *
957 * These should call NotifyBegin(), as should _tnl_EvalMesh, to allow
958 * a driver-hook.
959 */
960 vfmt->DrawArrays = radeon_fallback_DrawArrays;
961 vfmt->DrawElements = radeon_fallback_DrawElements;
962 vfmt->DrawRangeElements = radeon_fallback_DrawRangeElements;
963
964
965 /* Not active in supported states; just keep ctx->Current uptodate:
966 */
967 vfmt->FogCoordfvEXT = _mesa_noop_FogCoordfvEXT;
968 vfmt->FogCoordfEXT = _mesa_noop_FogCoordfEXT;
969 vfmt->EdgeFlag = _mesa_noop_EdgeFlag;
970 vfmt->EdgeFlagv = _mesa_noop_EdgeFlagv;
971 vfmt->Indexf = _mesa_noop_Indexf;
972 vfmt->Indexfv = _mesa_noop_Indexfv;
973
974
975 /* Active but unsupported -- fallback if we receive these:
976 */
977 vfmt->CallList = radeon_fallback_CallList;
978 vfmt->CallLists = radeon_fallback_CallLists;
979 vfmt->EvalCoord1f = radeon_fallback_EvalCoord1f;
980 vfmt->EvalCoord1fv = radeon_fallback_EvalCoord1fv;
981 vfmt->EvalCoord2f = radeon_fallback_EvalCoord2f;
982 vfmt->EvalCoord2fv = radeon_fallback_EvalCoord2fv;
983 vfmt->EvalMesh1 = radeon_fallback_EvalMesh1;
984 vfmt->EvalMesh2 = radeon_fallback_EvalMesh2;
985 vfmt->EvalPoint1 = radeon_fallback_EvalPoint1;
986 vfmt->EvalPoint2 = radeon_fallback_EvalPoint2;
987 vfmt->TexCoord3f = radeon_fallback_TexCoord3f;
988 vfmt->TexCoord3fv = radeon_fallback_TexCoord3fv;
989 vfmt->TexCoord4f = radeon_fallback_TexCoord4f;
990 vfmt->TexCoord4fv = radeon_fallback_TexCoord4fv;
991 vfmt->MultiTexCoord3fARB = radeon_fallback_MultiTexCoord3fARB;
992 vfmt->MultiTexCoord3fvARB = radeon_fallback_MultiTexCoord3fvARB;
993 vfmt->MultiTexCoord4fARB = radeon_fallback_MultiTexCoord4fARB;
994 vfmt->MultiTexCoord4fvARB = radeon_fallback_MultiTexCoord4fvARB;
995 vfmt->Vertex4f = radeon_fallback_Vertex4f;
996 vfmt->Vertex4fv = radeon_fallback_Vertex4fv;
997 vfmt->VertexAttrib1fNV = radeon_fallback_VertexAttrib1fNV;
998 vfmt->VertexAttrib1fvNV = radeon_fallback_VertexAttrib1fvNV;
999 vfmt->VertexAttrib2fNV = radeon_fallback_VertexAttrib2fNV;
1000 vfmt->VertexAttrib2fvNV = radeon_fallback_VertexAttrib2fvNV;
1001 vfmt->VertexAttrib3fNV = radeon_fallback_VertexAttrib3fNV;
1002 vfmt->VertexAttrib3fvNV = radeon_fallback_VertexAttrib3fvNV;
1003 vfmt->VertexAttrib4fNV = radeon_fallback_VertexAttrib4fNV;
1004 vfmt->VertexAttrib4fvNV = radeon_fallback_VertexAttrib4fvNV;
1005
1006 (void)radeon_fallback_vtxfmt;
1007
1008 TNL_CONTEXT(ctx)->Driver.NotifyBegin = radeonNotifyBegin;
1009
1010 rmesa->vb.enabled = 1;
1011 rmesa->vb.prim = &ctx->Driver.CurrentExecPrimitive;
1012 rmesa->vb.primflags = 0;
1013
1014 make_empty_list( &rmesa->vb.dfn_cache.Vertex2f );
1015 make_empty_list( &rmesa->vb.dfn_cache.Vertex2fv );
1016 make_empty_list( &rmesa->vb.dfn_cache.Vertex3f );
1017 make_empty_list( &rmesa->vb.dfn_cache.Vertex3fv );
1018 make_empty_list( &rmesa->vb.dfn_cache.Color4ub );
1019 make_empty_list( &rmesa->vb.dfn_cache.Color4ubv );
1020 make_empty_list( &rmesa->vb.dfn_cache.Color3ub );
1021 make_empty_list( &rmesa->vb.dfn_cache.Color3ubv );
1022 make_empty_list( &rmesa->vb.dfn_cache.Color4f );
1023 make_empty_list( &rmesa->vb.dfn_cache.Color4fv );
1024 make_empty_list( &rmesa->vb.dfn_cache.Color3f );
1025 make_empty_list( &rmesa->vb.dfn_cache.Color3fv );
1026 make_empty_list( &rmesa->vb.dfn_cache.SecondaryColor3fEXT );
1027 make_empty_list( &rmesa->vb.dfn_cache.SecondaryColor3fvEXT );
1028 make_empty_list( &rmesa->vb.dfn_cache.SecondaryColor3ubEXT );
1029 make_empty_list( &rmesa->vb.dfn_cache.SecondaryColor3ubvEXT );
1030 make_empty_list( &rmesa->vb.dfn_cache.Normal3f );
1031 make_empty_list( &rmesa->vb.dfn_cache.Normal3fv );
1032 make_empty_list( &rmesa->vb.dfn_cache.TexCoord2f );
1033 make_empty_list( &rmesa->vb.dfn_cache.TexCoord2fv );
1034 make_empty_list( &rmesa->vb.dfn_cache.TexCoord1f );
1035 make_empty_list( &rmesa->vb.dfn_cache.TexCoord1fv );
1036 make_empty_list( &rmesa->vb.dfn_cache.MultiTexCoord2fARB );
1037 make_empty_list( &rmesa->vb.dfn_cache.MultiTexCoord2fvARB );
1038 make_empty_list( &rmesa->vb.dfn_cache.MultiTexCoord1fARB );
1039 make_empty_list( &rmesa->vb.dfn_cache.MultiTexCoord1fvARB );
1040
1041 radeonInitCodegen( &rmesa->vb.codegen, useCodegen );
1042 }
1043
1044 static void free_funcs( struct dynfn *l )
1045 {
1046 struct dynfn *f, *tmp;
1047 foreach_s (f, tmp, l) {
1048 remove_from_list( f );
1049 ALIGN_FREE( f->code );
1050 FREE( f );
1051 }
1052 }
1053
1054
1055
1056 void radeonVtxfmtMakeCurrent( GLcontext *ctx )
1057 {
1058 }
1059
1060
1061 void radeonVtxfmtDestroy( GLcontext *ctx )
1062 {
1063 radeonContextPtr rmesa = RADEON_CONTEXT( ctx );
1064
1065 count_funcs( rmesa );
1066 free_funcs( &rmesa->vb.dfn_cache.Vertex2f );
1067 free_funcs( &rmesa->vb.dfn_cache.Vertex2fv );
1068 free_funcs( &rmesa->vb.dfn_cache.Vertex3f );
1069 free_funcs( &rmesa->vb.dfn_cache.Vertex3fv );
1070 free_funcs( &rmesa->vb.dfn_cache.Color4ub );
1071 free_funcs( &rmesa->vb.dfn_cache.Color4ubv );
1072 free_funcs( &rmesa->vb.dfn_cache.Color3ub );
1073 free_funcs( &rmesa->vb.dfn_cache.Color3ubv );
1074 free_funcs( &rmesa->vb.dfn_cache.Color4f );
1075 free_funcs( &rmesa->vb.dfn_cache.Color4fv );
1076 free_funcs( &rmesa->vb.dfn_cache.Color3f );
1077 free_funcs( &rmesa->vb.dfn_cache.Color3fv );
1078 free_funcs( &rmesa->vb.dfn_cache.SecondaryColor3ubEXT );
1079 free_funcs( &rmesa->vb.dfn_cache.SecondaryColor3ubvEXT );
1080 free_funcs( &rmesa->vb.dfn_cache.SecondaryColor3fEXT );
1081 free_funcs( &rmesa->vb.dfn_cache.SecondaryColor3fvEXT );
1082 free_funcs( &rmesa->vb.dfn_cache.Normal3f );
1083 free_funcs( &rmesa->vb.dfn_cache.Normal3fv );
1084 free_funcs( &rmesa->vb.dfn_cache.TexCoord2f );
1085 free_funcs( &rmesa->vb.dfn_cache.TexCoord2fv );
1086 free_funcs( &rmesa->vb.dfn_cache.TexCoord1f );
1087 free_funcs( &rmesa->vb.dfn_cache.TexCoord1fv );
1088 free_funcs( &rmesa->vb.dfn_cache.MultiTexCoord2fARB );
1089 free_funcs( &rmesa->vb.dfn_cache.MultiTexCoord2fvARB );
1090 free_funcs( &rmesa->vb.dfn_cache.MultiTexCoord1fARB );
1091 free_funcs( &rmesa->vb.dfn_cache.MultiTexCoord1fvARB );
1092 }
1093