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"
46 /* Fallback versions of all the entrypoints for situations where
47 * codegen isn't available. This is still a lot faster than the
48 * vb/pipeline implementation in Mesa.
50 static void r200_Vertex3f( GLfloat x
, GLfloat y
, GLfloat z
)
52 GET_CURRENT_CONTEXT(ctx
);
53 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
56 *rmesa
->vb
.dmaptr
++ = *(int *)&x
;
57 *rmesa
->vb
.dmaptr
++ = *(int *)&y
;
58 *rmesa
->vb
.dmaptr
++ = *(int *)&z
;
60 for (i
= 3; i
< rmesa
->vb
.vertex_size
; i
++)
61 *rmesa
->vb
.dmaptr
++ = rmesa
->vb
.vertex
[i
].i
;
63 if (--rmesa
->vb
.counter
== 0)
68 static void r200_Vertex3fv( const GLfloat
*v
)
70 GET_CURRENT_CONTEXT(ctx
);
71 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
74 *rmesa
->vb
.dmaptr
++ = *(int *)&v
[0];
75 *rmesa
->vb
.dmaptr
++ = *(int *)&v
[1];
76 *rmesa
->vb
.dmaptr
++ = *(int *)&v
[2];
78 for (i
= 3; i
< rmesa
->vb
.vertex_size
; i
++)
79 *rmesa
->vb
.dmaptr
++ = rmesa
->vb
.vertex
[i
].i
;
81 if (--rmesa
->vb
.counter
== 0)
86 static void r200_Vertex2f( GLfloat x
, GLfloat y
)
88 GET_CURRENT_CONTEXT(ctx
);
89 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
92 *rmesa
->vb
.dmaptr
++ = *(int *)&x
;
93 *rmesa
->vb
.dmaptr
++ = *(int *)&y
;
94 *rmesa
->vb
.dmaptr
++ = 0;
96 for (i
= 3; i
< rmesa
->vb
.vertex_size
; i
++)
97 *rmesa
->vb
.dmaptr
++ = rmesa
->vb
.vertex
[i
].i
;
99 if (--rmesa
->vb
.counter
== 0)
104 static void r200_Vertex2fv( const GLfloat
*v
)
106 GET_CURRENT_CONTEXT(ctx
);
107 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
110 *rmesa
->vb
.dmaptr
++ = *(int *)&v
[0];
111 *rmesa
->vb
.dmaptr
++ = *(int *)&v
[1];
112 *rmesa
->vb
.dmaptr
++ = 0;
114 for (i
= 3; i
< rmesa
->vb
.vertex_size
; i
++)
115 *rmesa
->vb
.dmaptr
++ = rmesa
->vb
.vertex
[i
].i
;
117 if (--rmesa
->vb
.counter
== 0)
123 /* Color for ubyte (packed) color formats:
126 static void r200_Color3ub_ub( GLubyte r
, GLubyte g
, GLubyte b
)
128 GET_CURRENT_CONTEXT(ctx
);
129 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
130 r200_color_t
*dest
= rmesa
->vb
.colorptr
;
137 static void r200_Color3ubv_ub( const GLubyte
*v
)
139 GET_CURRENT_CONTEXT(ctx
);
140 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
141 r200_color_t
*dest
= rmesa
->vb
.colorptr
;
148 static void r200_Color4ub_ub( GLubyte r
, GLubyte g
, GLubyte b
, GLubyte a
)
150 GET_CURRENT_CONTEXT(ctx
);
151 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
152 r200_color_t
*dest
= rmesa
->vb
.colorptr
;
159 static void r200_Color4ubv_ub( const GLubyte
*v
)
161 GET_CURRENT_CONTEXT(ctx
);
162 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
163 *(GLuint
*)rmesa
->vb
.colorptr
= LE32_TO_CPU(*(GLuint
*)v
);
167 static void r200_Color3f_ub( GLfloat r
, GLfloat g
, GLfloat b
)
169 GET_CURRENT_CONTEXT(ctx
);
170 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
171 r200_color_t
*dest
= rmesa
->vb
.colorptr
;
172 UNCLAMPED_FLOAT_TO_UBYTE( dest
->red
, r
);
173 UNCLAMPED_FLOAT_TO_UBYTE( dest
->green
, g
);
174 UNCLAMPED_FLOAT_TO_UBYTE( dest
->blue
, b
);
178 static void r200_Color3fv_ub( const GLfloat
*v
)
180 GET_CURRENT_CONTEXT(ctx
);
181 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
182 r200_color_t
*dest
= rmesa
->vb
.colorptr
;
183 UNCLAMPED_FLOAT_TO_UBYTE( dest
->red
, v
[0] );
184 UNCLAMPED_FLOAT_TO_UBYTE( dest
->green
, v
[1] );
185 UNCLAMPED_FLOAT_TO_UBYTE( dest
->blue
, v
[2] );
189 static void r200_Color4f_ub( GLfloat r
, GLfloat g
, GLfloat b
, GLfloat a
)
191 GET_CURRENT_CONTEXT(ctx
);
192 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
193 r200_color_t
*dest
= rmesa
->vb
.colorptr
;
194 UNCLAMPED_FLOAT_TO_UBYTE( dest
->red
, r
);
195 UNCLAMPED_FLOAT_TO_UBYTE( dest
->green
, g
);
196 UNCLAMPED_FLOAT_TO_UBYTE( dest
->blue
, b
);
197 UNCLAMPED_FLOAT_TO_UBYTE( dest
->alpha
, a
);
200 static void r200_Color4fv_ub( const GLfloat
*v
)
202 GET_CURRENT_CONTEXT(ctx
);
203 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
204 r200_color_t
*dest
= rmesa
->vb
.colorptr
;
205 UNCLAMPED_FLOAT_TO_UBYTE( dest
->red
, v
[0] );
206 UNCLAMPED_FLOAT_TO_UBYTE( dest
->green
, v
[1] );
207 UNCLAMPED_FLOAT_TO_UBYTE( dest
->blue
, v
[2] );
208 UNCLAMPED_FLOAT_TO_UBYTE( dest
->alpha
, v
[3] );
212 /* Color for float color+alpha formats:
215 static void r200_Color3ub_4f( GLubyte r
, GLubyte g
, GLubyte b
)
217 GET_CURRENT_CONTEXT(ctx
);
218 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
219 GLfloat
*dest
= rmesa
->vb
.floatcolorptr
;
220 dest
[0] = UBYTE_TO_FLOAT(r
);
221 dest
[1] = UBYTE_TO_FLOAT(g
);
222 dest
[2] = UBYTE_TO_FLOAT(b
);
226 static void r200_Color3ubv_4f( const GLubyte
*v
)
228 GET_CURRENT_CONTEXT(ctx
);
229 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
230 GLfloat
*dest
= rmesa
->vb
.floatcolorptr
;
231 dest
[0] = UBYTE_TO_FLOAT(v
[0]);
232 dest
[1] = UBYTE_TO_FLOAT(v
[1]);
233 dest
[2] = UBYTE_TO_FLOAT(v
[2]);
237 static void r200_Color4ub_4f( GLubyte r
, GLubyte g
, GLubyte b
, GLubyte a
)
239 GET_CURRENT_CONTEXT(ctx
);
240 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
241 GLfloat
*dest
= rmesa
->vb
.floatcolorptr
;
242 dest
[0] = UBYTE_TO_FLOAT(r
);
243 dest
[1] = UBYTE_TO_FLOAT(g
);
244 dest
[2] = UBYTE_TO_FLOAT(b
);
245 dest
[3] = UBYTE_TO_FLOAT(a
);
248 static void r200_Color4ubv_4f( const GLubyte
*v
)
250 GET_CURRENT_CONTEXT(ctx
);
251 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
252 GLfloat
*dest
= rmesa
->vb
.floatcolorptr
;
253 dest
[0] = UBYTE_TO_FLOAT(v
[0]);
254 dest
[1] = UBYTE_TO_FLOAT(v
[1]);
255 dest
[2] = UBYTE_TO_FLOAT(v
[2]);
256 dest
[3] = UBYTE_TO_FLOAT(v
[3]);
261 static void r200_Color3f_4f( GLfloat r
, GLfloat g
, GLfloat b
)
263 GET_CURRENT_CONTEXT(ctx
);
264 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
265 GLfloat
*dest
= rmesa
->vb
.floatcolorptr
;
272 static void r200_Color3fv_4f( const GLfloat
*v
)
274 GET_CURRENT_CONTEXT(ctx
);
275 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
276 GLfloat
*dest
= rmesa
->vb
.floatcolorptr
;
283 static void r200_Color4f_4f( GLfloat r
, GLfloat g
, GLfloat b
, GLfloat a
)
285 GET_CURRENT_CONTEXT(ctx
);
286 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
287 GLfloat
*dest
= rmesa
->vb
.floatcolorptr
;
294 static void r200_Color4fv_4f( const GLfloat
*v
)
296 GET_CURRENT_CONTEXT(ctx
);
297 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
298 GLfloat
*dest
= rmesa
->vb
.floatcolorptr
;
306 /* Color for float color formats:
309 static void r200_Color3ub_3f( GLubyte r
, GLubyte g
, GLubyte b
)
311 GET_CURRENT_CONTEXT(ctx
);
312 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
313 GLfloat
*dest
= rmesa
->vb
.floatcolorptr
;
314 dest
[0] = UBYTE_TO_FLOAT(r
);
315 dest
[1] = UBYTE_TO_FLOAT(g
);
316 dest
[2] = UBYTE_TO_FLOAT(b
);
319 static void r200_Color3ubv_3f( const GLubyte
*v
)
321 GET_CURRENT_CONTEXT(ctx
);
322 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
323 GLfloat
*dest
= rmesa
->vb
.floatcolorptr
;
324 dest
[0] = UBYTE_TO_FLOAT(v
[0]);
325 dest
[1] = UBYTE_TO_FLOAT(v
[1]);
326 dest
[2] = UBYTE_TO_FLOAT(v
[2]);
329 static void r200_Color4ub_3f( GLubyte r
, GLubyte g
, GLubyte b
, GLubyte a
)
331 GET_CURRENT_CONTEXT(ctx
);
332 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
333 GLfloat
*dest
= rmesa
->vb
.floatcolorptr
;
334 dest
[0] = UBYTE_TO_FLOAT(r
);
335 dest
[1] = UBYTE_TO_FLOAT(g
);
336 dest
[2] = UBYTE_TO_FLOAT(b
);
337 ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][3] = UBYTE_TO_FLOAT(a
);
340 static void r200_Color4ubv_3f( const GLubyte
*v
)
342 GET_CURRENT_CONTEXT(ctx
);
343 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
344 GLfloat
*dest
= rmesa
->vb
.floatcolorptr
;
345 dest
[0] = UBYTE_TO_FLOAT(v
[0]);
346 dest
[1] = UBYTE_TO_FLOAT(v
[1]);
347 dest
[2] = UBYTE_TO_FLOAT(v
[2]);
348 ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][3] = UBYTE_TO_FLOAT(v
[3]);
353 static void r200_Color3f_3f( GLfloat r
, GLfloat g
, GLfloat b
)
355 GET_CURRENT_CONTEXT(ctx
);
356 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
357 GLfloat
*dest
= rmesa
->vb
.floatcolorptr
;
363 static void r200_Color3fv_3f( const GLfloat
*v
)
365 GET_CURRENT_CONTEXT(ctx
);
366 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
367 GLfloat
*dest
= rmesa
->vb
.floatcolorptr
;
373 static void r200_Color4f_3f( GLfloat r
, GLfloat g
, GLfloat b
, GLfloat a
)
375 GET_CURRENT_CONTEXT(ctx
);
376 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
377 GLfloat
*dest
= rmesa
->vb
.floatcolorptr
;
381 ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][3] = a
;
384 static void r200_Color4fv_3f( const GLfloat
*v
)
386 GET_CURRENT_CONTEXT(ctx
);
387 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
388 GLfloat
*dest
= rmesa
->vb
.floatcolorptr
;
392 ctx
->Current
.Attrib
[VERT_ATTRIB_COLOR0
][3] = v
[3];
399 static void r200_SecondaryColor3ubEXT_ub( GLubyte r
, GLubyte g
, GLubyte b
)
401 GET_CURRENT_CONTEXT(ctx
);
402 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
403 r200_color_t
*dest
= rmesa
->vb
.specptr
;
410 static void r200_SecondaryColor3ubvEXT_ub( const GLubyte
*v
)
412 GET_CURRENT_CONTEXT(ctx
);
413 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
414 r200_color_t
*dest
= rmesa
->vb
.specptr
;
422 static void r200_SecondaryColor3fEXT_ub( GLfloat r
, GLfloat g
, GLfloat b
)
424 GET_CURRENT_CONTEXT(ctx
);
425 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
426 r200_color_t
*dest
= rmesa
->vb
.specptr
;
427 UNCLAMPED_FLOAT_TO_UBYTE( dest
->red
, r
);
428 UNCLAMPED_FLOAT_TO_UBYTE( dest
->green
, g
);
429 UNCLAMPED_FLOAT_TO_UBYTE( dest
->blue
, b
);
433 static void r200_SecondaryColor3fvEXT_ub( const GLfloat
*v
)
435 GET_CURRENT_CONTEXT(ctx
);
436 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
437 r200_color_t
*dest
= rmesa
->vb
.specptr
;
438 UNCLAMPED_FLOAT_TO_UBYTE( dest
->red
, v
[0] );
439 UNCLAMPED_FLOAT_TO_UBYTE( dest
->green
, v
[1] );
440 UNCLAMPED_FLOAT_TO_UBYTE( dest
->blue
, v
[2] );
445 static void r200_SecondaryColor3ubEXT_3f( GLubyte r
, GLubyte g
, GLubyte b
)
447 GET_CURRENT_CONTEXT(ctx
);
448 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
449 GLfloat
*dest
= rmesa
->vb
.floatspecptr
;
450 dest
[0] = UBYTE_TO_FLOAT(r
);
451 dest
[1] = UBYTE_TO_FLOAT(g
);
452 dest
[2] = UBYTE_TO_FLOAT(b
);
456 static void r200_SecondaryColor3ubvEXT_3f( const GLubyte
*v
)
458 GET_CURRENT_CONTEXT(ctx
);
459 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
460 GLfloat
*dest
= rmesa
->vb
.floatspecptr
;
461 dest
[0] = UBYTE_TO_FLOAT(v
[0]);
462 dest
[1] = UBYTE_TO_FLOAT(v
[1]);
463 dest
[2] = UBYTE_TO_FLOAT(v
[2]);
468 static void r200_SecondaryColor3fEXT_3f( GLfloat r
, GLfloat g
, GLfloat b
)
470 GET_CURRENT_CONTEXT(ctx
);
471 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
472 GLfloat
*dest
= rmesa
->vb
.floatspecptr
;
479 static void r200_SecondaryColor3fvEXT_3f( const GLfloat
*v
)
481 GET_CURRENT_CONTEXT(ctx
);
482 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
483 GLfloat
*dest
= rmesa
->vb
.floatspecptr
;
494 static void r200_Normal3f( GLfloat n0
, GLfloat n1
, GLfloat n2
)
496 GET_CURRENT_CONTEXT(ctx
);
497 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
498 GLfloat
*dest
= rmesa
->vb
.normalptr
;
504 static void r200_Normal3fv( const GLfloat
*v
)
506 GET_CURRENT_CONTEXT(ctx
);
507 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
508 GLfloat
*dest
= rmesa
->vb
.normalptr
;
518 /* \todo maybe (target & 4 ? target & 5 : target & 3) is more save than (target & 7) */
519 static void r200_MultiTexCoord1fARB(GLenum target
, GLfloat s
)
521 GET_CURRENT_CONTEXT(ctx
);
522 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
523 GLint unit
= (target
& 7);
524 GLfloat
* const dest
= rmesa
->vb
.texcoordptr
[unit
];
526 switch( ctx
->Texture
.Unit
[unit
]._ReallyEnabled
) {
527 case TEXTURE_CUBE_BIT
:
532 case TEXTURE_RECT_BIT
:
540 static void r200_MultiTexCoord2fARB(GLenum target
, GLfloat s
, GLfloat t
)
542 GET_CURRENT_CONTEXT(ctx
);
543 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
544 GLint unit
= (target
& 7);
545 GLfloat
* const dest
= rmesa
->vb
.texcoordptr
[unit
];
547 switch( ctx
->Texture
.Unit
[unit
]._ReallyEnabled
) {
548 case TEXTURE_CUBE_BIT
:
553 case TEXTURE_RECT_BIT
:
558 VFMT_FALLBACK(__FUNCTION__
);
559 GL_CALL(MultiTexCoord2fARB
)(target
, s
, t
);
564 static void r200_MultiTexCoord3fARB(GLenum target
, GLfloat s
, GLfloat t
, GLfloat r
)
566 GET_CURRENT_CONTEXT(ctx
);
567 r200ContextPtr rmesa
= R200_CONTEXT(ctx
);
568 GLint unit
= (target
& 7);
569 GLfloat
* const dest
= rmesa
->vb
.texcoordptr
[unit
];
571 switch( ctx
->Texture
.Unit
[unit
]._ReallyEnabled
) {
572 case TEXTURE_CUBE_BIT
:
579 VFMT_FALLBACK(__FUNCTION__
);
580 GL_CALL(MultiTexCoord3fARB
)(target
, s
, t
, r
);
585 static void r200_TexCoord1f(GLfloat s
)
587 r200_MultiTexCoord1fARB(GL_TEXTURE0
, s
);
590 static void r200_TexCoord2f(GLfloat s
, GLfloat t
)
592 r200_MultiTexCoord2fARB(GL_TEXTURE0
, s
, t
);
595 static void r200_TexCoord3f(GLfloat s
, GLfloat t
, GLfloat r
)
597 r200_MultiTexCoord3fARB(GL_TEXTURE0
, s
, t
, r
);
600 static void r200_TexCoord1fv(const GLfloat
*v
)
602 r200_MultiTexCoord1fARB(GL_TEXTURE0
, v
[0]);
605 static void r200_TexCoord2fv(const GLfloat
*v
)
607 r200_MultiTexCoord2fARB(GL_TEXTURE0
, v
[0], v
[1]);
610 static void r200_TexCoord3fv(const GLfloat
*v
)
612 r200_MultiTexCoord3fARB(GL_TEXTURE0
, v
[0], v
[1], v
[2]);
615 static void r200_MultiTexCoord1fvARB(GLenum target
, const GLfloat
*v
)
617 r200_MultiTexCoord1fARB(target
, v
[0]);
620 static void r200_MultiTexCoord2fvARB(GLenum target
, const GLfloat
*v
)
622 r200_MultiTexCoord2fARB(target
, v
[0], v
[1]);
625 static void r200_MultiTexCoord3fvARB(GLenum target
, const GLfloat
*v
)
627 r200_MultiTexCoord3fARB(target
, v
[0], v
[1], v
[2]);
631 static struct dynfn
*lookup( struct dynfn
*l
, const int *key
)
636 if (f
->key
[0] == key
[0] && f
->key
[1] == key
[1])
643 /* Can't use the loopback template for this:
646 #define CHOOSE(FN, FNTYPE, MASK0, MASK1, ARGS1, ARGS2 ) \
647 static void choose_##FN ARGS1 \
649 GET_CURRENT_CONTEXT(ctx); \
650 r200ContextPtr rmesa = R200_CONTEXT(ctx); \
654 key[0] = rmesa->vb.vtxfmt_0 & MASK0; \
655 key[1] = rmesa->vb.vtxfmt_1 & MASK1; \
657 dfn = lookup( &rmesa->vb.dfn_cache.FN, key ); \
659 dfn = rmesa->vb.codegen.FN( ctx, key ); \
660 else if (R200_DEBUG & DEBUG_CODEGEN) \
661 fprintf(stderr, "%s -- cached codegen\n", __FUNCTION__ ); \
664 ctx->Exec->FN = (FNTYPE)(dfn->code); \
666 if (R200_DEBUG & DEBUG_CODEGEN) \
667 fprintf(stderr, "%s -- generic version\n", __FUNCTION__ ); \
668 ctx->Exec->FN = r200_##FN; \
671 ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT; \
672 ctx->Exec->FN ARGS2; \
677 /* For the _3f case, only allow one color function to be hooked in at
678 * a time. Eventually, use a similar mechanism to allow selecting the
679 * color component of the vertex format based on client behaviour.
681 * Note: Perform these actions even if there is a codegen or cached
682 * codegen version of the chosen function.
684 #define CHOOSE_COLOR(FN, FNTYPE, NR, MASK0, MASK1, ARGS1, ARGS2 ) \
685 static void choose_##FN ARGS1 \
687 GET_CURRENT_CONTEXT(ctx); \
688 r200ContextPtr rmesa = R200_CONTEXT(ctx); \
692 key[0] = rmesa->vb.vtxfmt_0 & MASK0; \
693 key[1] = rmesa->vb.vtxfmt_1 & MASK1; \
695 if (VTX_COLOR(rmesa->vb.vtxfmt_0,0) == R200_VTX_PK_RGBA) { \
696 ctx->Exec->FN = r200_##FN##_ub; \
698 else if (VTX_COLOR(rmesa->vb.vtxfmt_0,0) == R200_VTX_FP_RGB) { \
700 if (rmesa->vb.installed_color_3f_sz != NR) { \
701 rmesa->vb.installed_color_3f_sz = NR; \
702 if (NR == 3) ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3] = 1.0; \
703 if (ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT) { \
704 r200_copy_to_current( ctx ); \
705 _mesa_install_exec_vtxfmt( ctx, &rmesa->vb.vtxfmt ); \
706 ctx->Exec->FN ARGS2; \
711 ctx->Exec->FN = r200_##FN##_3f; \
714 ctx->Exec->FN = r200_##FN##_4f; \
718 dfn = lookup( &rmesa->vb.dfn_cache.FN, key ); \
719 if (!dfn) dfn = rmesa->vb.codegen.FN( ctx, key ); \
722 if (R200_DEBUG & DEBUG_CODEGEN) \
723 fprintf(stderr, "%s -- codegen version\n", __FUNCTION__ ); \
724 ctx->Exec->FN = (FNTYPE)dfn->code; \
726 else if (R200_DEBUG & DEBUG_CODEGEN) \
727 fprintf(stderr, "%s -- 'c' version\n", __FUNCTION__ ); \
729 ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT; \
730 ctx->Exec->FN ARGS2; \
735 /* Right now there are both _ub and _3f versions of the secondary color
736 * functions. Currently, we only set-up the hardware to use the _ub versions.
737 * The _3f versions are needed for the cases where secondary color isn't used
738 * in the vertex format, but it still needs to be stored in the context
741 #define CHOOSE_SECONDARY_COLOR(FN, FNTYPE, MASK0, MASK1, ARGS1, ARGS2 ) \
742 static void choose_##FN ARGS1 \
744 GET_CURRENT_CONTEXT(ctx); \
745 r200ContextPtr rmesa = R200_CONTEXT(ctx); \
749 key[0] = rmesa->vb.vtxfmt_0 & MASK0; \
750 key[1] = rmesa->vb.vtxfmt_1 & MASK1; \
752 dfn = lookup( &rmesa->vb.dfn_cache.FN, key ); \
754 dfn = rmesa->vb.codegen.FN( ctx, key ); \
755 else if (R200_DEBUG & DEBUG_CODEGEN) \
756 fprintf(stderr, "%s -- cached version\n", __FUNCTION__ ); \
759 ctx->Exec->FN = (FNTYPE)(dfn->code); \
761 if (R200_DEBUG & DEBUG_CODEGEN) \
762 fprintf(stderr, "%s -- generic version\n", __FUNCTION__ ); \
763 ctx->Exec->FN = (VTX_COLOR(rmesa->vb.vtxfmt_0,1) == R200_VTX_PK_RGBA) \
764 ? r200_##FN##_ub : r200_##FN##_3f; \
767 ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT; \
768 ctx->Exec->FN ARGS2; \
779 #define MASK_XYZW (R200_VTX_W0|R200_VTX_Z0)
780 #define MASK_NORM (MASK_XYZW|R200_VTX_N0)
781 #define MASK_COLOR (MASK_NORM |(R200_VTX_COLOR_MASK<<R200_VTX_COLOR_0_SHIFT))
782 #define MASK_SPEC (MASK_COLOR|(R200_VTX_COLOR_MASK<<R200_VTX_COLOR_1_SHIFT))
786 #define MASK_ST0 (0x7 << R200_VTX_TEX0_COMP_CNT_SHIFT)
787 /* FIXME: maybe something like in the radeon driver is needed here? */
790 typedef void (*p4f
)( GLfloat
, GLfloat
, GLfloat
, GLfloat
);
791 typedef void (*p3f
)( GLfloat
, GLfloat
, GLfloat
);
792 typedef void (*p2f
)( GLfloat
, GLfloat
);
793 typedef void (*p1f
)( GLfloat
);
794 typedef void (*pe3f
)( GLenum
, GLfloat
, GLfloat
, GLfloat
);
795 typedef void (*pe2f
)( GLenum
, GLfloat
, GLfloat
);
796 typedef void (*pe1f
)( GLenum
, GLfloat
);
797 typedef void (*p4ub
)( GLubyte
, GLubyte
, GLubyte
, GLubyte
);
798 typedef void (*p3ub
)( GLubyte
, GLubyte
, GLubyte
);
799 typedef void (*pfv
)( const GLfloat
* );
800 typedef void (*pefv
)( GLenum
, const GLfloat
* );
801 typedef void (*pubv
)( const GLubyte
* );
804 CHOOSE(Normal3f
, p3f
, MASK_NORM
, 0,
805 (GLfloat a
,GLfloat b
,GLfloat c
), (a
,b
,c
))
806 CHOOSE(Normal3fv
, pfv
, MASK_NORM
, 0,
807 (const GLfloat
*v
), (v
))
810 CHOOSE_COLOR(Color4ub
, p4ub
, 4, MASK_COLOR
, 0,
811 (GLubyte a
,GLubyte b
, GLubyte c
, GLubyte d
), (a
,b
,c
,d
))
812 CHOOSE_COLOR(Color4ubv
, pubv
, 4, MASK_COLOR
, 0,
813 (const GLubyte
*v
), (v
))
814 CHOOSE_COLOR(Color3ub
, p3ub
, 3, MASK_COLOR
, 0,
815 (GLubyte a
,GLubyte b
, GLubyte c
), (a
,b
,c
))
816 CHOOSE_COLOR(Color3ubv
, pubv
, 3, MASK_COLOR
, 0,
817 (const GLubyte
*v
), (v
))
818 CHOOSE_SECONDARY_COLOR(SecondaryColor3ubEXT
, p3ub
, MASK_SPEC
, 0,
819 (GLubyte a
,GLubyte b
, GLubyte c
), (a
,b
,c
))
820 CHOOSE_SECONDARY_COLOR(SecondaryColor3ubvEXT
, pubv
, MASK_SPEC
, 0,
821 (const GLubyte
*v
), (v
))
824 CHOOSE_COLOR(Color4f
, p4f
, 4, MASK_COLOR
, 0,
825 (GLfloat a
,GLfloat b
, GLfloat c
, GLfloat d
), (a
,b
,c
,d
))
826 CHOOSE_COLOR(Color4fv
, pfv
, 4, MASK_COLOR
, 0,
827 (const GLfloat
*v
), (v
))
828 CHOOSE_COLOR(Color3f
, p3f
, 3, MASK_COLOR
, 0,
829 (GLfloat a
,GLfloat b
, GLfloat c
), (a
,b
,c
))
830 CHOOSE_COLOR(Color3fv
, pfv
, 3, MASK_COLOR
, 0,
831 (const GLfloat
*v
), (v
))
834 CHOOSE_SECONDARY_COLOR(SecondaryColor3fEXT
, p3f
, MASK_SPEC
, 0,
835 (GLfloat a
,GLfloat b
, GLfloat c
), (a
,b
,c
))
836 CHOOSE_SECONDARY_COLOR(SecondaryColor3fvEXT
, pfv
, MASK_SPEC
, 0,
837 (const GLfloat
*v
), (v
))
839 CHOOSE(TexCoord3f
, p3f
, ~0, MASK_ST0
,
840 (GLfloat a
,GLfloat b
,GLfloat c
), (a
,b
,c
))
841 CHOOSE(TexCoord3fv
, pfv
, ~0, MASK_ST0
,
842 (const GLfloat
*v
), (v
))
843 CHOOSE(TexCoord2f
, p2f
, ~0, MASK_ST0
,
844 (GLfloat a
,GLfloat b
), (a
,b
))
845 CHOOSE(TexCoord2fv
, pfv
, ~0, MASK_ST0
,
846 (const GLfloat
*v
), (v
))
847 CHOOSE(TexCoord1f
, p1f
, ~0, MASK_ST0
,
849 CHOOSE(TexCoord1fv
, pfv
, ~0, MASK_ST0
,
850 (const GLfloat
*v
), (v
))
852 CHOOSE(MultiTexCoord3fARB
, pe3f
, ~0, ~0,
853 (GLenum u
,GLfloat a
,GLfloat b
,GLfloat c
), (u
,a
,b
,c
))
854 CHOOSE(MultiTexCoord3fvARB
, pefv
, ~0, ~0,
855 (GLenum u
,const GLfloat
*v
), (u
,v
))
856 CHOOSE(MultiTexCoord2fARB
, pe2f
, ~0, ~0,
857 (GLenum u
,GLfloat a
,GLfloat b
), (u
,a
,b
))
858 CHOOSE(MultiTexCoord2fvARB
, pefv
, ~0, ~0,
859 (GLenum u
,const GLfloat
*v
), (u
,v
))
860 CHOOSE(MultiTexCoord1fARB
, pe1f
, ~0, ~0,
861 (GLenum u
,GLfloat a
), (u
,a
))
862 CHOOSE(MultiTexCoord1fvARB
, pefv
, ~0, ~0,
863 (GLenum u
,const GLfloat
*v
), (u
,v
))
865 CHOOSE(Vertex3f
, p3f
, ~0, ~0,
866 (GLfloat a
,GLfloat b
,GLfloat c
), (a
,b
,c
))
867 CHOOSE(Vertex3fv
, pfv
, ~0, ~0,
868 (const GLfloat
*v
), (v
))
869 CHOOSE(Vertex2f
, p2f
, ~0, ~0,
870 (GLfloat a
,GLfloat b
), (a
,b
))
871 CHOOSE(Vertex2fv
, pfv
, ~0, ~0,
872 (const GLfloat
*v
), (v
))
878 void r200VtxfmtInitChoosers( GLvertexformat
*vfmt
)
880 vfmt
->Color3f
= choose_Color3f
;
881 vfmt
->Color3fv
= choose_Color3fv
;
882 vfmt
->Color4f
= choose_Color4f
;
883 vfmt
->Color4fv
= choose_Color4fv
;
884 vfmt
->SecondaryColor3fEXT
= choose_SecondaryColor3fEXT
;
885 vfmt
->SecondaryColor3fvEXT
= choose_SecondaryColor3fvEXT
;
886 vfmt
->MultiTexCoord1fARB
= choose_MultiTexCoord1fARB
;
887 vfmt
->MultiTexCoord1fvARB
= choose_MultiTexCoord1fvARB
;
888 vfmt
->MultiTexCoord2fARB
= choose_MultiTexCoord2fARB
;
889 vfmt
->MultiTexCoord2fvARB
= choose_MultiTexCoord2fvARB
;
890 vfmt
->MultiTexCoord3fARB
= choose_MultiTexCoord3fARB
;
891 vfmt
->MultiTexCoord3fvARB
= choose_MultiTexCoord3fvARB
;
892 vfmt
->Normal3f
= choose_Normal3f
;
893 vfmt
->Normal3fv
= choose_Normal3fv
;
894 vfmt
->TexCoord1f
= choose_TexCoord1f
;
895 vfmt
->TexCoord1fv
= choose_TexCoord1fv
;
896 vfmt
->TexCoord2f
= choose_TexCoord2f
;
897 vfmt
->TexCoord2fv
= choose_TexCoord2fv
;
898 vfmt
->TexCoord3f
= choose_TexCoord3f
;
899 vfmt
->TexCoord3fv
= choose_TexCoord3fv
;
900 vfmt
->Vertex2f
= choose_Vertex2f
;
901 vfmt
->Vertex2fv
= choose_Vertex2fv
;
902 vfmt
->Vertex3f
= choose_Vertex3f
;
903 vfmt
->Vertex3fv
= choose_Vertex3fv
;
905 /* TODO: restore ubyte colors to vtxfmt.
908 vfmt
->Color3ub
= choose_Color3ub
;
909 vfmt
->Color3ubv
= choose_Color3ubv
;
910 vfmt
->Color4ub
= choose_Color4ub
;
911 vfmt
->Color4ubv
= choose_Color4ubv
;
912 vfmt
->SecondaryColor3ubEXT
= choose_SecondaryColor3ubEXT
;
913 vfmt
->SecondaryColor3ubvEXT
= choose_SecondaryColor3ubvEXT
;
918 static struct dynfn
*codegen_noop( GLcontext
*ctx
, const int *key
)
920 (void) ctx
; (void) key
;
924 void r200InitCodegen( struct dfn_generators
*gen
, GLboolean useCodegen
)
926 gen
->Vertex3f
= codegen_noop
;
927 gen
->Vertex3fv
= codegen_noop
;
928 gen
->Color4ub
= codegen_noop
;
929 gen
->Color4ubv
= codegen_noop
;
930 gen
->Normal3f
= codegen_noop
;
931 gen
->Normal3fv
= codegen_noop
;
933 gen
->TexCoord3f
= codegen_noop
;
934 gen
->TexCoord3fv
= codegen_noop
;
935 gen
->TexCoord2f
= codegen_noop
;
936 gen
->TexCoord2fv
= codegen_noop
;
937 gen
->TexCoord1f
= codegen_noop
;
938 gen
->TexCoord1fv
= codegen_noop
;
940 gen
->MultiTexCoord3fARB
= codegen_noop
;
941 gen
->MultiTexCoord3fvARB
= codegen_noop
;
942 gen
->MultiTexCoord2fARB
= codegen_noop
;
943 gen
->MultiTexCoord2fvARB
= codegen_noop
;
944 gen
->MultiTexCoord1fARB
= codegen_noop
;
945 gen
->MultiTexCoord1fvARB
= codegen_noop
;
947 gen
->Vertex2f
= codegen_noop
;
948 gen
->Vertex2fv
= codegen_noop
;
949 gen
->Color3ub
= codegen_noop
;
950 gen
->Color3ubv
= codegen_noop
;
951 gen
->Color4f
= codegen_noop
;
952 gen
->Color4fv
= codegen_noop
;
953 gen
->Color3f
= codegen_noop
;
954 gen
->Color3fv
= codegen_noop
;
955 gen
->SecondaryColor3fEXT
= codegen_noop
;
956 gen
->SecondaryColor3fvEXT
= codegen_noop
;
957 gen
->SecondaryColor3ubEXT
= codegen_noop
;
958 gen
->SecondaryColor3ubvEXT
= codegen_noop
;
961 #if defined(USE_X86_ASM)
962 r200InitX86Codegen( gen
);
965 #if defined(USE_SSE_ASM)
966 r200InitSSECodegen( gen
);