1 /* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_vtxfmt_c.c,v 1.2 2002/12/16 16:18:56 dawes Exp $ */
3 Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.
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.
9 Permission is hereby granted, free of charge, to any person obtaining
10 a copy of this software and associated documentation files (the
11 "Software"), to deal in the Software without restriction, including
12 without limitation the rights to use, copy, modify, merge, publish,
13 distribute, sublicense, and/or sell copies of the Software, and to
14 permit persons to whom the Software is furnished to do so, subject to
15 the following conditions:
17 The above copyright notice and this permission notice (including the
18 next paragraph) shall be included in all copies or substantial
19 portions of the Software.
21 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
22 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
23 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
24 IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
25 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
26 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
27 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 **************************************************************************/
33 * Keith Whitwell <keith@tungstengraphics.com>
40 #include "simple_list.h"
44 #include "r200_vtxfmt.h"
47 /* Fallback versions of all the entrypoints for situations where
48 * codegen isn't available. This is still a lot faster than the
49 * vb/pipeline implementation in Mesa.
51 static void r200_Vertex3f( GLfloat x
, GLfloat y
, GLfloat z
)
53 GET_CURRENT_CONTEXT(ctx
);
54 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
57 *rmesa
->vb
.dmaptr
++ = *(int *)&x
;
58 *rmesa
->vb
.dmaptr
++ = *(int *)&y
;
59 *rmesa
->vb
.dmaptr
++ = *(int *)&z
;
61 for (i
= 3; i
< rmesa
->vb
.vertex_size
; i
++)
62 *rmesa
->vb
.dmaptr
++ = rmesa
->vb
.vertex
[i
].i
;
64 if (--rmesa
->vb
.counter
== 0)
69 static void r200_Vertex3fv( const GLfloat
*v
)
71 GET_CURRENT_CONTEXT(ctx
);
72 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
75 *rmesa
->vb
.dmaptr
++ = *(int *)&v
[0];
76 *rmesa
->vb
.dmaptr
++ = *(int *)&v
[1];
77 *rmesa
->vb
.dmaptr
++ = *(int *)&v
[2];
79 for (i
= 3; i
< rmesa
->vb
.vertex_size
; i
++)
80 *rmesa
->vb
.dmaptr
++ = rmesa
->vb
.vertex
[i
].i
;
82 if (--rmesa
->vb
.counter
== 0)
87 static void r200_Vertex2f( GLfloat x
, GLfloat y
)
89 GET_CURRENT_CONTEXT(ctx
);
90 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
93 *rmesa
->vb
.dmaptr
++ = *(int *)&x
;
94 *rmesa
->vb
.dmaptr
++ = *(int *)&y
;
95 *rmesa
->vb
.dmaptr
++ = 0;
97 for (i
= 3; i
< rmesa
->vb
.vertex_size
; i
++)
98 *rmesa
->vb
.dmaptr
++ = rmesa
->vb
.vertex
[i
].i
;
100 if (--rmesa
->vb
.counter
== 0)
105 static void r200_Vertex2fv( const GLfloat
*v
)
107 GET_CURRENT_CONTEXT(ctx
);
108 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
111 *rmesa
->vb
.dmaptr
++ = *(int *)&v
[0];
112 *rmesa
->vb
.dmaptr
++ = *(int *)&v
[1];
113 *rmesa
->vb
.dmaptr
++ = 0;
115 for (i
= 3; i
< rmesa
->vb
.vertex_size
; i
++)
116 *rmesa
->vb
.dmaptr
++ = rmesa
->vb
.vertex
[i
].i
;
118 if (--rmesa
->vb
.counter
== 0)
124 /* Color for ubyte (packed) color formats:
127 static void r200_Color3ub_ub( GLubyte r
, GLubyte g
, GLubyte b
)
129 GET_CURRENT_CONTEXT(ctx
);
130 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
131 r200_color_t
*dest
= rmesa
->vb
.colorptr
;
138 static void r200_Color3ubv_ub( const GLubyte
*v
)
140 GET_CURRENT_CONTEXT(ctx
);
141 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
142 r200_color_t
*dest
= rmesa
->vb
.colorptr
;
149 static void r200_Color4ub_ub( GLubyte r
, GLubyte g
, GLubyte b
, GLubyte a
)
151 GET_CURRENT_CONTEXT(ctx
);
152 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
153 r200_color_t
*dest
= rmesa
->vb
.colorptr
;
160 static void r200_Color4ubv_ub( const GLubyte
*v
)
162 GET_CURRENT_CONTEXT(ctx
);
163 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
164 *(GLuint
*)rmesa
->vb
.colorptr
= LE32_TO_CPU(*(GLuint
*)v
);
168 static void r200_Color3f_ub( GLfloat r
, GLfloat g
, GLfloat b
)
170 GET_CURRENT_CONTEXT(ctx
);
171 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
172 r200_color_t
*dest
= rmesa
->vb
.colorptr
;
173 UNCLAMPED_FLOAT_TO_UBYTE( dest
->red
, r
);
174 UNCLAMPED_FLOAT_TO_UBYTE( dest
->green
, g
);
175 UNCLAMPED_FLOAT_TO_UBYTE( dest
->blue
, b
);
179 static void r200_Color3fv_ub( const GLfloat
*v
)
181 GET_CURRENT_CONTEXT(ctx
);
182 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
183 r200_color_t
*dest
= rmesa
->vb
.colorptr
;
184 UNCLAMPED_FLOAT_TO_UBYTE( dest
->red
, v
[0] );
185 UNCLAMPED_FLOAT_TO_UBYTE( dest
->green
, v
[1] );
186 UNCLAMPED_FLOAT_TO_UBYTE( dest
->blue
, v
[2] );
190 static void r200_Color4f_ub( GLfloat r
, GLfloat g
, GLfloat b
, GLfloat a
)
192 GET_CURRENT_CONTEXT(ctx
);
193 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
194 r200_color_t
*dest
= rmesa
->vb
.colorptr
;
195 UNCLAMPED_FLOAT_TO_UBYTE( dest
->red
, r
);
196 UNCLAMPED_FLOAT_TO_UBYTE( dest
->green
, g
);
197 UNCLAMPED_FLOAT_TO_UBYTE( dest
->blue
, b
);
198 UNCLAMPED_FLOAT_TO_UBYTE( dest
->alpha
, a
);
201 static void r200_Color4fv_ub( const GLfloat
*v
)
203 GET_CURRENT_CONTEXT(ctx
);
204 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
205 r200_color_t
*dest
= rmesa
->vb
.colorptr
;
206 UNCLAMPED_FLOAT_TO_UBYTE( dest
->red
, v
[0] );
207 UNCLAMPED_FLOAT_TO_UBYTE( dest
->green
, v
[1] );
208 UNCLAMPED_FLOAT_TO_UBYTE( dest
->blue
, v
[2] );
209 UNCLAMPED_FLOAT_TO_UBYTE( dest
->alpha
, v
[3] );
213 /* Color for float color+alpha formats:
216 static void r200_Color3ub_4f( GLubyte r
, GLubyte g
, GLubyte b
)
218 GET_CURRENT_CONTEXT(ctx
);
219 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
220 GLfloat
*dest
= rmesa
->vb
.floatcolorptr
;
221 dest
[0] = UBYTE_TO_FLOAT(r
);
222 dest
[1] = UBYTE_TO_FLOAT(g
);
223 dest
[2] = UBYTE_TO_FLOAT(b
);
227 static void r200_Color3ubv_4f( const GLubyte
*v
)
229 GET_CURRENT_CONTEXT(ctx
);
230 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
231 GLfloat
*dest
= rmesa
->vb
.floatcolorptr
;
232 dest
[0] = UBYTE_TO_FLOAT(v
[0]);
233 dest
[1] = UBYTE_TO_FLOAT(v
[1]);
234 dest
[2] = UBYTE_TO_FLOAT(v
[2]);
238 static void r200_Color4ub_4f( GLubyte r
, GLubyte g
, GLubyte b
, GLubyte a
)
240 GET_CURRENT_CONTEXT(ctx
);
241 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
242 GLfloat
*dest
= rmesa
->vb
.floatcolorptr
;
243 dest
[0] = UBYTE_TO_FLOAT(r
);
244 dest
[1] = UBYTE_TO_FLOAT(g
);
245 dest
[2] = UBYTE_TO_FLOAT(b
);
246 dest
[3] = UBYTE_TO_FLOAT(a
);
249 static void r200_Color4ubv_4f( const GLubyte
*v
)
251 GET_CURRENT_CONTEXT(ctx
);
252 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
253 GLfloat
*dest
= rmesa
->vb
.floatcolorptr
;
254 dest
[0] = UBYTE_TO_FLOAT(v
[0]);
255 dest
[1] = UBYTE_TO_FLOAT(v
[1]);
256 dest
[2] = UBYTE_TO_FLOAT(v
[2]);
257 dest
[3] = UBYTE_TO_FLOAT(v
[3]);
262 static void r200_Color3f_4f( GLfloat r
, GLfloat g
, GLfloat b
)
264 GET_CURRENT_CONTEXT(ctx
);
265 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
266 GLfloat
*dest
= rmesa
->vb
.floatcolorptr
;
273 static void r200_Color3fv_4f( const GLfloat
*v
)
275 GET_CURRENT_CONTEXT(ctx
);
276 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
277 GLfloat
*dest
= rmesa
->vb
.floatcolorptr
;
284 static void r200_Color4f_4f( GLfloat r
, GLfloat g
, GLfloat b
, GLfloat a
)
286 GET_CURRENT_CONTEXT(ctx
);
287 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
288 GLfloat
*dest
= rmesa
->vb
.floatcolorptr
;
295 static void r200_Color4fv_4f( const GLfloat
*v
)
297 GET_CURRENT_CONTEXT(ctx
);
298 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
299 GLfloat
*dest
= rmesa
->vb
.floatcolorptr
;
307 /* Color for float color formats:
310 static void r200_Color3ub_3f( GLubyte r
, GLubyte g
, GLubyte b
)
312 GET_CURRENT_CONTEXT(ctx
);
313 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
314 GLfloat
*dest
= rmesa
->vb
.floatcolorptr
;
315 dest
[0] = UBYTE_TO_FLOAT(r
);
316 dest
[1] = UBYTE_TO_FLOAT(g
);
317 dest
[2] = UBYTE_TO_FLOAT(b
);
320 static void r200_Color3ubv_3f( const GLubyte
*v
)
322 GET_CURRENT_CONTEXT(ctx
);
323 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
324 GLfloat
*dest
= rmesa
->vb
.floatcolorptr
;
325 dest
[0] = UBYTE_TO_FLOAT(v
[0]);
326 dest
[1] = UBYTE_TO_FLOAT(v
[1]);
327 dest
[2] = UBYTE_TO_FLOAT(v
[2]);
330 static void r200_Color4ub_3f( GLubyte r
, GLubyte g
, GLubyte b
, GLubyte a
)
332 GET_CURRENT_CONTEXT(ctx
);
333 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
334 GLfloat
*dest
= rmesa
->vb
.floatcolorptr
;
335 dest
[0] = UBYTE_TO_FLOAT(r
);
336 dest
[1] = UBYTE_TO_FLOAT(g
);
337 dest
[2] = UBYTE_TO_FLOAT(b
);
338 ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][3] = UBYTE_TO_FLOAT(a
);
341 static void r200_Color4ubv_3f( const GLubyte
*v
)
343 GET_CURRENT_CONTEXT(ctx
);
344 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
345 GLfloat
*dest
= rmesa
->vb
.floatcolorptr
;
346 dest
[0] = UBYTE_TO_FLOAT(v
[0]);
347 dest
[1] = UBYTE_TO_FLOAT(v
[1]);
348 dest
[2] = UBYTE_TO_FLOAT(v
[2]);
349 ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][3] = UBYTE_TO_FLOAT(v
[3]);
354 static void r200_Color3f_3f( GLfloat r
, GLfloat g
, GLfloat b
)
356 GET_CURRENT_CONTEXT(ctx
);
357 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
358 GLfloat
*dest
= rmesa
->vb
.floatcolorptr
;
364 static void r200_Color3fv_3f( const GLfloat
*v
)
366 GET_CURRENT_CONTEXT(ctx
);
367 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
368 GLfloat
*dest
= rmesa
->vb
.floatcolorptr
;
374 static void r200_Color4f_3f( GLfloat r
, GLfloat g
, GLfloat b
, GLfloat a
)
376 GET_CURRENT_CONTEXT(ctx
);
377 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
378 GLfloat
*dest
= rmesa
->vb
.floatcolorptr
;
382 ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][3] = a
;
385 static void r200_Color4fv_3f( const GLfloat
*v
)
387 GET_CURRENT_CONTEXT(ctx
);
388 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
389 GLfloat
*dest
= rmesa
->vb
.floatcolorptr
;
393 ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][3] = v
[3];
400 static void r200_SecondaryColor3ubEXT_ub( GLubyte r
, GLubyte g
, GLubyte b
)
402 GET_CURRENT_CONTEXT(ctx
);
403 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
404 r200_color_t
*dest
= rmesa
->vb
.specptr
;
411 static void r200_SecondaryColor3ubvEXT_ub( const GLubyte
*v
)
413 GET_CURRENT_CONTEXT(ctx
);
414 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
415 r200_color_t
*dest
= rmesa
->vb
.specptr
;
423 static void r200_SecondaryColor3fEXT_ub( GLfloat r
, GLfloat g
, GLfloat b
)
425 GET_CURRENT_CONTEXT(ctx
);
426 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
427 r200_color_t
*dest
= rmesa
->vb
.specptr
;
428 UNCLAMPED_FLOAT_TO_UBYTE( dest
->red
, r
);
429 UNCLAMPED_FLOAT_TO_UBYTE( dest
->green
, g
);
430 UNCLAMPED_FLOAT_TO_UBYTE( dest
->blue
, b
);
434 static void r200_SecondaryColor3fvEXT_ub( const GLfloat
*v
)
436 GET_CURRENT_CONTEXT(ctx
);
437 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
438 r200_color_t
*dest
= rmesa
->vb
.specptr
;
439 UNCLAMPED_FLOAT_TO_UBYTE( dest
->red
, v
[0] );
440 UNCLAMPED_FLOAT_TO_UBYTE( dest
->green
, v
[1] );
441 UNCLAMPED_FLOAT_TO_UBYTE( dest
->blue
, v
[2] );
446 static void r200_SecondaryColor3ubEXT_3f( GLubyte r
, GLubyte g
, GLubyte b
)
448 GET_CURRENT_CONTEXT(ctx
);
449 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
450 GLfloat
*dest
= rmesa
->vb
.floatspecptr
;
451 dest
[0] = UBYTE_TO_FLOAT(r
);
452 dest
[1] = UBYTE_TO_FLOAT(g
);
453 dest
[2] = UBYTE_TO_FLOAT(b
);
457 static void r200_SecondaryColor3ubvEXT_3f( const GLubyte
*v
)
459 GET_CURRENT_CONTEXT(ctx
);
460 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
461 GLfloat
*dest
= rmesa
->vb
.floatspecptr
;
462 dest
[0] = UBYTE_TO_FLOAT(v
[0]);
463 dest
[1] = UBYTE_TO_FLOAT(v
[1]);
464 dest
[2] = UBYTE_TO_FLOAT(v
[2]);
469 static void r200_SecondaryColor3fEXT_3f( GLfloat r
, GLfloat g
, GLfloat b
)
471 GET_CURRENT_CONTEXT(ctx
);
472 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
473 GLfloat
*dest
= rmesa
->vb
.floatspecptr
;
480 static void r200_SecondaryColor3fvEXT_3f( const GLfloat
*v
)
482 GET_CURRENT_CONTEXT(ctx
);
483 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
484 GLfloat
*dest
= rmesa
->vb
.floatspecptr
;
495 static void r200_Normal3f( GLfloat n0
, GLfloat n1
, GLfloat n2
)
497 GET_CURRENT_CONTEXT(ctx
);
498 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
499 GLfloat
*dest
= rmesa
->vb
.normalptr
;
505 static void r200_Normal3fv( const GLfloat
*v
)
507 GET_CURRENT_CONTEXT(ctx
);
508 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
509 GLfloat
*dest
= rmesa
->vb
.normalptr
;
518 static void r200_FogCoordfEXT( GLfloat f
)
520 GET_CURRENT_CONTEXT(ctx
);
521 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
522 GLfloat
*dest
= rmesa
->vb
.fogptr
;
523 dest
[0] = r200ComputeFogBlendFactor( ctx
, f
);
524 /* ctx->Current.Attrib[VERT_ATTRIB_FOG][0] = f;*/
527 static void r200_FogCoordfvEXT( const GLfloat
*v
)
529 GET_CURRENT_CONTEXT(ctx
);
530 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
531 GLfloat
*dest
= rmesa
->vb
.fogptr
;
532 dest
[0] = r200ComputeFogBlendFactor( ctx
, v
[0] );
533 /* ctx->Current.Attrib[VERT_ATTRIB_FOG][0] = v[0];*/
540 /* \todo maybe (target & 4 ? target & 5 : target & 3) is more save than (target & 7) */
541 static void r200_MultiTexCoord1fARB(GLenum target
, GLfloat s
)
543 GET_CURRENT_CONTEXT(ctx
);
544 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
545 GLint unit
= (target
& 7);
546 GLfloat
* const dest
= rmesa
->vb
.texcoordptr
[unit
];
548 switch( ctx
->Texture
.Unit
[unit
]._ReallyEnabled
) {
549 case TEXTURE_CUBE_BIT
:
554 case TEXTURE_RECT_BIT
:
562 static void r200_MultiTexCoord2fARB(GLenum target
, GLfloat s
, GLfloat t
)
564 GET_CURRENT_CONTEXT(ctx
);
565 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
566 GLint unit
= (target
& 7);
567 GLfloat
* const dest
= rmesa
->vb
.texcoordptr
[unit
];
569 switch( ctx
->Texture
.Unit
[unit
]._ReallyEnabled
) {
570 case TEXTURE_CUBE_BIT
:
575 case TEXTURE_RECT_BIT
:
580 VFMT_FALLBACK(__FUNCTION__
);
581 GL_CALL(MultiTexCoord2fARB
)(target
, s
, t
);
586 static void r200_MultiTexCoord3fARB(GLenum target
, GLfloat s
, GLfloat t
, GLfloat r
)
588 GET_CURRENT_CONTEXT(ctx
);
589 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
590 GLint unit
= (target
& 7);
591 GLfloat
* const dest
= rmesa
->vb
.texcoordptr
[unit
];
593 switch( ctx
->Texture
.Unit
[unit
]._ReallyEnabled
) {
594 case TEXTURE_CUBE_BIT
:
601 VFMT_FALLBACK(__FUNCTION__
);
602 GL_CALL(MultiTexCoord3fARB
)(target
, s
, t
, r
);
607 static void r200_TexCoord1f(GLfloat s
)
609 r200_MultiTexCoord1fARB(GL_TEXTURE0
, s
);
612 static void r200_TexCoord2f(GLfloat s
, GLfloat t
)
614 r200_MultiTexCoord2fARB(GL_TEXTURE0
, s
, t
);
617 static void r200_TexCoord3f(GLfloat s
, GLfloat t
, GLfloat r
)
619 r200_MultiTexCoord3fARB(GL_TEXTURE0
, s
, t
, r
);
622 static void r200_TexCoord1fv(const GLfloat
*v
)
624 r200_MultiTexCoord1fARB(GL_TEXTURE0
, v
[0]);
627 static void r200_TexCoord2fv(const GLfloat
*v
)
629 r200_MultiTexCoord2fARB(GL_TEXTURE0
, v
[0], v
[1]);
632 static void r200_TexCoord3fv(const GLfloat
*v
)
634 r200_MultiTexCoord3fARB(GL_TEXTURE0
, v
[0], v
[1], v
[2]);
637 static void r200_MultiTexCoord1fvARB(GLenum target
, const GLfloat
*v
)
639 r200_MultiTexCoord1fARB(target
, v
[0]);
642 static void r200_MultiTexCoord2fvARB(GLenum target
, const GLfloat
*v
)
644 r200_MultiTexCoord2fARB(target
, v
[0], v
[1]);
647 static void r200_MultiTexCoord3fvARB(GLenum target
, const GLfloat
*v
)
649 r200_MultiTexCoord3fARB(target
, v
[0], v
[1], v
[2]);
653 static struct dynfn
*lookup( struct dynfn
*l
, const int *key
)
658 if (f
->key
[0] == key
[0] && f
->key
[1] == key
[1])
665 /* Can't use the loopback template for this:
668 #define CHOOSE(FN, FNTYPE, MASK0, MASK1, ARGS1, ARGS2 ) \
669 static void choose_##FN ARGS1 \
671 GET_CURRENT_CONTEXT(ctx); \
672 r200ContextPtr rmesa = R200_CONTEXT(ctx); \
676 key[0] = rmesa->vb.vtxfmt_0 & MASK0; \
677 key[1] = rmesa->vb.vtxfmt_1 & MASK1; \
679 dfn = lookup( &rmesa->vb.dfn_cache.FN, key ); \
681 dfn = rmesa->vb.codegen.FN( ctx, key ); \
682 else if (R200_DEBUG & DEBUG_CODEGEN) \
683 fprintf(stderr, "%s -- cached codegen\n", __FUNCTION__ ); \
686 ctx->Exec->FN = (FNTYPE)(dfn->code); \
688 if (R200_DEBUG & DEBUG_CODEGEN) \
689 fprintf(stderr, "%s -- generic version\n", __FUNCTION__ ); \
690 ctx->Exec->FN = r200_##FN; \
693 ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT; \
694 ctx->Exec->FN ARGS2; \
699 /* For the _3f case, only allow one color function to be hooked in at
700 * a time. Eventually, use a similar mechanism to allow selecting the
701 * color component of the vertex format based on client behaviour.
703 * Note: Perform these actions even if there is a codegen or cached
704 * codegen version of the chosen function.
706 #define CHOOSE_COLOR(FN, FNTYPE, NR, MASK0, MASK1, ARGS1, ARGS2 ) \
707 static void choose_##FN ARGS1 \
709 GET_CURRENT_CONTEXT(ctx); \
710 r200ContextPtr rmesa = R200_CONTEXT(ctx); \
714 key[0] = rmesa->vb.vtxfmt_0 & MASK0; \
715 key[1] = rmesa->vb.vtxfmt_1 & MASK1; \
717 if (VTX_COLOR(rmesa->vb.vtxfmt_0,0) == R200_VTX_PK_RGBA) { \
718 ctx->Exec->FN = r200_##FN##_ub; \
720 else if (VTX_COLOR(rmesa->vb.vtxfmt_0,0) == R200_VTX_FP_RGB) { \
722 if (rmesa->vb.installed_color_3f_sz != NR) { \
723 rmesa->vb.installed_color_3f_sz = NR; \
724 if (NR == 3) ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3] = 1.0; \
725 if (ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT) { \
726 r200_copy_to_current( ctx ); \
727 _mesa_install_exec_vtxfmt( ctx, &rmesa->vb.vtxfmt ); \
728 ctx->Exec->FN ARGS2; \
733 ctx->Exec->FN = r200_##FN##_3f; \
736 ctx->Exec->FN = r200_##FN##_4f; \
740 dfn = lookup( &rmesa->vb.dfn_cache.FN, key ); \
741 if (!dfn) dfn = rmesa->vb.codegen.FN( ctx, key ); \
744 if (R200_DEBUG & DEBUG_CODEGEN) \
745 fprintf(stderr, "%s -- codegen version\n", __FUNCTION__ ); \
746 ctx->Exec->FN = (FNTYPE)dfn->code; \
748 else if (R200_DEBUG & DEBUG_CODEGEN) \
749 fprintf(stderr, "%s -- 'c' version\n", __FUNCTION__ ); \
751 ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT; \
752 ctx->Exec->FN ARGS2; \
757 /* Right now there are both _ub and _3f versions of the secondary color
758 * functions. Currently, we only set-up the hardware to use the _ub versions.
759 * The _3f versions are needed for the cases where secondary color isn't used
760 * in the vertex format, but it still needs to be stored in the context
763 #define CHOOSE_SECONDARY_COLOR(FN, FNTYPE, MASK0, MASK1, ARGS1, ARGS2 ) \
764 static void choose_##FN ARGS1 \
766 GET_CURRENT_CONTEXT(ctx); \
767 r200ContextPtr rmesa = R200_CONTEXT(ctx); \
771 key[0] = rmesa->vb.vtxfmt_0 & MASK0; \
772 key[1] = rmesa->vb.vtxfmt_1 & MASK1; \
774 dfn = lookup( &rmesa->vb.dfn_cache.FN, key ); \
776 dfn = rmesa->vb.codegen.FN( ctx, key ); \
777 else if (R200_DEBUG & DEBUG_CODEGEN) \
778 fprintf(stderr, "%s -- cached version\n", __FUNCTION__ ); \
781 ctx->Exec->FN = (FNTYPE)(dfn->code); \
783 if (R200_DEBUG & DEBUG_CODEGEN) \
784 fprintf(stderr, "%s -- generic version\n", __FUNCTION__ ); \
785 ctx->Exec->FN = (VTX_COLOR(rmesa->vb.vtxfmt_0,1) == R200_VTX_PK_RGBA) \
786 ? r200_##FN##_ub : r200_##FN##_3f; \
789 ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT; \
790 ctx->Exec->FN ARGS2; \
801 #define MASK_XYZW (R200_VTX_W0|R200_VTX_Z0)
802 #define MASK_NORM (MASK_XYZW|R200_VTX_N0)
803 #define MASK_FOG (MASK_NORM |R200_VTX_DISCRETE_FOG)
804 #define MASK_COLOR (MASK_FOG |(R200_VTX_COLOR_MASK<<R200_VTX_COLOR_0_SHIFT))
805 #define MASK_SPEC (MASK_COLOR|(R200_VTX_COLOR_MASK<<R200_VTX_COLOR_1_SHIFT))
809 #define MASK_ST0 (0x7 << R200_VTX_TEX0_COMP_CNT_SHIFT)
810 /* FIXME: maybe something like in the radeon driver is needed here? */
813 typedef void (*p4f
)( GLfloat
, GLfloat
, GLfloat
, GLfloat
);
814 typedef void (*p3f
)( GLfloat
, GLfloat
, GLfloat
);
815 typedef void (*p2f
)( GLfloat
, GLfloat
);
816 typedef void (*p1f
)( GLfloat
);
817 typedef void (*pe3f
)( GLenum
, GLfloat
, GLfloat
, GLfloat
);
818 typedef void (*pe2f
)( GLenum
, GLfloat
, GLfloat
);
819 typedef void (*pe1f
)( GLenum
, GLfloat
);
820 typedef void (*p4ub
)( GLubyte
, GLubyte
, GLubyte
, GLubyte
);
821 typedef void (*p3ub
)( GLubyte
, GLubyte
, GLubyte
);
822 typedef void (*pfv
)( const GLfloat
* );
823 typedef void (*pefv
)( GLenum
, const GLfloat
* );
824 typedef void (*pubv
)( const GLubyte
* );
827 CHOOSE(Normal3f
, p3f
, MASK_NORM
, 0,
828 (GLfloat a
,GLfloat b
,GLfloat c
), (a
,b
,c
))
829 CHOOSE(Normal3fv
, pfv
, MASK_NORM
, 0,
830 (const GLfloat
*v
), (v
))
833 CHOOSE_COLOR(Color4ub
, p4ub
, 4, MASK_COLOR
, 0,
834 (GLubyte a
,GLubyte b
, GLubyte c
, GLubyte d
), (a
,b
,c
,d
))
835 CHOOSE_COLOR(Color4ubv
, pubv
, 4, MASK_COLOR
, 0,
836 (const GLubyte
*v
), (v
))
837 CHOOSE_COLOR(Color3ub
, p3ub
, 3, MASK_COLOR
, 0,
838 (GLubyte a
,GLubyte b
, GLubyte c
), (a
,b
,c
))
839 CHOOSE_COLOR(Color3ubv
, pubv
, 3, MASK_COLOR
, 0,
840 (const GLubyte
*v
), (v
))
841 CHOOSE_SECONDARY_COLOR(SecondaryColor3ubEXT
, p3ub
, MASK_SPEC
, 0,
842 (GLubyte a
,GLubyte b
, GLubyte c
), (a
,b
,c
))
843 CHOOSE_SECONDARY_COLOR(SecondaryColor3ubvEXT
, pubv
, MASK_SPEC
, 0,
844 (const GLubyte
*v
), (v
))
847 CHOOSE_COLOR(Color4f
, p4f
, 4, MASK_COLOR
, 0,
848 (GLfloat a
,GLfloat b
, GLfloat c
, GLfloat d
), (a
,b
,c
,d
))
849 CHOOSE_COLOR(Color4fv
, pfv
, 4, MASK_COLOR
, 0,
850 (const GLfloat
*v
), (v
))
851 CHOOSE_COLOR(Color3f
, p3f
, 3, MASK_COLOR
, 0,
852 (GLfloat a
,GLfloat b
, GLfloat c
), (a
,b
,c
))
853 CHOOSE_COLOR(Color3fv
, pfv
, 3, MASK_COLOR
, 0,
854 (const GLfloat
*v
), (v
))
857 CHOOSE_SECONDARY_COLOR(SecondaryColor3fEXT
, p3f
, MASK_SPEC
, 0,
858 (GLfloat a
,GLfloat b
, GLfloat c
), (a
,b
,c
))
859 CHOOSE_SECONDARY_COLOR(SecondaryColor3fvEXT
, pfv
, MASK_SPEC
, 0,
860 (const GLfloat
*v
), (v
))
862 CHOOSE(TexCoord3f
, p3f
, ~0, MASK_ST0
,
863 (GLfloat a
,GLfloat b
,GLfloat c
), (a
,b
,c
))
864 CHOOSE(TexCoord3fv
, pfv
, ~0, MASK_ST0
,
865 (const GLfloat
*v
), (v
))
866 CHOOSE(TexCoord2f
, p2f
, ~0, MASK_ST0
,
867 (GLfloat a
,GLfloat b
), (a
,b
))
868 CHOOSE(TexCoord2fv
, pfv
, ~0, MASK_ST0
,
869 (const GLfloat
*v
), (v
))
870 CHOOSE(TexCoord1f
, p1f
, ~0, MASK_ST0
,
872 CHOOSE(TexCoord1fv
, pfv
, ~0, MASK_ST0
,
873 (const GLfloat
*v
), (v
))
875 CHOOSE(MultiTexCoord3fARB
, pe3f
, ~0, ~0,
876 (GLenum u
,GLfloat a
,GLfloat b
,GLfloat c
), (u
,a
,b
,c
))
877 CHOOSE(MultiTexCoord3fvARB
, pefv
, ~0, ~0,
878 (GLenum u
,const GLfloat
*v
), (u
,v
))
879 CHOOSE(MultiTexCoord2fARB
, pe2f
, ~0, ~0,
880 (GLenum u
,GLfloat a
,GLfloat b
), (u
,a
,b
))
881 CHOOSE(MultiTexCoord2fvARB
, pefv
, ~0, ~0,
882 (GLenum u
,const GLfloat
*v
), (u
,v
))
883 CHOOSE(MultiTexCoord1fARB
, pe1f
, ~0, ~0,
884 (GLenum u
,GLfloat a
), (u
,a
))
885 CHOOSE(MultiTexCoord1fvARB
, pefv
, ~0, ~0,
886 (GLenum u
,const GLfloat
*v
), (u
,v
))
888 CHOOSE(Vertex3f
, p3f
, ~0, ~0,
889 (GLfloat a
,GLfloat b
,GLfloat c
), (a
,b
,c
))
890 CHOOSE(Vertex3fv
, pfv
, ~0, ~0,
891 (const GLfloat
*v
), (v
))
892 CHOOSE(Vertex2f
, p2f
, ~0, ~0,
893 (GLfloat a
,GLfloat b
), (a
,b
))
894 CHOOSE(Vertex2fv
, pfv
, ~0, ~0,
895 (const GLfloat
*v
), (v
))
897 CHOOSE(FogCoordfEXT
, p1f
, MASK_FOG
, ~0,
899 CHOOSE(FogCoordfvEXT
, pfv
, MASK_FOG
, ~0,
900 (const GLfloat
*f
), (f
))
905 void r200VtxfmtInitChoosers( GLvertexformat
*vfmt
)
907 vfmt
->Color3f
= choose_Color3f
;
908 vfmt
->Color3fv
= choose_Color3fv
;
909 vfmt
->Color4f
= choose_Color4f
;
910 vfmt
->Color4fv
= choose_Color4fv
;
911 vfmt
->SecondaryColor3fEXT
= choose_SecondaryColor3fEXT
;
912 vfmt
->SecondaryColor3fvEXT
= choose_SecondaryColor3fvEXT
;
913 vfmt
->MultiTexCoord1fARB
= choose_MultiTexCoord1fARB
;
914 vfmt
->MultiTexCoord1fvARB
= choose_MultiTexCoord1fvARB
;
915 vfmt
->MultiTexCoord2fARB
= choose_MultiTexCoord2fARB
;
916 vfmt
->MultiTexCoord2fvARB
= choose_MultiTexCoord2fvARB
;
917 vfmt
->MultiTexCoord3fARB
= choose_MultiTexCoord3fARB
;
918 vfmt
->MultiTexCoord3fvARB
= choose_MultiTexCoord3fvARB
;
919 vfmt
->Normal3f
= choose_Normal3f
;
920 vfmt
->Normal3fv
= choose_Normal3fv
;
921 vfmt
->TexCoord1f
= choose_TexCoord1f
;
922 vfmt
->TexCoord1fv
= choose_TexCoord1fv
;
923 vfmt
->TexCoord2f
= choose_TexCoord2f
;
924 vfmt
->TexCoord2fv
= choose_TexCoord2fv
;
925 vfmt
->TexCoord3f
= choose_TexCoord3f
;
926 vfmt
->TexCoord3fv
= choose_TexCoord3fv
;
927 vfmt
->Vertex2f
= choose_Vertex2f
;
928 vfmt
->Vertex2fv
= choose_Vertex2fv
;
929 vfmt
->Vertex3f
= choose_Vertex3f
;
930 vfmt
->Vertex3fv
= choose_Vertex3fv
;
931 /* vfmt->FogCoordfEXT = choose_FogCoordfEXT;
932 vfmt->FogCoordfvEXT = choose_FogCoordfvEXT;*/
934 /* TODO: restore ubyte colors to vtxfmt.
937 vfmt
->Color3ub
= choose_Color3ub
;
938 vfmt
->Color3ubv
= choose_Color3ubv
;
939 vfmt
->Color4ub
= choose_Color4ub
;
940 vfmt
->Color4ubv
= choose_Color4ubv
;
941 vfmt
->SecondaryColor3ubEXT
= choose_SecondaryColor3ubEXT
;
942 vfmt
->SecondaryColor3ubvEXT
= choose_SecondaryColor3ubvEXT
;
947 static struct dynfn
*codegen_noop( GLcontext
*ctx
, const int *key
)
949 (void) ctx
; (void) key
;
953 void r200InitCodegen( struct dfn_generators
*gen
, GLboolean useCodegen
)
955 gen
->Vertex3f
= codegen_noop
;
956 gen
->Vertex3fv
= codegen_noop
;
957 gen
->Color4ub
= codegen_noop
;
958 gen
->Color4ubv
= codegen_noop
;
959 gen
->Normal3f
= codegen_noop
;
960 gen
->Normal3fv
= codegen_noop
;
962 gen
->TexCoord3f
= codegen_noop
;
963 gen
->TexCoord3fv
= codegen_noop
;
964 gen
->TexCoord2f
= codegen_noop
;
965 gen
->TexCoord2fv
= codegen_noop
;
966 gen
->TexCoord1f
= codegen_noop
;
967 gen
->TexCoord1fv
= codegen_noop
;
969 gen
->MultiTexCoord3fARB
= codegen_noop
;
970 gen
->MultiTexCoord3fvARB
= codegen_noop
;
971 gen
->MultiTexCoord2fARB
= codegen_noop
;
972 gen
->MultiTexCoord2fvARB
= codegen_noop
;
973 gen
->MultiTexCoord1fARB
= codegen_noop
;
974 gen
->MultiTexCoord1fvARB
= codegen_noop
;
975 /* gen->FogCoordfEXT = codegen_noop;
976 gen->FogCoordfvEXT = codegen_noop;*/
978 gen
->Vertex2f
= codegen_noop
;
979 gen
->Vertex2fv
= codegen_noop
;
980 gen
->Color3ub
= codegen_noop
;
981 gen
->Color3ubv
= codegen_noop
;
982 gen
->Color4f
= codegen_noop
;
983 gen
->Color4fv
= codegen_noop
;
984 gen
->Color3f
= codegen_noop
;
985 gen
->Color3fv
= codegen_noop
;
986 gen
->SecondaryColor3fEXT
= codegen_noop
;
987 gen
->SecondaryColor3fvEXT
= codegen_noop
;
988 gen
->SecondaryColor3ubEXT
= codegen_noop
;
989 gen
->SecondaryColor3ubvEXT
= codegen_noop
;
992 #if defined(USE_X86_ASM)
993 r200InitX86Codegen( gen
);
996 #if defined(USE_SSE_ASM)
997 r200InitSSECodegen( gen
);