projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Wrap every place that accesses a dispatch table with a macro. A new script-
[mesa.git] / src / mesa / drivers / dri / r200 / r200_vtxfmt_c.c
1 /* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_vtxfmt_c.c,v 1.2 2002/12/16 16:18:56 dawes Exp $ */
2 /*
3 Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.
4
5 The Weather Channel (TM) funded Tungsten Graphics to develop the
6 initial release of the Radeon 8500 driver under the XFree86 license.
7 This notice must be preserved.
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
36 #include "glheader.h"
37 #include "imports.h"
38 #include "mtypes.h"
39 #include "colormac.h"
40 #include "simple_list.h"
41 #include "api_noop.h"
42 #include "vtxfmt.h"
43
44 #include "r200_vtxfmt.h"
45 #include "r200_tcl.h"
46
47 #include "dispatch.h"
48
49 /* Fallback versions of all the entrypoints for situations where
50 * codegen isn't available. This is still a lot faster than the
51 * vb/pipeline implementation in Mesa.
52 */
53 static void r200_Vertex3f( GLfloat x, GLfloat y, GLfloat z )
54 {
55 GET_CURRENT_CONTEXT(ctx);
56 r200ContextPtr rmesa = R200_CONTEXT(ctx);
57 int i;
58
59 *rmesa->vb.dmaptr++ = *(int *)&x;
60 *rmesa->vb.dmaptr++ = *(int *)&y;
61 *rmesa->vb.dmaptr++ = *(int *)&z;
62
63 for (i = 3; i < rmesa->vb.vertex_size; i++)
64 *rmesa->vb.dmaptr++ = rmesa->vb.vertex[i].i;
65
66 if (--rmesa->vb.counter == 0)
67 rmesa->vb.notify();
68 }
69
70
71 static void r200_Vertex3fv( const GLfloat *v )
72 {
73 GET_CURRENT_CONTEXT(ctx);
74 r200ContextPtr rmesa = R200_CONTEXT(ctx);
75 int i;
76
77 *rmesa->vb.dmaptr++ = *(int *)&v[0];
78 *rmesa->vb.dmaptr++ = *(int *)&v[1];
79 *rmesa->vb.dmaptr++ = *(int *)&v[2];
80
81 for (i = 3; i < rmesa->vb.vertex_size; i++)
82 *rmesa->vb.dmaptr++ = rmesa->vb.vertex[i].i;
83
84 if (--rmesa->vb.counter == 0)
85 rmesa->vb.notify();
86 }
87
88
89 static void r200_Vertex2f( GLfloat x, GLfloat y )
90 {
91 GET_CURRENT_CONTEXT(ctx);
92 r200ContextPtr rmesa = R200_CONTEXT(ctx);
93 int i;
94
95 *rmesa->vb.dmaptr++ = *(int *)&x;
96 *rmesa->vb.dmaptr++ = *(int *)&y;
97 *rmesa->vb.dmaptr++ = 0;
98
99 for (i = 3; i < rmesa->vb.vertex_size; i++)
100 *rmesa->vb.dmaptr++ = rmesa->vb.vertex[i].i;
101
102 if (--rmesa->vb.counter == 0)
103 rmesa->vb.notify();
104 }
105
106
107 static void r200_Vertex2fv( const GLfloat *v )
108 {
109 GET_CURRENT_CONTEXT(ctx);
110 r200ContextPtr rmesa = R200_CONTEXT(ctx);
111 int i;
112
113 *rmesa->vb.dmaptr++ = *(int *)&v[0];
114 *rmesa->vb.dmaptr++ = *(int *)&v[1];
115 *rmesa->vb.dmaptr++ = 0;
116
117 for (i = 3; i < rmesa->vb.vertex_size; i++)
118 *rmesa->vb.dmaptr++ = rmesa->vb.vertex[i].i;
119
120 if (--rmesa->vb.counter == 0)
121 rmesa->vb.notify();
122 }
123
124
125
126 /* Color for ubyte (packed) color formats:
127 */
128 #if 0
129 static void r200_Color3ub_ub( GLubyte r, GLubyte g, GLubyte b )
130 {
131 GET_CURRENT_CONTEXT(ctx);
132 r200ContextPtr rmesa = R200_CONTEXT(ctx);
133 r200_color_t *dest = rmesa->vb.colorptr;
134 dest->red = r;
135 dest->green = g;
136 dest->blue = b;
137 dest->alpha = 0xff;
138 }
139
140 static void r200_Color3ubv_ub( const GLubyte *v )
141 {
142 GET_CURRENT_CONTEXT(ctx);
143 r200ContextPtr rmesa = R200_CONTEXT(ctx);
144 r200_color_t *dest = rmesa->vb.colorptr;
145 dest->red = v[0];
146 dest->green = v[1];
147 dest->blue = v[2];
148 dest->alpha = 0xff;
149 }
150
151 static void r200_Color4ub_ub( GLubyte r, GLubyte g, GLubyte b, GLubyte a )
152 {
153 GET_CURRENT_CONTEXT(ctx);
154 r200ContextPtr rmesa = R200_CONTEXT(ctx);
155 r200_color_t *dest = rmesa->vb.colorptr;
156 dest->red = r;
157 dest->green = g;
158 dest->blue = b;
159 dest->alpha = a;
160 }
161
162 static void r200_Color4ubv_ub( const GLubyte *v )
163 {
164 GET_CURRENT_CONTEXT(ctx);
165 r200ContextPtr rmesa = R200_CONTEXT(ctx);
166 *(GLuint *)rmesa->vb.colorptr = LE32_TO_CPU(*(GLuint *)v);
167 }
168 #endif /* 0 */
169
170 static void r200_Color3f_ub( GLfloat r, GLfloat g, GLfloat b )
171 {
172 GET_CURRENT_CONTEXT(ctx);
173 r200ContextPtr rmesa = R200_CONTEXT(ctx);
174 r200_color_t *dest = rmesa->vb.colorptr;
175 UNCLAMPED_FLOAT_TO_UBYTE( dest->red, r );
176 UNCLAMPED_FLOAT_TO_UBYTE( dest->green, g );
177 UNCLAMPED_FLOAT_TO_UBYTE( dest->blue, b );
178 dest->alpha = 255;
179 }
180
181 static void r200_Color3fv_ub( const GLfloat *v )
182 {
183 GET_CURRENT_CONTEXT(ctx);
184 r200ContextPtr rmesa = R200_CONTEXT(ctx);
185 r200_color_t *dest = rmesa->vb.colorptr;
186 UNCLAMPED_FLOAT_TO_UBYTE( dest->red, v[0] );
187 UNCLAMPED_FLOAT_TO_UBYTE( dest->green, v[1] );
188 UNCLAMPED_FLOAT_TO_UBYTE( dest->blue, v[2] );
189 dest->alpha = 255;
190 }
191
192 static void r200_Color4f_ub( GLfloat r, GLfloat g, GLfloat b, GLfloat a )
193 {
194 GET_CURRENT_CONTEXT(ctx);
195 r200ContextPtr rmesa = R200_CONTEXT(ctx);
196 r200_color_t *dest = rmesa->vb.colorptr;
197 UNCLAMPED_FLOAT_TO_UBYTE( dest->red, r );
198 UNCLAMPED_FLOAT_TO_UBYTE( dest->green, g );
199 UNCLAMPED_FLOAT_TO_UBYTE( dest->blue, b );
200 UNCLAMPED_FLOAT_TO_UBYTE( dest->alpha, a );
201 }
202
203 static void r200_Color4fv_ub( const GLfloat *v )
204 {
205 GET_CURRENT_CONTEXT(ctx);
206 r200ContextPtr rmesa = R200_CONTEXT(ctx);
207 r200_color_t *dest = rmesa->vb.colorptr;
208 UNCLAMPED_FLOAT_TO_UBYTE( dest->red, v[0] );
209 UNCLAMPED_FLOAT_TO_UBYTE( dest->green, v[1] );
210 UNCLAMPED_FLOAT_TO_UBYTE( dest->blue, v[2] );
211 UNCLAMPED_FLOAT_TO_UBYTE( dest->alpha, v[3] );
212 }
213
214
215 /* Color for float color+alpha formats:
216 */
217 #if 0
218 static void r200_Color3ub_4f( GLubyte r, GLubyte g, GLubyte b )
219 {
220 GET_CURRENT_CONTEXT(ctx);
221 r200ContextPtr rmesa = R200_CONTEXT(ctx);
222 GLfloat *dest = rmesa->vb.floatcolorptr;
223 dest[0] = UBYTE_TO_FLOAT(r);
224 dest[1] = UBYTE_TO_FLOAT(g);
225 dest[2] = UBYTE_TO_FLOAT(b);
226 dest[3] = 1.0;
227 }
228
229 static void r200_Color3ubv_4f( const GLubyte *v )
230 {
231 GET_CURRENT_CONTEXT(ctx);
232 r200ContextPtr rmesa = R200_CONTEXT(ctx);
233 GLfloat *dest = rmesa->vb.floatcolorptr;
234 dest[0] = UBYTE_TO_FLOAT(v[0]);
235 dest[1] = UBYTE_TO_FLOAT(v[1]);
236 dest[2] = UBYTE_TO_FLOAT(v[2]);
237 dest[3] = 1.0;
238 }
239
240 static void r200_Color4ub_4f( GLubyte r, GLubyte g, GLubyte b, GLubyte a )
241 {
242 GET_CURRENT_CONTEXT(ctx);
243 r200ContextPtr rmesa = R200_CONTEXT(ctx);
244 GLfloat *dest = rmesa->vb.floatcolorptr;
245 dest[0] = UBYTE_TO_FLOAT(r);
246 dest[1] = UBYTE_TO_FLOAT(g);
247 dest[2] = UBYTE_TO_FLOAT(b);
248 dest[3] = UBYTE_TO_FLOAT(a);
249 }
250
251 static void r200_Color4ubv_4f( const GLubyte *v )
252 {
253 GET_CURRENT_CONTEXT(ctx);
254 r200ContextPtr rmesa = R200_CONTEXT(ctx);
255 GLfloat *dest = rmesa->vb.floatcolorptr;
256 dest[0] = UBYTE_TO_FLOAT(v[0]);
257 dest[1] = UBYTE_TO_FLOAT(v[1]);
258 dest[2] = UBYTE_TO_FLOAT(v[2]);
259 dest[3] = UBYTE_TO_FLOAT(v[3]);
260 }
261 #endif /* 0 */
262
263
264 static void r200_Color3f_4f( GLfloat r, GLfloat g, GLfloat b )
265 {
266 GET_CURRENT_CONTEXT(ctx);
267 r200ContextPtr rmesa = R200_CONTEXT(ctx);
268 GLfloat *dest = rmesa->vb.floatcolorptr;
269 dest[0] = r;
270 dest[1] = g;
271 dest[2] = b;
272 dest[3] = 1.0;
273 }
274
275 static void r200_Color3fv_4f( const GLfloat *v )
276 {
277 GET_CURRENT_CONTEXT(ctx);
278 r200ContextPtr rmesa = R200_CONTEXT(ctx);
279 GLfloat *dest = rmesa->vb.floatcolorptr;
280 dest[0] = v[0];
281 dest[1] = v[1];
282 dest[2] = v[2];
283 dest[3] = 1.0;
284 }
285
286 static void r200_Color4f_4f( GLfloat r, GLfloat g, GLfloat b, GLfloat a )
287 {
288 GET_CURRENT_CONTEXT(ctx);
289 r200ContextPtr rmesa = R200_CONTEXT(ctx);
290 GLfloat *dest = rmesa->vb.floatcolorptr;
291 dest[0] = r;
292 dest[1] = g;
293 dest[2] = b;
294 dest[3] = a;
295 }
296
297 static void r200_Color4fv_4f( const GLfloat *v )
298 {
299 GET_CURRENT_CONTEXT(ctx);
300 r200ContextPtr rmesa = R200_CONTEXT(ctx);
301 GLfloat *dest = rmesa->vb.floatcolorptr;
302 dest[0] = v[0];
303 dest[1] = v[1];
304 dest[2] = v[2];
305 dest[3] = v[3];
306 }
307
308
309 /* Color for float color formats:
310 */
311 #if 0
312 static void r200_Color3ub_3f( GLubyte r, GLubyte g, GLubyte b )
313 {
314 GET_CURRENT_CONTEXT(ctx);
315 r200ContextPtr rmesa = R200_CONTEXT(ctx);
316 GLfloat *dest = rmesa->vb.floatcolorptr;
317 dest[0] = UBYTE_TO_FLOAT(r);
318 dest[1] = UBYTE_TO_FLOAT(g);
319 dest[2] = UBYTE_TO_FLOAT(b);
320 }
321
322 static void r200_Color3ubv_3f( const GLubyte *v )
323 {
324 GET_CURRENT_CONTEXT(ctx);
325 r200ContextPtr rmesa = R200_CONTEXT(ctx);
326 GLfloat *dest = rmesa->vb.floatcolorptr;
327 dest[0] = UBYTE_TO_FLOAT(v[0]);
328 dest[1] = UBYTE_TO_FLOAT(v[1]);
329 dest[2] = UBYTE_TO_FLOAT(v[2]);
330 }
331
332 static void r200_Color4ub_3f( GLubyte r, GLubyte g, GLubyte b, GLubyte a )
333 {
334 GET_CURRENT_CONTEXT(ctx);
335 r200ContextPtr rmesa = R200_CONTEXT(ctx);
336 GLfloat *dest = rmesa->vb.floatcolorptr;
337 dest[0] = UBYTE_TO_FLOAT(r);
338 dest[1] = UBYTE_TO_FLOAT(g);
339 dest[2] = UBYTE_TO_FLOAT(b);
340 ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3] = UBYTE_TO_FLOAT(a);
341 }
342
343 static void r200_Color4ubv_3f( const GLubyte *v )
344 {
345 GET_CURRENT_CONTEXT(ctx);
346 r200ContextPtr rmesa = R200_CONTEXT(ctx);
347 GLfloat *dest = rmesa->vb.floatcolorptr;
348 dest[0] = UBYTE_TO_FLOAT(v[0]);
349 dest[1] = UBYTE_TO_FLOAT(v[1]);
350 dest[2] = UBYTE_TO_FLOAT(v[2]);
351 ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3] = UBYTE_TO_FLOAT(v[3]);
352 }
353 #endif /* 0 */
354
355
356 static void r200_Color3f_3f( GLfloat r, GLfloat g, GLfloat b )
357 {
358 GET_CURRENT_CONTEXT(ctx);
359 r200ContextPtr rmesa = R200_CONTEXT(ctx);
360 GLfloat *dest = rmesa->vb.floatcolorptr;
361 dest[0] = r;
362 dest[1] = g;
363 dest[2] = b;
364 }
365
366 static void r200_Color3fv_3f( const GLfloat *v )
367 {
368 GET_CURRENT_CONTEXT(ctx);
369 r200ContextPtr rmesa = R200_CONTEXT(ctx);
370 GLfloat *dest = rmesa->vb.floatcolorptr;
371 dest[0] = v[0];
372 dest[1] = v[1];
373 dest[2] = v[2];
374 }
375
376 static void r200_Color4f_3f( GLfloat r, GLfloat g, GLfloat b, GLfloat a )
377 {
378 GET_CURRENT_CONTEXT(ctx);
379 r200ContextPtr rmesa = R200_CONTEXT(ctx);
380 GLfloat *dest = rmesa->vb.floatcolorptr;
381 dest[0] = r;
382 dest[1] = g;
383 dest[2] = b;
384 ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3] = a;
385 }
386
387 static void r200_Color4fv_3f( const GLfloat *v )
388 {
389 GET_CURRENT_CONTEXT(ctx);
390 r200ContextPtr rmesa = R200_CONTEXT(ctx);
391 GLfloat *dest = rmesa->vb.floatcolorptr;
392 dest[0] = v[0];
393 dest[1] = v[1];
394 dest[2] = v[2];
395 ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3] = v[3];
396 }
397
398
399 /* Secondary Color:
400 */
401 #if 0
402 static void r200_SecondaryColor3ubEXT_ub( GLubyte r, GLubyte g, GLubyte b )
403 {
404 GET_CURRENT_CONTEXT(ctx);
405 r200ContextPtr rmesa = R200_CONTEXT(ctx);
406 r200_color_t *dest = rmesa->vb.specptr;
407 dest->red = r;
408 dest->green = g;
409 dest->blue = b;
410 dest->alpha = 0xff;
411 }
412
413 static void r200_SecondaryColor3ubvEXT_ub( const GLubyte *v )
414 {
415 GET_CURRENT_CONTEXT(ctx);
416 r200ContextPtr rmesa = R200_CONTEXT(ctx);
417 r200_color_t *dest = rmesa->vb.specptr;
418 dest->red = v[0];
419 dest->green = v[1];
420 dest->blue = v[2];
421 dest->alpha = 0xff;
422 }
423 #endif /* 0 */
424
425 static void r200_SecondaryColor3fEXT_ub( GLfloat r, GLfloat g, GLfloat b )
426 {
427 GET_CURRENT_CONTEXT(ctx);
428 r200ContextPtr rmesa = R200_CONTEXT(ctx);
429 r200_color_t *dest = rmesa->vb.specptr;
430 UNCLAMPED_FLOAT_TO_UBYTE( dest->red, r );
431 UNCLAMPED_FLOAT_TO_UBYTE( dest->green, g );
432 UNCLAMPED_FLOAT_TO_UBYTE( dest->blue, b );
433 dest->alpha = 255;
434 }
435
436 static void r200_SecondaryColor3fvEXT_ub( const GLfloat *v )
437 {
438 GET_CURRENT_CONTEXT(ctx);
439 r200ContextPtr rmesa = R200_CONTEXT(ctx);
440 r200_color_t *dest = rmesa->vb.specptr;
441 UNCLAMPED_FLOAT_TO_UBYTE( dest->red, v[0] );
442 UNCLAMPED_FLOAT_TO_UBYTE( dest->green, v[1] );
443 UNCLAMPED_FLOAT_TO_UBYTE( dest->blue, v[2] );
444 dest->alpha = 255;
445 }
446
447 #if 0
448 static void r200_SecondaryColor3ubEXT_3f( GLubyte r, GLubyte g, GLubyte b )
449 {
450 GET_CURRENT_CONTEXT(ctx);
451 r200ContextPtr rmesa = R200_CONTEXT(ctx);
452 GLfloat *dest = rmesa->vb.floatspecptr;
453 dest[0] = UBYTE_TO_FLOAT(r);
454 dest[1] = UBYTE_TO_FLOAT(g);
455 dest[2] = UBYTE_TO_FLOAT(b);
456 dest[3] = 1.0;
457 }
458
459 static void r200_SecondaryColor3ubvEXT_3f( const GLubyte *v )
460 {
461 GET_CURRENT_CONTEXT(ctx);
462 r200ContextPtr rmesa = R200_CONTEXT(ctx);
463 GLfloat *dest = rmesa->vb.floatspecptr;
464 dest[0] = UBYTE_TO_FLOAT(v[0]);
465 dest[1] = UBYTE_TO_FLOAT(v[1]);
466 dest[2] = UBYTE_TO_FLOAT(v[2]);
467 dest[3] = 1.0;
468 }
469 #endif /* 0 */
470
471 static void r200_SecondaryColor3fEXT_3f( GLfloat r, GLfloat g, GLfloat b )
472 {
473 GET_CURRENT_CONTEXT(ctx);
474 r200ContextPtr rmesa = R200_CONTEXT(ctx);
475 GLfloat *dest = rmesa->vb.floatspecptr;
476 dest[0] = r;
477 dest[1] = g;
478 dest[2] = b;
479 dest[3] = 1.0;
480 }
481
482 static void r200_SecondaryColor3fvEXT_3f( const GLfloat *v )
483 {
484 GET_CURRENT_CONTEXT(ctx);
485 r200ContextPtr rmesa = R200_CONTEXT(ctx);
486 GLfloat *dest = rmesa->vb.floatspecptr;
487 dest[0] = v[0];
488 dest[1] = v[1];
489 dest[2] = v[2];
490 dest[3] = 1.0;
491 }
492
493
494
495 /* Normal
496 */
497 static void r200_Normal3f( GLfloat n0, GLfloat n1, GLfloat n2 )
498 {
499 GET_CURRENT_CONTEXT(ctx);
500 r200ContextPtr rmesa = R200_CONTEXT(ctx);
501 GLfloat *dest = rmesa->vb.normalptr;
502 dest[0] = n0;
503 dest[1] = n1;
504 dest[2] = n2;
505 }
506
507 static void r200_Normal3fv( const GLfloat *v )
508 {
509 GET_CURRENT_CONTEXT(ctx);
510 r200ContextPtr rmesa = R200_CONTEXT(ctx);
511 GLfloat *dest = rmesa->vb.normalptr;
512 dest[0] = v[0];
513 dest[1] = v[1];
514 dest[2] = v[2];
515 }
516
517
518 /* FogCoord
519 */
520 static void r200_FogCoordfEXT( GLfloat f )
521 {
522 GET_CURRENT_CONTEXT(ctx);
523 r200ContextPtr rmesa = R200_CONTEXT(ctx);
524 GLfloat *dest = rmesa->vb.fogptr;
525 dest[0] = r200ComputeFogBlendFactor( ctx, f );
526 /* ctx->Current.Attrib[VERT_ATTRIB_FOG][0] = f;*/
527 }
528
529 static void r200_FogCoordfvEXT( const GLfloat *v )
530 {
531 GET_CURRENT_CONTEXT(ctx);
532 r200ContextPtr rmesa = R200_CONTEXT(ctx);
533 GLfloat *dest = rmesa->vb.fogptr;
534 dest[0] = r200ComputeFogBlendFactor( ctx, v[0] );
535 /* ctx->Current.Attrib[VERT_ATTRIB_FOG][0] = v[0];*/
536 }
537
538
539 /* TexCoord
540 */
541
542 /* \todo maybe (target & 4 ? target & 5 : target & 3) is more save than (target & 7) */
543 static void r200_MultiTexCoord1fARB(GLenum target, GLfloat s)
544 {
545 GET_CURRENT_CONTEXT(ctx);
546 r200ContextPtr rmesa = R200_CONTEXT(ctx);
547 GLint unit = (target & 7);
548 GLfloat * const dest = rmesa->vb.texcoordptr[unit];
549
550 switch( ctx->Texture.Unit[unit]._ReallyEnabled ) {
551 case TEXTURE_CUBE_BIT:
552 case TEXTURE_3D_BIT:
553 dest[2] = 0.0;
554 /* FALLTHROUGH */
555 case TEXTURE_2D_BIT:
556 case TEXTURE_RECT_BIT:
557 dest[1] = 0.0;
558 /* FALLTHROUGH */
559 case TEXTURE_1D_BIT:
560 dest[0] = s;
561 }
562 }
563
564 static void r200_MultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t)
565 {
566 GET_CURRENT_CONTEXT(ctx);
567 r200ContextPtr rmesa = R200_CONTEXT(ctx);
568 GLint unit = (target & 7);
569 GLfloat * const dest = rmesa->vb.texcoordptr[unit];
570
571 switch( ctx->Texture.Unit[unit]._ReallyEnabled ) {
572 case TEXTURE_CUBE_BIT:
573 case TEXTURE_3D_BIT:
574 dest[2] = 0.0;
575 /* FALLTHROUGH */
576 case TEXTURE_2D_BIT:
577 case TEXTURE_RECT_BIT:
578 dest[1] = t;
579 dest[0] = s;
580 break;
581 default:
582 VFMT_FALLBACK(__FUNCTION__);
583 CALL_MultiTexCoord2fARB(GET_DISPATCH(), (target, s, t));
584 return;
585 }
586 }
587
588 static void r200_MultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r)
589 {
590 GET_CURRENT_CONTEXT(ctx);
591 r200ContextPtr rmesa = R200_CONTEXT(ctx);
592 GLint unit = (target & 7);
593 GLfloat * const dest = rmesa->vb.texcoordptr[unit];
594
595 switch( ctx->Texture.Unit[unit]._ReallyEnabled ) {
596 case TEXTURE_CUBE_BIT:
597 case TEXTURE_3D_BIT:
598 dest[2] = r;
599 dest[1] = t;
600 dest[0] = s;
601 break;
602 default:
603 VFMT_FALLBACK(__FUNCTION__);
604 CALL_MultiTexCoord3fARB(GET_DISPATCH(), (target, s, t, r));
605 return;
606 }
607 }
608
609 static void r200_TexCoord1f(GLfloat s)
610 {
611 r200_MultiTexCoord1fARB(GL_TEXTURE0, s);
612 }
613
614 static void r200_TexCoord2f(GLfloat s, GLfloat t)
615 {
616 r200_MultiTexCoord2fARB(GL_TEXTURE0, s, t);
617 }
618
619 static void r200_TexCoord3f(GLfloat s, GLfloat t, GLfloat r)
620 {
621 r200_MultiTexCoord3fARB(GL_TEXTURE0, s, t, r);
622 }
623
624 static void r200_TexCoord1fv(const GLfloat *v)
625 {
626 r200_MultiTexCoord1fARB(GL_TEXTURE0, v[0]);
627 }
628
629 static void r200_TexCoord2fv(const GLfloat *v)
630 {
631 r200_MultiTexCoord2fARB(GL_TEXTURE0, v[0], v[1]);
632 }
633
634 static void r200_TexCoord3fv(const GLfloat *v)
635 {
636 r200_MultiTexCoord3fARB(GL_TEXTURE0, v[0], v[1], v[2]);
637 }
638
639 static void r200_MultiTexCoord1fvARB(GLenum target, const GLfloat *v)
640 {
641 r200_MultiTexCoord1fARB(target, v[0]);
642 }
643
644 static void r200_MultiTexCoord2fvARB(GLenum target, const GLfloat *v)
645 {
646 r200_MultiTexCoord2fARB(target, v[0], v[1]);
647 }
648
649 static void r200_MultiTexCoord3fvARB(GLenum target, const GLfloat *v)
650 {
651 r200_MultiTexCoord3fARB(target, v[0], v[1], v[2]);
652 }
653
654
655 static struct dynfn *lookup( struct dynfn *l, const int *key )
656 {
657 struct dynfn *f;
658
659 foreach( f, l ) {
660 if (f->key[0] == key[0] && f->key[1] == key[1])
661 return f;
662 }
663
664 return NULL;
665 }
666
667 /* Can't use the loopback template for this:
668 */
669
670 #define CHOOSE(FN, FNTYPE, MASK0, MASK1, ARGS1, ARGS2 ) \
671 static void choose_##FN ARGS1 \
672 { \
673 GET_CURRENT_CONTEXT(ctx); \
674 r200ContextPtr rmesa = R200_CONTEXT(ctx); \
675 int key[2]; \
676 struct dynfn *dfn; \
677 \
678 key[0] = rmesa->vb.vtxfmt_0 & MASK0; \
679 key[1] = rmesa->vb.vtxfmt_1 & MASK1; \
680 \
681 dfn = lookup( &rmesa->vb.dfn_cache.FN, key ); \
682 if (dfn == 0) \
683 dfn = rmesa->vb.codegen.FN( ctx, key ); \
684 else if (R200_DEBUG & DEBUG_CODEGEN) \
685 fprintf(stderr, "%s -- cached codegen\n", __FUNCTION__ ); \
686 \
687 if (dfn) \
688 SET_ ## FN (ctx->Exec, (FNTYPE)(dfn->code)); \
689 else { \
690 if (R200_DEBUG & DEBUG_CODEGEN) \
691 fprintf(stderr, "%s -- generic version\n", __FUNCTION__ ); \
692 SET_ ## FN (ctx->Exec, r200_##FN); \
693 } \
694 \
695 ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT; \
696 CALL_ ## FN (ctx->Exec, ARGS2); \
697 }
698
699
700
701 /* For the _3f case, only allow one color function to be hooked in at
702 * a time. Eventually, use a similar mechanism to allow selecting the
703 * color component of the vertex format based on client behaviour.
704 *
705 * Note: Perform these actions even if there is a codegen or cached
706 * codegen version of the chosen function.
707 */
708 #define CHOOSE_COLOR(FN, FNTYPE, NR, MASK0, MASK1, ARGS1, ARGS2 ) \
709 static void choose_##FN ARGS1 \
710 { \
711 GET_CURRENT_CONTEXT(ctx); \
712 r200ContextPtr rmesa = R200_CONTEXT(ctx); \
713 int key[2]; \
714 struct dynfn *dfn; \
715 \
716 key[0] = rmesa->vb.vtxfmt_0 & MASK0; \
717 key[1] = rmesa->vb.vtxfmt_1 & MASK1; \
718 \
719 if (VTX_COLOR(rmesa->vb.vtxfmt_0,0) == R200_VTX_PK_RGBA) { \
720 SET_ ## FN (ctx->Exec, r200_##FN##_ub); \
721 } \
722 else if (VTX_COLOR(rmesa->vb.vtxfmt_0,0) == R200_VTX_FP_RGB) { \
723 \
724 if (rmesa->vb.installed_color_3f_sz != NR) { \
725 rmesa->vb.installed_color_3f_sz = NR; \
726 if (NR == 3) ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3] = 1.0; \
727 if (ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT) { \
728 r200_copy_to_current( ctx ); \
729 _mesa_install_exec_vtxfmt( ctx, &rmesa->vb.vtxfmt ); \
730 CALL_ ## FN (ctx->Exec, ARGS2); \
731 return; \
732 } \
733 } \
734 \
735 SET_ ## FN (ctx->Exec, r200_##FN##_3f); \
736 } \
737 else { \
738 SET_ ## FN (ctx->Exec, r200_##FN##_4f); \
739 } \
740 \
741 \
742 dfn = lookup( &rmesa->vb.dfn_cache.FN, key ); \
743 if (!dfn) dfn = rmesa->vb.codegen.FN( ctx, key ); \
744 \
745 if (dfn) { \
746 if (R200_DEBUG & DEBUG_CODEGEN) \
747 fprintf(stderr, "%s -- codegen version\n", __FUNCTION__ ); \
748 SET_ ## FN (ctx->Exec, (FNTYPE)dfn->code); \
749 } \
750 else if (R200_DEBUG & DEBUG_CODEGEN) \
751 fprintf(stderr, "%s -- 'c' version\n", __FUNCTION__ ); \
752 \
753 ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT; \
754 CALL_ ## FN (ctx->Exec, ARGS2); \
755 }
756
757
758
759 /* Right now there are both _ub and _3f versions of the secondary color
760 * functions. Currently, we only set-up the hardware to use the _ub versions.
761 * The _3f versions are needed for the cases where secondary color isn't used
762 * in the vertex format, but it still needs to be stored in the context
763 * state vector.
764 */
765 #define CHOOSE_SECONDARY_COLOR(FN, FNTYPE, MASK0, MASK1, ARGS1, ARGS2 ) \
766 static void choose_##FN ARGS1 \
767 { \
768 GET_CURRENT_CONTEXT(ctx); \
769 r200ContextPtr rmesa = R200_CONTEXT(ctx); \
770 int key[2]; \
771 struct dynfn *dfn; \
772 \
773 key[0] = rmesa->vb.vtxfmt_0 & MASK0; \
774 key[1] = rmesa->vb.vtxfmt_1 & MASK1; \
775 \
776 dfn = lookup( &rmesa->vb.dfn_cache.FN, key ); \
777 if (dfn == 0) \
778 dfn = rmesa->vb.codegen.FN( ctx, key ); \
779 else if (R200_DEBUG & DEBUG_CODEGEN) \
780 fprintf(stderr, "%s -- cached version\n", __FUNCTION__ ); \
781 \
782 if (dfn) \
783 SET_ ## FN (ctx->Exec, (FNTYPE)(dfn->code)); \
784 else { \
785 if (R200_DEBUG & DEBUG_CODEGEN) \
786 fprintf(stderr, "%s -- generic version\n", __FUNCTION__ ); \
787 SET_ ## FN (ctx->Exec, (VTX_COLOR(rmesa->vb.vtxfmt_0,1) == R200_VTX_PK_RGBA) \
788 ? r200_##FN##_ub : r200_##FN##_3f); \
789 } \
790 \
791 ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT; \
792 CALL_ ## FN (ctx->Exec, ARGS2); \
793 }
794
795
796
797
798
799
800
801 /* VTXFMT_0
802 */
803 #define MASK_XYZW (R200_VTX_W0|R200_VTX_Z0)
804 #define MASK_NORM (MASK_XYZW|R200_VTX_N0)
805 #define MASK_FOG (MASK_NORM |R200_VTX_DISCRETE_FOG)
806 #define MASK_COLOR (MASK_FOG |(R200_VTX_COLOR_MASK<<R200_VTX_COLOR_0_SHIFT))
807 #define MASK_SPEC (MASK_COLOR|(R200_VTX_COLOR_MASK<<R200_VTX_COLOR_1_SHIFT))
808
809 /* VTXFMT_1
810 */
811 #define MASK_ST0 (0x7 << R200_VTX_TEX0_COMP_CNT_SHIFT)
812 /* FIXME: maybe something like in the radeon driver is needed here? */
813
814
815 typedef void (*p4f)( GLfloat, GLfloat, GLfloat, GLfloat );
816 typedef void (*p3f)( GLfloat, GLfloat, GLfloat );
817 typedef void (*p2f)( GLfloat, GLfloat );
818 typedef void (*p1f)( GLfloat );
819 typedef void (*pe3f)( GLenum, GLfloat, GLfloat, GLfloat );
820 typedef void (*pe2f)( GLenum, GLfloat, GLfloat );
821 typedef void (*pe1f)( GLenum, GLfloat );
822 typedef void (*p4ub)( GLubyte, GLubyte, GLubyte, GLubyte );
823 typedef void (*p3ub)( GLubyte, GLubyte, GLubyte );
824 typedef void (*pfv)( const GLfloat * );
825 typedef void (*pefv)( GLenum, const GLfloat * );
826 typedef void (*pubv)( const GLubyte * );
827
828
829 CHOOSE(Normal3f, p3f, MASK_NORM, 0,
830 (GLfloat a,GLfloat b,GLfloat c), (a,b,c))
831 CHOOSE(Normal3fv, pfv, MASK_NORM, 0,
832 (const GLfloat *v), (v))
833
834 #if 0
835 CHOOSE_COLOR(Color4ub, p4ub, 4, MASK_COLOR, 0,
836 (GLubyte a,GLubyte b, GLubyte c, GLubyte d), (a,b,c,d))
837 CHOOSE_COLOR(Color4ubv, pubv, 4, MASK_COLOR, 0,
838 (const GLubyte *v), (v))
839 CHOOSE_COLOR(Color3ub, p3ub, 3, MASK_COLOR, 0,
840 (GLubyte a,GLubyte b, GLubyte c), (a,b,c))
841 CHOOSE_COLOR(Color3ubv, pubv, 3, MASK_COLOR, 0,
842 (const GLubyte *v), (v))
843 CHOOSE_SECONDARY_COLOR(SecondaryColor3ubEXT, p3ub, MASK_SPEC, 0,
844 (GLubyte a,GLubyte b, GLubyte c), (a,b,c))
845 CHOOSE_SECONDARY_COLOR(SecondaryColor3ubvEXT, pubv, MASK_SPEC, 0,
846 (const GLubyte *v), (v))
847 #endif
848
849 CHOOSE_COLOR(Color4f, p4f, 4, MASK_COLOR, 0,
850 (GLfloat a,GLfloat b, GLfloat c, GLfloat d), (a,b,c,d))
851 CHOOSE_COLOR(Color4fv, pfv, 4, MASK_COLOR, 0,
852 (const GLfloat *v), (v))
853 CHOOSE_COLOR(Color3f, p3f, 3, MASK_COLOR, 0,
854 (GLfloat a,GLfloat b, GLfloat c), (a,b,c))
855 CHOOSE_COLOR(Color3fv, pfv, 3, MASK_COLOR, 0,
856 (const GLfloat *v), (v))
857
858
859 CHOOSE_SECONDARY_COLOR(SecondaryColor3fEXT, p3f, MASK_SPEC, 0,
860 (GLfloat a,GLfloat b, GLfloat c), (a,b,c))
861 CHOOSE_SECONDARY_COLOR(SecondaryColor3fvEXT, pfv, MASK_SPEC, 0,
862 (const GLfloat *v), (v))
863
864 CHOOSE(TexCoord3f, p3f, ~0, MASK_ST0,
865 (GLfloat a,GLfloat b,GLfloat c), (a,b,c))
866 CHOOSE(TexCoord3fv, pfv, ~0, MASK_ST0,
867 (const GLfloat *v), (v))
868 CHOOSE(TexCoord2f, p2f, ~0, MASK_ST0,
869 (GLfloat a,GLfloat b), (a,b))
870 CHOOSE(TexCoord2fv, pfv, ~0, MASK_ST0,
871 (const GLfloat *v), (v))
872 CHOOSE(TexCoord1f, p1f, ~0, MASK_ST0,
873 (GLfloat a), (a))
874 CHOOSE(TexCoord1fv, pfv, ~0, MASK_ST0,
875 (const GLfloat *v), (v))
876
877 CHOOSE(MultiTexCoord3fARB, pe3f, ~0, ~0,
878 (GLenum u,GLfloat a,GLfloat b,GLfloat c), (u,a,b,c))
879 CHOOSE(MultiTexCoord3fvARB, pefv, ~0, ~0,
880 (GLenum u,const GLfloat *v), (u,v))
881 CHOOSE(MultiTexCoord2fARB, pe2f, ~0, ~0,
882 (GLenum u,GLfloat a,GLfloat b), (u,a,b))
883 CHOOSE(MultiTexCoord2fvARB, pefv, ~0, ~0,
884 (GLenum u,const GLfloat *v), (u,v))
885 CHOOSE(MultiTexCoord1fARB, pe1f, ~0, ~0,
886 (GLenum u,GLfloat a), (u,a))
887 CHOOSE(MultiTexCoord1fvARB, pefv, ~0, ~0,
888 (GLenum u,const GLfloat *v), (u,v))
889
890 CHOOSE(Vertex3f, p3f, ~0, ~0,
891 (GLfloat a,GLfloat b,GLfloat c), (a,b,c))
892 CHOOSE(Vertex3fv, pfv, ~0, ~0,
893 (const GLfloat *v), (v))
894 CHOOSE(Vertex2f, p2f, ~0, ~0,
895 (GLfloat a,GLfloat b), (a,b))
896 CHOOSE(Vertex2fv, pfv, ~0, ~0,
897 (const GLfloat *v), (v))
898
899 CHOOSE(FogCoordfEXT, p1f, MASK_FOG, ~0,
900 (GLfloat f), (f))
901 CHOOSE(FogCoordfvEXT, pfv, MASK_FOG, ~0,
902 (const GLfloat *f), (f))
903
904
905
906
907 void r200VtxfmtInitChoosers( GLvertexformat *vfmt )
908 {
909 vfmt->Color3f = choose_Color3f;
910 vfmt->Color3fv = choose_Color3fv;
911 vfmt->Color4f = choose_Color4f;
912 vfmt->Color4fv = choose_Color4fv;
913 vfmt->SecondaryColor3fEXT = choose_SecondaryColor3fEXT;
914 vfmt->SecondaryColor3fvEXT = choose_SecondaryColor3fvEXT;
915 vfmt->MultiTexCoord1fARB = choose_MultiTexCoord1fARB;
916 vfmt->MultiTexCoord1fvARB = choose_MultiTexCoord1fvARB;
917 vfmt->MultiTexCoord2fARB = choose_MultiTexCoord2fARB;
918 vfmt->MultiTexCoord2fvARB = choose_MultiTexCoord2fvARB;
919 vfmt->MultiTexCoord3fARB = choose_MultiTexCoord3fARB;
920 vfmt->MultiTexCoord3fvARB = choose_MultiTexCoord3fvARB;
921 vfmt->Normal3f = choose_Normal3f;
922 vfmt->Normal3fv = choose_Normal3fv;
923 vfmt->TexCoord1f = choose_TexCoord1f;
924 vfmt->TexCoord1fv = choose_TexCoord1fv;
925 vfmt->TexCoord2f = choose_TexCoord2f;
926 vfmt->TexCoord2fv = choose_TexCoord2fv;
927 vfmt->TexCoord3f = choose_TexCoord3f;
928 vfmt->TexCoord3fv = choose_TexCoord3fv;
929 vfmt->Vertex2f = choose_Vertex2f;
930 vfmt->Vertex2fv = choose_Vertex2fv;
931 vfmt->Vertex3f = choose_Vertex3f;
932 vfmt->Vertex3fv = choose_Vertex3fv;
933 /* vfmt->FogCoordfEXT = choose_FogCoordfEXT;
934 vfmt->FogCoordfvEXT = choose_FogCoordfvEXT;*/
935
936 /* TODO: restore ubyte colors to vtxfmt.
937 */
938 #if 0
939 vfmt->Color3ub = choose_Color3ub;
940 vfmt->Color3ubv = choose_Color3ubv;
941 vfmt->Color4ub = choose_Color4ub;
942 vfmt->Color4ubv = choose_Color4ubv;
943 vfmt->SecondaryColor3ubEXT = choose_SecondaryColor3ubEXT;
944 vfmt->SecondaryColor3ubvEXT = choose_SecondaryColor3ubvEXT;
945 #endif
946 }
947
948
949 static struct dynfn *codegen_noop( GLcontext *ctx, const int *key )
950 {
951 (void) ctx; (void) key;
952 return NULL;
953 }
954
955 void r200InitCodegen( struct dfn_generators *gen, GLboolean useCodegen )
956 {
957 gen->Vertex3f = codegen_noop;
958 gen->Vertex3fv = codegen_noop;
959 gen->Color4ub = codegen_noop;
960 gen->Color4ubv = codegen_noop;
961 gen->Normal3f = codegen_noop;
962 gen->Normal3fv = codegen_noop;
963
964 gen->TexCoord3f = codegen_noop;
965 gen->TexCoord3fv = codegen_noop;
966 gen->TexCoord2f = codegen_noop;
967 gen->TexCoord2fv = codegen_noop;
968 gen->TexCoord1f = codegen_noop;
969 gen->TexCoord1fv = codegen_noop;
970
971 gen->MultiTexCoord3fARB = codegen_noop;
972 gen->MultiTexCoord3fvARB = codegen_noop;
973 gen->MultiTexCoord2fARB = codegen_noop;
974 gen->MultiTexCoord2fvARB = codegen_noop;
975 gen->MultiTexCoord1fARB = codegen_noop;
976 gen->MultiTexCoord1fvARB = codegen_noop;
977 /* gen->FogCoordfEXT = codegen_noop;
978 gen->FogCoordfvEXT = codegen_noop;*/
979
980 gen->Vertex2f = codegen_noop;
981 gen->Vertex2fv = codegen_noop;
982 gen->Color3ub = codegen_noop;
983 gen->Color3ubv = codegen_noop;
984 gen->Color4f = codegen_noop;
985 gen->Color4fv = codegen_noop;
986 gen->Color3f = codegen_noop;
987 gen->Color3fv = codegen_noop;
988 gen->SecondaryColor3fEXT = codegen_noop;
989 gen->SecondaryColor3fvEXT = codegen_noop;
990 gen->SecondaryColor3ubEXT = codegen_noop;
991 gen->SecondaryColor3ubvEXT = codegen_noop;
992
993 if (useCodegen) {
994 #if defined(USE_X86_ASM)
995 r200InitX86Codegen( gen );
996 #endif
997
998 #if defined(USE_SSE_ASM)
999 r200InitSSECodegen( gen );
1000 #endif
1001 }
1002 }