1 /* $XFree86: xc/lib/GL/mesa/src/drv/r128/r128_tris.c,v 1.8 2002/10/30 12:51:43 alanh Exp $ */ /* -*- c-basic-offset: 3 -*- */
2 /**************************************************************************
4 Copyright 2000, 2001 ATI Technologies Inc., Ontario, Canada, and
5 VA Linux Systems Inc., Fremont, California.
9 Permission is hereby granted, free of charge, to any person obtaining a
10 copy of this software and associated documentation files (the "Software"),
11 to deal in the Software without restriction, including without limitation
12 on the rights to use, copy, modify, merge, publish, distribute, sub
13 license, and/or sell copies of the Software, and to permit persons to whom
14 the Software is furnished to do so, subject to the following conditions:
16 The above copyright notice and this permission notice (including the next
17 paragraph) shall be included in all copies or substantial portions of the
20 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22 FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
23 ATI, VA LINUX SYSTEMS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
24 DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
25 OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
26 USE OR OTHER DEALINGS IN THE SOFTWARE.
28 **************************************************************************/
32 * Keith Whitwell <keith@tungstengraphics.com>
41 #include "swrast/swrast.h"
42 #include "swrast_setup/swrast_setup.h"
44 #include "tnl/t_context.h"
45 #include "tnl/t_pipeline.h"
47 #include "r128_tris.h"
48 #include "r128_state.h"
50 #include "r128_ioctl.h"
52 static const GLuint hw_prim
[GL_POLYGON
+1] = {
53 R128_CCE_VC_CNTL_PRIM_TYPE_POINT
,
54 R128_CCE_VC_CNTL_PRIM_TYPE_LINE
,
55 R128_CCE_VC_CNTL_PRIM_TYPE_LINE
,
56 R128_CCE_VC_CNTL_PRIM_TYPE_LINE
,
57 R128_CCE_VC_CNTL_PRIM_TYPE_TRI_LIST
,
58 R128_CCE_VC_CNTL_PRIM_TYPE_TRI_LIST
,
59 R128_CCE_VC_CNTL_PRIM_TYPE_TRI_LIST
,
60 R128_CCE_VC_CNTL_PRIM_TYPE_TRI_LIST
,
61 R128_CCE_VC_CNTL_PRIM_TYPE_TRI_LIST
,
62 R128_CCE_VC_CNTL_PRIM_TYPE_TRI_LIST
,
65 static void r128RasterPrimitive( GLcontext
*ctx
, GLuint hwprim
);
66 static void r128RenderPrimitive( GLcontext
*ctx
, GLenum prim
);
69 /***********************************************************************
70 * Emit primitives as inline vertices *
71 ***********************************************************************/
76 #define HAVE_LE32_VERTS 1
77 #define CTX_ARG r128ContextPtr rmesa
78 #define GET_VERTEX_DWORDS() rmesa->vertex_size
79 #define ALLOC_VERTS( n, size ) r128AllocDmaLow( rmesa, (n), (size) * 4 )
82 r128ContextPtr rmesa = R128_CONTEXT(ctx); \
83 const char *vertptr = rmesa->verts;
84 #define VERT(x) (r128Vertex *)(vertptr + ((x) * vertsize * 4))
85 #define VERTEX r128Vertex
87 #define TAG(x) r128_##x
88 #include "tnl_dd/t_dd_triemit.h"
93 /***********************************************************************
94 * Macros for t_dd_tritmp.h to draw basic primitives *
95 ***********************************************************************/
97 #define TRI( a, b, c ) \
100 rmesa->draw_tri( rmesa, a, b, c ); \
102 r128_triangle( rmesa, a, b, c ); \
105 #define QUAD( a, b, c, d ) \
108 rmesa->draw_tri( rmesa, a, b, d ); \
109 rmesa->draw_tri( rmesa, b, c, d ); \
111 r128_quad( rmesa, a, b, c, d ); \
114 #define LINE( v0, v1 ) \
117 rmesa->draw_line( rmesa, v0, v1 ); \
119 r128_line( rmesa, v0, v1 ); \
122 #define POINT( v0 ) \
125 rmesa->draw_point( rmesa, v0 ); \
127 r128_point( rmesa, v0 ); \
131 /***********************************************************************
132 * Build render functions from dd templates *
133 ***********************************************************************/
135 #define R128_OFFSET_BIT 0x01
136 #define R128_TWOSIDE_BIT 0x02
137 #define R128_UNFILLED_BIT 0x04
138 #define R128_FALLBACK_BIT 0x08
139 #define R128_MAX_TRIFUNC 0x10
143 tnl_points_func points
;
145 tnl_triangle_func triangle
;
147 } rast_tab
[R128_MAX_TRIFUNC
];
150 #define DO_FALLBACK (IND & R128_FALLBACK_BIT)
151 #define DO_OFFSET (IND & R128_OFFSET_BIT)
152 #define DO_UNFILLED (IND & R128_UNFILLED_BIT)
153 #define DO_TWOSIDE (IND & R128_TWOSIDE_BIT)
159 #define DO_FULL_QUAD 1
163 #define HAVE_BACK_COLORS 0
164 #define HAVE_HW_FLATSHADE 1
165 #define VERTEX r128Vertex
168 #define DEPTH_SCALE rmesa->depth_scale
169 #define UNFILLED_TRI unfilled_tri
170 #define UNFILLED_QUAD unfilled_quad
171 #define VERT_X(_v) _v->v.x
172 #define VERT_Y(_v) _v->v.y
173 #define VERT_Z(_v) _v->v.z
174 #define AREA_IS_CCW( a ) (a > 0)
175 #define GET_VERTEX(e) (rmesa->verts + (e * rmesa->vertex_size * sizeof(int)))
177 #define VERT_SET_RGBA( v, c ) \
179 r128_color_t *color = (r128_color_t *)&((v)->ui[coloroffset]); \
180 UNCLAMPED_FLOAT_TO_UBYTE(color->red, (c)[0]); \
181 UNCLAMPED_FLOAT_TO_UBYTE(color->green, (c)[1]); \
182 UNCLAMPED_FLOAT_TO_UBYTE(color->blue, (c)[2]); \
183 UNCLAMPED_FLOAT_TO_UBYTE(color->alpha, (c)[3]); \
186 #define VERT_COPY_RGBA( v0, v1 ) v0->ui[coloroffset] = v1->ui[coloroffset]
188 #define VERT_SET_SPEC( v0, c ) \
191 r128_color_t *spec = (r128_color_t *)&((v0)->ui[specoffset]); \
192 UNCLAMPED_FLOAT_TO_UBYTE(spec->red, (c)[0]); \
193 UNCLAMPED_FLOAT_TO_UBYTE(spec->green, (c)[1]); \
194 UNCLAMPED_FLOAT_TO_UBYTE(spec->blue, (c)[2]); \
197 #define VERT_COPY_SPEC( v0, v1 ) \
200 r128_color_t *spec0 = (r128_color_t *)&((v0)->ui[specoffset]); \
201 r128_color_t *spec1 = (r128_color_t *)&((v1)->ui[specoffset]); \
202 spec0->red = spec1->red; \
203 spec0->green = spec1->green; \
204 spec0->blue = spec1->blue; \
208 /* These don't need LE32_TO_CPU() as they are used to save and restore
209 * colors which are already in the correct format.
211 #define VERT_SAVE_RGBA( idx ) color[idx] = v[idx]->ui[coloroffset]
212 #define VERT_RESTORE_RGBA( idx ) v[idx]->ui[coloroffset] = color[idx]
213 #define VERT_SAVE_SPEC( idx ) if (havespec) spec[idx] = v[idx]->ui[specoffset]
214 #define VERT_RESTORE_SPEC( idx ) if (havespec) v[idx]->ui[specoffset] = spec[idx]
217 #define LOCAL_VARS(n) \
218 r128ContextPtr rmesa = R128_CONTEXT(ctx); \
219 GLuint color[n], spec[n]; \
220 GLuint coloroffset = rmesa->coloroffset; \
221 GLuint specoffset = rmesa->specoffset; \
222 GLboolean havespec = (rmesa->specoffset != 0); \
223 (void) color; (void) spec; (void) specoffset; \
224 (void) coloroffset; (void) havespec;
226 /***********************************************************************
227 * Helpers for rendering unfilled primitives *
228 ***********************************************************************/
230 #define RASTERIZE(x) if (rmesa->hw_primitive != hw_prim[x]) \
231 r128RasterPrimitive( ctx, hw_prim[x] )
232 #define RENDER_PRIMITIVE rmesa->render_primitive
233 #define IND R128_FALLBACK_BIT
235 #include "tnl_dd/t_dd_unfilled.h"
239 /***********************************************************************
240 * Generate GL render functions *
241 ***********************************************************************/
246 #include "tnl_dd/t_dd_tritmp.h"
248 #define IND (R128_OFFSET_BIT)
249 #define TAG(x) x##_offset
250 #include "tnl_dd/t_dd_tritmp.h"
252 #define IND (R128_TWOSIDE_BIT)
253 #define TAG(x) x##_twoside
254 #include "tnl_dd/t_dd_tritmp.h"
256 #define IND (R128_TWOSIDE_BIT|R128_OFFSET_BIT)
257 #define TAG(x) x##_twoside_offset
258 #include "tnl_dd/t_dd_tritmp.h"
260 #define IND (R128_UNFILLED_BIT)
261 #define TAG(x) x##_unfilled
262 #include "tnl_dd/t_dd_tritmp.h"
264 #define IND (R128_OFFSET_BIT|R128_UNFILLED_BIT)
265 #define TAG(x) x##_offset_unfilled
266 #include "tnl_dd/t_dd_tritmp.h"
268 #define IND (R128_TWOSIDE_BIT|R128_UNFILLED_BIT)
269 #define TAG(x) x##_twoside_unfilled
270 #include "tnl_dd/t_dd_tritmp.h"
272 #define IND (R128_TWOSIDE_BIT|R128_OFFSET_BIT|R128_UNFILLED_BIT)
273 #define TAG(x) x##_twoside_offset_unfilled
274 #include "tnl_dd/t_dd_tritmp.h"
276 #define IND (R128_FALLBACK_BIT)
277 #define TAG(x) x##_fallback
278 #include "tnl_dd/t_dd_tritmp.h"
280 #define IND (R128_OFFSET_BIT|R128_FALLBACK_BIT)
281 #define TAG(x) x##_offset_fallback
282 #include "tnl_dd/t_dd_tritmp.h"
284 #define IND (R128_TWOSIDE_BIT|R128_FALLBACK_BIT)
285 #define TAG(x) x##_twoside_fallback
286 #include "tnl_dd/t_dd_tritmp.h"
288 #define IND (R128_TWOSIDE_BIT|R128_OFFSET_BIT|R128_FALLBACK_BIT)
289 #define TAG(x) x##_twoside_offset_fallback
290 #include "tnl_dd/t_dd_tritmp.h"
292 #define IND (R128_UNFILLED_BIT|R128_FALLBACK_BIT)
293 #define TAG(x) x##_unfilled_fallback
294 #include "tnl_dd/t_dd_tritmp.h"
296 #define IND (R128_OFFSET_BIT|R128_UNFILLED_BIT|R128_FALLBACK_BIT)
297 #define TAG(x) x##_offset_unfilled_fallback
298 #include "tnl_dd/t_dd_tritmp.h"
300 #define IND (R128_TWOSIDE_BIT|R128_UNFILLED_BIT|R128_FALLBACK_BIT)
301 #define TAG(x) x##_twoside_unfilled_fallback
302 #include "tnl_dd/t_dd_tritmp.h"
304 #define IND (R128_TWOSIDE_BIT|R128_OFFSET_BIT|R128_UNFILLED_BIT| \
306 #define TAG(x) x##_twoside_offset_unfilled_fallback
307 #include "tnl_dd/t_dd_tritmp.h"
310 static void init_rast_tab( void )
315 init_twoside_offset();
317 init_offset_unfilled();
318 init_twoside_unfilled();
319 init_twoside_offset_unfilled();
321 init_offset_fallback();
322 init_twoside_fallback();
323 init_twoside_offset_fallback();
324 init_unfilled_fallback();
325 init_offset_unfilled_fallback();
326 init_twoside_unfilled_fallback();
327 init_twoside_offset_unfilled_fallback();
332 /***********************************************************************
333 * Rasterization fallback helpers *
334 ***********************************************************************/
337 /* This code is hit only when a mix of accelerated and unaccelerated
338 * primitives are being drawn, and only for the unaccelerated
342 r128_fallback_tri( r128ContextPtr rmesa
,
347 GLcontext
*ctx
= rmesa
->glCtx
;
349 _swsetup_Translate( ctx
, v0
, &v
[0] );
350 _swsetup_Translate( ctx
, v1
, &v
[1] );
351 _swsetup_Translate( ctx
, v2
, &v
[2] );
352 /* XXX: SpanRenderStart */
353 _swrast_Triangle( ctx
, &v
[0], &v
[1], &v
[2] );
358 r128_fallback_line( r128ContextPtr rmesa
,
362 GLcontext
*ctx
= rmesa
->glCtx
;
364 _swsetup_Translate( ctx
, v0
, &v
[0] );
365 _swsetup_Translate( ctx
, v1
, &v
[1] );
366 _swrast_Line( ctx
, &v
[0], &v
[1] );
371 r128_fallback_point( r128ContextPtr rmesa
,
374 GLcontext
*ctx
= rmesa
->glCtx
;
376 _swsetup_Translate( ctx
, v0
, &v
[0] );
377 _swrast_Point( ctx
, &v
[0] );
382 /**********************************************************************/
383 /* Render unclipped begin/end objects */
384 /**********************************************************************/
386 #define RENDER_POINTS( start, count ) \
387 for ( ; start < count ; start++) \
388 r128_point( rmesa, VERT(start) )
389 #define RENDER_LINE( v0, v1 ) \
390 r128_line( rmesa, VERT(v0), VERT(v1) )
391 #define RENDER_TRI( v0, v1, v2 ) \
392 r128_triangle( rmesa, VERT(v0), VERT(v1), VERT(v2) )
393 #define RENDER_QUAD( v0, v1, v2, v3 ) \
394 r128_quad( rmesa, VERT(v0), VERT(v1), VERT(v2), VERT(v3) )
395 #define INIT(x) do { \
396 if (0) fprintf(stderr, "%s\n", __FUNCTION__); \
397 r128RenderPrimitive( ctx, x ); \
401 r128ContextPtr rmesa = R128_CONTEXT(ctx); \
402 const GLuint vertsize = rmesa->vertex_size; \
403 const char *vertptr = (char *)rmesa->verts; \
404 const GLuint * const elt = TNL_CONTEXT(ctx)->vb.Elts; \
406 #define RESET_STIPPLE
407 #define RESET_OCCLUSION
408 #define PRESERVE_VB_DEFS
410 #define TAG(x) r128_##x##_verts
411 #include "tnl/t_vb_rendertmp.h"
414 #define TAG(x) r128_##x##_elts
415 #define ELT(x) elt[x]
416 #include "tnl/t_vb_rendertmp.h"
419 /**********************************************************************/
420 /* Choose render functions */
421 /**********************************************************************/
423 #define POINT_FALLBACK (DD_POINT_SMOOTH)
424 #define LINE_FALLBACK (DD_LINE_STIPPLE|DD_LINE_SMOOTH)
425 #define TRI_FALLBACK (DD_TRI_SMOOTH)
426 #define ANY_FALLBACK_FLAGS (POINT_FALLBACK|LINE_FALLBACK|TRI_FALLBACK)
427 #define ANY_RASTER_FLAGS (DD_TRI_LIGHT_TWOSIDE|DD_TRI_OFFSET|DD_TRI_UNFILLED)
428 #define _R128_NEW_RENDER_STATE (ANY_FALLBACK_FLAGS | ANY_RASTER_FLAGS)
430 static void r128ChooseRenderState(GLcontext
*ctx
)
432 r128ContextPtr rmesa
= R128_CONTEXT(ctx
);
433 GLuint flags
= ctx
->_TriangleCaps
;
436 if (flags
& (ANY_RASTER_FLAGS
|ANY_FALLBACK_FLAGS
)) {
437 rmesa
->draw_point
= r128_point
;
438 rmesa
->draw_line
= r128_line
;
439 rmesa
->draw_tri
= r128_triangle
;
441 if (flags
& ANY_RASTER_FLAGS
) {
442 if (flags
& DD_TRI_LIGHT_TWOSIDE
) index
|= R128_TWOSIDE_BIT
;
443 if (flags
& DD_TRI_OFFSET
) index
|= R128_OFFSET_BIT
;
444 if (flags
& DD_TRI_UNFILLED
) index
|= R128_UNFILLED_BIT
;
447 /* Hook in fallbacks for specific primitives.
449 if (flags
& (POINT_FALLBACK
|LINE_FALLBACK
|TRI_FALLBACK
)) {
450 if (flags
& POINT_FALLBACK
) rmesa
->draw_point
= r128_fallback_point
;
451 if (flags
& LINE_FALLBACK
) rmesa
->draw_line
= r128_fallback_line
;
452 if (flags
& TRI_FALLBACK
) rmesa
->draw_tri
= r128_fallback_tri
;
453 index
|= R128_FALLBACK_BIT
;
457 if (index
!= rmesa
->RenderIndex
) {
458 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
459 tnl
->Driver
.Render
.Points
= rast_tab
[index
].points
;
460 tnl
->Driver
.Render
.Line
= rast_tab
[index
].line
;
461 tnl
->Driver
.Render
.ClippedLine
= rast_tab
[index
].line
;
462 tnl
->Driver
.Render
.Triangle
= rast_tab
[index
].triangle
;
463 tnl
->Driver
.Render
.Quad
= rast_tab
[index
].quad
;
466 tnl
->Driver
.Render
.PrimTabVerts
= r128_render_tab_verts
;
467 tnl
->Driver
.Render
.PrimTabElts
= r128_render_tab_elts
;
468 tnl
->Driver
.Render
.ClippedPolygon
= r128_fast_clipped_poly
;
470 tnl
->Driver
.Render
.PrimTabVerts
= _tnl_render_tab_verts
;
471 tnl
->Driver
.Render
.PrimTabElts
= _tnl_render_tab_elts
;
472 tnl
->Driver
.Render
.ClippedPolygon
= _tnl_RenderClippedPolygon
;
475 rmesa
->RenderIndex
= index
;
479 /**********************************************************************/
480 /* Validate state at pipeline start */
481 /**********************************************************************/
483 static void r128RunPipeline( GLcontext
*ctx
)
485 r128ContextPtr rmesa
= R128_CONTEXT(ctx
);
487 if (rmesa
->new_state
|| rmesa
->NewGLState
& _NEW_TEXTURE
)
488 r128DDUpdateHWState( ctx
);
490 if (!rmesa
->Fallback
&& rmesa
->NewGLState
) {
491 if (rmesa
->NewGLState
& _R128_NEW_RENDER_STATE
)
492 r128ChooseRenderState( ctx
);
494 rmesa
->NewGLState
= 0;
497 _tnl_run_pipeline( ctx
);
500 /**********************************************************************/
501 /* High level hooks for t_vb_render.c */
502 /**********************************************************************/
504 /* This is called when Mesa switches between rendering triangle
505 * primitives (such as GL_POLYGON, GL_QUADS, GL_TRIANGLE_STRIP, etc),
506 * and lines, points and bitmaps.
508 * As the r128 uses triangles to render lines and points, it is
509 * necessary to turn off hardware culling when rendering these
513 static void r128RasterPrimitive( GLcontext
*ctx
, GLuint hwprim
)
515 r128ContextPtr rmesa
= R128_CONTEXT(ctx
);
517 rmesa
->setup
.dp_gui_master_cntl_c
&= ~R128_GMC_BRUSH_NONE
;
519 if ( ctx
->Polygon
.StippleFlag
&& hwprim
== GL_TRIANGLES
) {
520 rmesa
->setup
.dp_gui_master_cntl_c
|= R128_GMC_BRUSH_32x32_MONO_FG_LA
;
523 rmesa
->setup
.dp_gui_master_cntl_c
|= R128_GMC_BRUSH_SOLID_COLOR
;
526 rmesa
->new_state
|= R128_NEW_CONTEXT
;
527 rmesa
->dirty
|= R128_UPLOAD_CONTEXT
;
529 if (rmesa
->hw_primitive
!= hwprim
) {
530 FLUSH_BATCH( rmesa
);
531 rmesa
->hw_primitive
= hwprim
;
535 static void r128RenderPrimitive( GLcontext
*ctx
, GLenum prim
)
537 r128ContextPtr rmesa
= R128_CONTEXT(ctx
);
538 GLuint hw
= hw_prim
[prim
];
539 rmesa
->render_primitive
= prim
;
540 if (prim
>= GL_TRIANGLES
&& (ctx
->_TriangleCaps
& DD_TRI_UNFILLED
))
542 r128RasterPrimitive( ctx
, hw
);
545 #define EMIT_ATTR( ATTR, STYLE, VF, SIZE ) \
547 rmesa->vertex_attrs[rmesa->vertex_attr_count].attrib = (ATTR); \
548 rmesa->vertex_attrs[rmesa->vertex_attr_count].format = (STYLE); \
549 rmesa->vertex_attr_count++; \
554 #define EMIT_PAD( SIZE ) \
556 rmesa->vertex_attrs[rmesa->vertex_attr_count].attrib = 0; \
557 rmesa->vertex_attrs[rmesa->vertex_attr_count].format = EMIT_PAD; \
558 rmesa->vertex_attrs[rmesa->vertex_attr_count].offset = (SIZE); \
559 rmesa->vertex_attr_count++; \
563 static void r128RenderStart( GLcontext
*ctx
)
565 r128ContextPtr rmesa
= R128_CONTEXT(ctx
);
566 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
567 struct vertex_buffer
*VB
= &tnl
->vb
;
568 GLuint index
= tnl
->render_inputs
;
570 GLboolean fallback_projtex
= GL_FALSE
;
574 VB
->AttribPtr
[VERT_ATTRIB_POS
] = VB
->NdcPtr
;
575 rmesa
->vertex_attr_count
= 0;
576 rmesa
->specoffset
= 0;
578 /* EMIT_ATTR's must be in order as they tell t_vertex.c how to
579 * build up a hardware vertex.
581 if ( index
& _TNL_BITS_TEX_ANY
)
582 EMIT_ATTR( _TNL_ATTRIB_POS
, EMIT_4F_VIEWPORT
, R128_CCE_VC_FRMT_RHW
, 16 );
584 EMIT_ATTR( _TNL_ATTRIB_POS
, EMIT_3F_VIEWPORT
, 0, 12 );
586 rmesa
->coloroffset
= offset
;
587 #if MESA_LITTLE_ENDIAN
588 EMIT_ATTR( _TNL_ATTRIB_COLOR0
, EMIT_4UB_4F_BGRA
,
589 R128_CCE_VC_FRMT_DIFFUSE_ARGB
, 4 );
591 EMIT_ATTR( _TNL_ATTRIB_COLOR0
, EMIT_4UB_4F_ARGB
,
592 R128_CCE_VC_FRMT_DIFFUSE_ARGB
, 4 );
595 if ( index
& (_TNL_BIT_COLOR1
|_TNL_BIT_FOG
) ) {
596 #if MESA_LITTLE_ENDIAN
597 if ( index
& _TNL_BIT_COLOR1
) {
598 rmesa
->specoffset
= offset
;
599 EMIT_ATTR( _TNL_ATTRIB_COLOR1
, EMIT_3UB_3F_RGB
,
600 R128_CCE_VC_FRMT_SPEC_FRGB
, 3 );
604 if (index
& _TNL_BIT_FOG
)
605 EMIT_ATTR( _TNL_ATTRIB_FOG
, EMIT_1UB_1F
, R128_CCE_VC_FRMT_SPEC_FRGB
,
610 if (index
& _TNL_BIT_FOG
)
611 EMIT_ATTR( _TNL_ATTRIB_FOG
, EMIT_1UB_1F
, R128_CCE_VC_FRMT_SPEC_FRGB
,
616 if ( index
& _TNL_BIT_COLOR1
) {
617 rmesa
->specoffset
= offset
;
618 EMIT_ATTR( _TNL_ATTRIB_COLOR1
, EMIT_3UB_3F_RGB
,
619 R128_CCE_VC_FRMT_SPEC_FRGB
, 3 );
625 if ( index
& _TNL_BIT_TEX(rmesa
->tmu_source
[0]) ) {
626 if ( VB
->TexCoordPtr
[rmesa
->tmu_source
[0]]->size
> 2 )
627 fallback_projtex
= GL_TRUE
;
628 EMIT_ATTR( _TNL_ATTRIB_TEX0
, EMIT_2F
, R128_CCE_VC_FRMT_S_T
, 8 );
630 if ( index
& _TNL_BIT_TEX(rmesa
->tmu_source
[1]) ) {
631 if ( VB
->TexCoordPtr
[rmesa
->tmu_source
[1]]->size
> 2 )
632 fallback_projtex
= GL_TRUE
;
633 EMIT_ATTR( _TNL_ATTRIB_TEX1
, EMIT_2F
, R128_CCE_VC_FRMT_S2_T2
, 8 );
636 /* projective textures are not supported by the hardware */
637 FALLBACK( rmesa
, R128_FALLBACK_PROJTEX
, fallback_projtex
);
639 /* Only need to change the vertex emit code if there has been a
640 * statechange to a TNL index.
642 if ( index
!= rmesa
->tnl_state
) {
643 FLUSH_BATCH( rmesa
);
644 rmesa
->dirty
|= R128_UPLOAD_CONTEXT
;
647 _tnl_install_attrs( ctx
,
649 rmesa
->vertex_attr_count
,
650 rmesa
->hw_viewport
, 0 );
651 rmesa
->vertex_size
>>= 2;
653 rmesa
->vertex_format
= vc_frmt
;
657 static void r128RenderFinish( GLcontext
*ctx
)
659 if (R128_CONTEXT(ctx
)->RenderIndex
& R128_FALLBACK_BIT
)
660 _swrast_flush( ctx
);
664 /**********************************************************************/
665 /* Transition to/from hardware rasterization. */
666 /**********************************************************************/
668 static const char * const fallbackStrings
[] = {
670 "glDrawBuffer(GL_FRONT_AND_BACK)",
672 "glEnable(GL_STENCIL) without hw stencil buffer",
673 "glRenderMode(selection or feedback)",
674 "glLogicOp (mode != GL_COPY)",
675 "GL_SEPARATE_SPECULAR_COLOR",
676 "glBlendEquation(mode != ADD)",
678 "Projective texture",
679 "Rasterization disable",
683 static const char *getFallbackString(GLuint bit
)
690 return fallbackStrings
[i
];
693 void r128Fallback( GLcontext
*ctx
, GLuint bit
, GLboolean mode
)
695 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
696 r128ContextPtr rmesa
= R128_CONTEXT(ctx
);
697 GLuint oldfallback
= rmesa
->Fallback
;
700 rmesa
->Fallback
|= bit
;
701 if (oldfallback
== 0) {
702 FLUSH_BATCH( rmesa
);
703 _swsetup_Wakeup( ctx
);
704 rmesa
->RenderIndex
= ~0;
705 if ( R128_DEBUG
& DEBUG_VERBOSE_FALL
) {
706 fprintf(stderr
, "R128 begin rasterization fallback: 0x%x %s\n",
707 bit
, getFallbackString(bit
));
712 rmesa
->Fallback
&= ~bit
;
713 if (oldfallback
== bit
) {
714 _swrast_flush( ctx
);
715 tnl
->Driver
.Render
.Start
= r128RenderStart
;
716 tnl
->Driver
.Render
.PrimitiveNotify
= r128RenderPrimitive
;
717 tnl
->Driver
.Render
.Finish
= r128RenderFinish
;
719 tnl
->Driver
.Render
.BuildVertices
= _tnl_build_vertices
;
720 tnl
->Driver
.Render
.CopyPV
= _tnl_copy_pv
;
721 tnl
->Driver
.Render
.Interp
= _tnl_interp
;
723 _tnl_invalidate_vertex_state( ctx
, ~0 );
724 _tnl_invalidate_vertices( ctx
, ~0 );
725 _tnl_install_attrs( ctx
,
727 rmesa
->vertex_attr_count
,
728 rmesa
->hw_viewport
, 0 );
730 rmesa
->NewGLState
|= _R128_NEW_RENDER_STATE
;
731 if ( R128_DEBUG
& DEBUG_VERBOSE_FALL
) {
732 fprintf(stderr
, "R128 end rasterization fallback: 0x%x %s\n",
733 bit
, getFallbackString(bit
));
740 /**********************************************************************/
741 /* Initialization. */
742 /**********************************************************************/
744 void r128InitTriFuncs( GLcontext
*ctx
)
746 r128ContextPtr rmesa
= R128_CONTEXT(ctx
);
747 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
748 static int firsttime
= 1;
755 tnl
->Driver
.RunPipeline
= r128RunPipeline
;
756 tnl
->Driver
.Render
.Start
= r128RenderStart
;
757 tnl
->Driver
.Render
.Finish
= r128RenderFinish
;
758 tnl
->Driver
.Render
.PrimitiveNotify
= r128RenderPrimitive
;
759 tnl
->Driver
.Render
.ResetLineStipple
= _swrast_ResetLineStipple
;
760 tnl
->Driver
.Render
.BuildVertices
= _tnl_build_vertices
;
761 tnl
->Driver
.Render
.CopyPV
= _tnl_copy_pv
;
762 tnl
->Driver
.Render
.Interp
= _tnl_interp
;
764 _tnl_init_vertices( ctx
, ctx
->Const
.MaxArrayLockSize
+ 12,
765 (6 + 2 * ctx
->Const
.MaxTextureUnits
) * sizeof(GLfloat
) );
766 rmesa
->verts
= (char *)tnl
->clipspace
.vertex_buf
;
767 rmesa
->tnl_state
= -1;
769 rmesa
->NewGLState
|= _R128_NEW_RENDER_STATE
;