src/mesa/drivers/dri/r128/r128_tris.c

   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 /**************************************************************************
   3
   4 Copyright 2000, 2001 ATI Technologies Inc., Ontario, Canada, and
   5                      VA Linux Systems Inc., Fremont, California.
   6
   7 All Rights Reserved.
   8
   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:
  15
  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
  18 Software.
  19
  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.
  27
  28 **************************************************************************/
  29
  30 /*
  31  * Authors:
  32  *   Keith Whitwell <keith@tungstengraphics.com>
  33  *
  34  */
  35
  36 #include "glheader.h"
  37 #include "mtypes.h"
  38 #include "colormac.h"
  39 #include "macros.h"
  40
  41 #include "swrast/swrast.h"
  42 #include "swrast_setup/swrast_setup.h"
  43 #include "tnl/tnl.h"
  44 #include "tnl/t_context.h"
  45 #include "tnl/t_pipeline.h"
  46
  47 #include "r128_tris.h"
  48 #include "r128_state.h"
  49 #include "r128_tex.h"
  50 #include "r128_ioctl.h"
  51
  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,
  63 };
  64
  65 static void r128RasterPrimitive( GLcontext *ctx, GLuint hwprim );
  66 static void r128RenderPrimitive( GLcontext *ctx, GLenum prim );
  67
  68
  69 /***********************************************************************
  70  *                    Emit primitives as inline vertices               *
  71  ***********************************************************************/
  72
  73 #define HAVE_QUADS 0
  74 #define HAVE_LINES 1
  75 #define HAVE_POINTS 1
  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 )
  80 #undef LOCAL_VARS
  81 #define LOCAL_VARS                                              \
  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
  86 #undef TAG
  87 #define TAG(x) r128_##x
  88 #include "tnl_dd/t_dd_triemit.h"
  89 #undef TAG
  90 #undef LOCAL_VARS
  91
  92
  93 /***********************************************************************
  94  *          Macros for t_dd_tritmp.h to draw basic primitives          *
  95  ***********************************************************************/
  96
  97 #define TRI( a, b, c )                          \
  98 do {                                            \
  99    if (DO_FALLBACK)                             \
 100       rmesa->draw_tri( rmesa, a, b, c );        \
 101    else                                         \
 102       r128_triangle( rmesa, a, b, c );          \
 103 } while (0)
 104
 105 #define QUAD( a, b, c, d )                      \
 106 do {                                            \
 107    if (DO_FALLBACK) {                           \
 108       rmesa->draw_tri( rmesa, a, b, d );        \
 109       rmesa->draw_tri( rmesa, b, c, d );        \
 110    } else                                       \
 111       r128_quad( rmesa, a, b, c, d );           \
 112 } while (0)
 113
 114 #define LINE( v0, v1 )                          \
 115 do {                                            \
 116    if (DO_FALLBACK)                             \
 117       rmesa->draw_line( rmesa, v0, v1 );        \
 118    else                                         \
 119       r128_line( rmesa, v0, v1 );               \
 120 } while (0)
 121
 122 #define POINT( v0 )                             \
 123 do {                                            \
 124    if (DO_FALLBACK)                             \
 125       rmesa->draw_point( rmesa, v0 );           \
 126    else                                         \
 127       r128_point( rmesa, v0 );                  \
 128 } while (0)
 129
 130
 131 /***********************************************************************
 132  *              Build render functions from dd templates               *
 133  ***********************************************************************/
 134
 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
 140
 141
 142 static struct {
 143    tnl_points_func              points;
 144    tnl_line_func                line;
 145    tnl_triangle_func    triangle;
 146    tnl_quad_func                quad;
 147 } rast_tab[R128_MAX_TRIFUNC];
 148
 149
 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)
 154 #define DO_FLAT      0
 155 #define DO_TRI       1
 156 #define DO_QUAD      1
 157 #define DO_LINE      1
 158 #define DO_POINTS    1
 159 #define DO_FULL_QUAD 1
 160
 161 #define HAVE_RGBA   1
 162 #define HAVE_SPEC   1
 163 #define HAVE_BACK_COLORS  0
 164 #define HAVE_HW_FLATSHADE 1
 165 #define VERTEX r128Vertex
 166 #define TAB rast_tab
 167
 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)))
 176
 177 #define VERT_SET_RGBA( v, c )                                   \
 178 do {                                                            \
 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]);              \
 184 } while (0)
 185
 186 #define VERT_COPY_RGBA( v0, v1 ) v0->ui[coloroffset] = v1->ui[coloroffset]
 187
 188 #define VERT_SET_SPEC( v0, c )                                  \
 189 do {                                                            \
 190    if (havespec) {                                              \
 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]);             \
 195    }                                                            \
 196 } while (0)
 197 #define VERT_COPY_SPEC( v0, v1 )                        \
 198 do {                                                    \
 199    if (havespec) {                                      \
 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;                       \
 205    }                                                    \
 206 } while (0)
 207
 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.
 210  */
 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]
 215
 216
 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;
 225
 226 /***********************************************************************
 227  *                Helpers for rendering unfilled primitives            *
 228  ***********************************************************************/
 229
 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
 234 #define TAG(x) x
 235 #include "tnl_dd/t_dd_unfilled.h"
 236 #undef IND
 237
 238
 239 /***********************************************************************
 240  *                      Generate GL render functions                   *
 241  ***********************************************************************/
 242
 243
 244 #define IND (0)
 245 #define TAG(x) x
 246 #include "tnl_dd/t_dd_tritmp.h"
 247
 248 #define IND (R128_OFFSET_BIT)
 249 #define TAG(x) x##_offset
 250 #include "tnl_dd/t_dd_tritmp.h"
 251
 252 #define IND (R128_TWOSIDE_BIT)
 253 #define TAG(x) x##_twoside
 254 #include "tnl_dd/t_dd_tritmp.h"
 255
 256 #define IND (R128_TWOSIDE_BIT|R128_OFFSET_BIT)
 257 #define TAG(x) x##_twoside_offset
 258 #include "tnl_dd/t_dd_tritmp.h"
 259
 260 #define IND (R128_UNFILLED_BIT)
 261 #define TAG(x) x##_unfilled
 262 #include "tnl_dd/t_dd_tritmp.h"
 263
 264 #define IND (R128_OFFSET_BIT|R128_UNFILLED_BIT)
 265 #define TAG(x) x##_offset_unfilled
 266 #include "tnl_dd/t_dd_tritmp.h"
 267
 268 #define IND (R128_TWOSIDE_BIT|R128_UNFILLED_BIT)
 269 #define TAG(x) x##_twoside_unfilled
 270 #include "tnl_dd/t_dd_tritmp.h"
 271
 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"
 275
 276 #define IND (R128_FALLBACK_BIT)
 277 #define TAG(x) x##_fallback
 278 #include "tnl_dd/t_dd_tritmp.h"
 279
 280 #define IND (R128_OFFSET_BIT|R128_FALLBACK_BIT)
 281 #define TAG(x) x##_offset_fallback
 282 #include "tnl_dd/t_dd_tritmp.h"
 283
 284 #define IND (R128_TWOSIDE_BIT|R128_FALLBACK_BIT)
 285 #define TAG(x) x##_twoside_fallback
 286 #include "tnl_dd/t_dd_tritmp.h"
 287
 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"
 291
 292 #define IND (R128_UNFILLED_BIT|R128_FALLBACK_BIT)
 293 #define TAG(x) x##_unfilled_fallback
 294 #include "tnl_dd/t_dd_tritmp.h"
 295
 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"
 299
 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"
 303
 304 #define IND (R128_TWOSIDE_BIT|R128_OFFSET_BIT|R128_UNFILLED_BIT| \
 305              R128_FALLBACK_BIT)
 306 #define TAG(x) x##_twoside_offset_unfilled_fallback
 307 #include "tnl_dd/t_dd_tritmp.h"
 308
 309
 310 static void init_rast_tab( void )
 311 {
 312    init();
 313    init_offset();
 314    init_twoside();
 315    init_twoside_offset();
 316    init_unfilled();
 317    init_offset_unfilled();
 318    init_twoside_unfilled();
 319    init_twoside_offset_unfilled();
 320    init_fallback();
 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();
 328 }
 329
 330
 331
 332 /***********************************************************************
 333  *                    Rasterization fallback helpers                   *
 334  ***********************************************************************/
 335
 336
 337 /* This code is hit only when a mix of accelerated and unaccelerated
 338  * primitives are being drawn, and only for the unaccelerated
 339  * primitives.
 340  */
 341 static void
 342 r128_fallback_tri( r128ContextPtr rmesa,
 343                      r128Vertex *v0,
 344                      r128Vertex *v1,
 345                      r128Vertex *v2 )
 346 {
 347    GLcontext *ctx = rmesa->glCtx;
 348    SWvertex v[3];
 349    _swsetup_Translate( ctx, v0, &v[0] );
 350    _swsetup_Translate( ctx, v1, &v[1] );
 351    _swsetup_Translate( ctx, v2, &v[2] );
 352    _swrast_Triangle( ctx, &v[0], &v[1], &v[2] );
 353 }
 354
 355
 356 static void
 357 r128_fallback_line( r128ContextPtr rmesa,
 358                     r128Vertex *v0,
 359                     r128Vertex *v1 )
 360 {
 361    GLcontext *ctx = rmesa->glCtx;
 362    SWvertex v[2];
 363    _swsetup_Translate( ctx, v0, &v[0] );
 364    _swsetup_Translate( ctx, v1, &v[1] );
 365    _swrast_Line( ctx, &v[0], &v[1] );
 366 }
 367
 368
 369 static void
 370 r128_fallback_point( r128ContextPtr rmesa,
 371                      r128Vertex *v0 )
 372 {
 373    GLcontext *ctx = rmesa->glCtx;
 374    SWvertex v[1];
 375    _swsetup_Translate( ctx, v0, &v[0] );
 376    _swrast_Point( ctx, &v[0] );
 377 }
 378
 379
 380
 381 /**********************************************************************/
 382 /*               Render unclipped begin/end objects                   */
 383 /**********************************************************************/
 384
 385 #define RENDER_POINTS( start, count )           \
 386    for ( ; start < count ; start++)             \
 387       r128_point( rmesa, VERT(start) )
 388 #define RENDER_LINE( v0, v1 ) \
 389    r128_line( rmesa, VERT(v0), VERT(v1) )
 390 #define RENDER_TRI( v0, v1, v2 )  \
 391    r128_triangle( rmesa, VERT(v0), VERT(v1), VERT(v2) )
 392 #define RENDER_QUAD( v0, v1, v2, v3 ) \
 393    r128_quad( rmesa, VERT(v0), VERT(v1), VERT(v2), VERT(v3) )
 394 #define INIT(x) do {                                    \
 395    if (0) fprintf(stderr, "%s\n", __FUNCTION__);        \
 396    r128RenderPrimitive( ctx, x );                       \
 397 } while (0)
 398 #undef LOCAL_VARS
 399 #define LOCAL_VARS                                              \
 400     r128ContextPtr rmesa = R128_CONTEXT(ctx);           \
 401     const GLuint vertsize = rmesa->vertex_size;         \
 402     const char *vertptr = (char *)rmesa->verts;         \
 403     const GLuint * const elt = TNL_CONTEXT(ctx)->vb.Elts;       \
 404     (void) elt;
 405 #define RESET_STIPPLE
 406 #define RESET_OCCLUSION
 407 #define PRESERVE_VB_DEFS
 408 #define ELT(x) (x)
 409 #define TAG(x) r128_##x##_verts
 410 #include "tnl/t_vb_rendertmp.h"
 411 #undef ELT
 412 #undef TAG
 413 #define TAG(x) r128_##x##_elts
 414 #define ELT(x) elt[x]
 415 #include "tnl/t_vb_rendertmp.h"
 416
 417
 418 /**********************************************************************/
 419 /*                    Choose render functions                         */
 420 /**********************************************************************/
 421
 422 #define POINT_FALLBACK (DD_POINT_SMOOTH)
 423 #define LINE_FALLBACK (DD_LINE_STIPPLE|DD_LINE_SMOOTH)
 424 #define TRI_FALLBACK (DD_TRI_SMOOTH)
 425 #define ANY_FALLBACK_FLAGS (POINT_FALLBACK|LINE_FALLBACK|TRI_FALLBACK)
 426 #define ANY_RASTER_FLAGS (DD_TRI_LIGHT_TWOSIDE|DD_TRI_OFFSET|DD_TRI_UNFILLED)
 427 #define _R128_NEW_RENDER_STATE (ANY_FALLBACK_FLAGS | ANY_RASTER_FLAGS)
 428
 429 static void r128ChooseRenderState(GLcontext *ctx)
 430 {
 431    r128ContextPtr rmesa = R128_CONTEXT(ctx);
 432    GLuint flags = ctx->_TriangleCaps;
 433    GLuint index = 0;
 434
 435    if (flags & (ANY_RASTER_FLAGS|ANY_FALLBACK_FLAGS)) {
 436       rmesa->draw_point = r128_point;
 437       rmesa->draw_line = r128_line;
 438       rmesa->draw_tri = r128_triangle;
 439
 440       if (flags & ANY_RASTER_FLAGS) {
 441          if (flags & DD_TRI_LIGHT_TWOSIDE) index |= R128_TWOSIDE_BIT;
 442          if (flags & DD_TRI_OFFSET)        index |= R128_OFFSET_BIT;
 443          if (flags & DD_TRI_UNFILLED)      index |= R128_UNFILLED_BIT;
 444       }
 445
 446       /* Hook in fallbacks for specific primitives.
 447        */
 448       if (flags & (POINT_FALLBACK|LINE_FALLBACK|TRI_FALLBACK)) {
 449          if (flags & POINT_FALLBACK) rmesa->draw_point = r128_fallback_point;
 450          if (flags & LINE_FALLBACK)  rmesa->draw_line = r128_fallback_line;
 451          if (flags & TRI_FALLBACK)   rmesa->draw_tri = r128_fallback_tri;
 452          index |= R128_FALLBACK_BIT;
 453       }
 454    }
 455
 456    if (index != rmesa->RenderIndex) {
 457       TNLcontext *tnl = TNL_CONTEXT(ctx);
 458       tnl->Driver.Render.Points = rast_tab[index].points;
 459       tnl->Driver.Render.Line = rast_tab[index].line;
 460       tnl->Driver.Render.ClippedLine = rast_tab[index].line;
 461       tnl->Driver.Render.Triangle = rast_tab[index].triangle;
 462       tnl->Driver.Render.Quad = rast_tab[index].quad;
 463
 464       if (index == 0) {
 465          tnl->Driver.Render.PrimTabVerts = r128_render_tab_verts;
 466          tnl->Driver.Render.PrimTabElts = r128_render_tab_elts;
 467          tnl->Driver.Render.ClippedPolygon = r128_fast_clipped_poly;
 468       } else {
 469          tnl->Driver.Render.PrimTabVerts = _tnl_render_tab_verts;
 470          tnl->Driver.Render.PrimTabElts = _tnl_render_tab_elts;
 471          tnl->Driver.Render.ClippedPolygon = _tnl_RenderClippedPolygon;
 472       }
 473
 474       rmesa->RenderIndex = index;
 475    }
 476 }
 477
 478 /**********************************************************************/
 479 /*                 Validate state at pipeline start                   */
 480 /**********************************************************************/
 481
 482 static void r128RunPipeline( GLcontext *ctx )
 483 {
 484    r128ContextPtr rmesa = R128_CONTEXT(ctx);
 485
 486    if (rmesa->new_state || rmesa->NewGLState & _NEW_TEXTURE)
 487       r128DDUpdateHWState( ctx );
 488
 489    if (!rmesa->Fallback && rmesa->NewGLState) {
 490       if (rmesa->NewGLState & _R128_NEW_RENDER_STATE)
 491          r128ChooseRenderState( ctx );
 492
 493       rmesa->NewGLState = 0;
 494    }
 495
 496    _tnl_run_pipeline( ctx );
 497 }
 498
 499 /**********************************************************************/
 500 /*                 High level hooks for t_vb_render.c                 */
 501 /**********************************************************************/
 502
 503 /* This is called when Mesa switches between rendering triangle
 504  * primitives (such as GL_POLYGON, GL_QUADS, GL_TRIANGLE_STRIP, etc),
 505  * and lines, points and bitmaps.
 506  *
 507  * As the r128 uses triangles to render lines and points, it is
 508  * necessary to turn off hardware culling when rendering these
 509  * primitives.
 510  */
 511
 512 static void r128RasterPrimitive( GLcontext *ctx, GLuint hwprim )
 513 {
 514    r128ContextPtr rmesa = R128_CONTEXT(ctx);
 515
 516    rmesa->setup.dp_gui_master_cntl_c &= ~R128_GMC_BRUSH_NONE;
 517
 518    if ( ctx->Polygon.StippleFlag && hwprim == GL_TRIANGLES ) {
 519       rmesa->setup.dp_gui_master_cntl_c |= R128_GMC_BRUSH_32x32_MONO_FG_LA;
 520    }
 521    else {
 522       rmesa->setup.dp_gui_master_cntl_c |= R128_GMC_BRUSH_SOLID_COLOR;
 523    }
 524
 525    rmesa->new_state |= R128_NEW_CONTEXT;
 526    rmesa->dirty |= R128_UPLOAD_CONTEXT;
 527
 528    if (rmesa->hw_primitive != hwprim) {
 529       FLUSH_BATCH( rmesa );
 530       rmesa->hw_primitive = hwprim;
 531    }
 532 }
 533
 534 static void r128RenderPrimitive( GLcontext *ctx, GLenum prim )
 535 {
 536    r128ContextPtr rmesa = R128_CONTEXT(ctx);
 537    GLuint hw = hw_prim[prim];
 538    rmesa->render_primitive = prim;
 539    if (prim >= GL_TRIANGLES && (ctx->_TriangleCaps & DD_TRI_UNFILLED))
 540       return;
 541    r128RasterPrimitive( ctx, hw );
 542 }
 543
 544 #define EMIT_ATTR( ATTR, STYLE, VF, SIZE )                              \
 545 do {                                                                    \
 546    rmesa->vertex_attrs[rmesa->vertex_attr_count].attrib = (ATTR);       \
 547    rmesa->vertex_attrs[rmesa->vertex_attr_count].format = (STYLE);      \
 548    rmesa->vertex_attr_count++;                                          \
 549    vc_frmt |= (VF);                                                     \
 550    offset += (SIZE);                                                    \
 551 } while (0)
 552
 553 #define EMIT_PAD( SIZE )                                                \
 554 do {                                                                    \
 555    rmesa->vertex_attrs[rmesa->vertex_attr_count].attrib = 0;            \
 556    rmesa->vertex_attrs[rmesa->vertex_attr_count].format = EMIT_PAD;     \
 557    rmesa->vertex_attrs[rmesa->vertex_attr_count].offset = (SIZE);       \
 558    rmesa->vertex_attr_count++;                                          \
 559    offset += (SIZE);                                                    \
 560 } while (0)
 561
 562 static void r128RenderStart( GLcontext *ctx )
 563 {
 564    r128ContextPtr rmesa = R128_CONTEXT(ctx);
 565    TNLcontext *tnl = TNL_CONTEXT(ctx);
 566    struct vertex_buffer *VB = &tnl->vb;
 567    GLuint index = tnl->render_inputs;
 568    GLuint vc_frmt = 0;
 569    GLboolean fallback_projtex = GL_FALSE;
 570    GLuint offset = 0;
 571
 572    /* Important: */
 573    VB->AttribPtr[VERT_ATTRIB_POS] = VB->NdcPtr;
 574    rmesa->vertex_attr_count = 0;
 575    rmesa->specoffset = 0;
 576
 577    /* EMIT_ATTR's must be in order as they tell t_vertex.c how to
 578     * build up a hardware vertex.
 579     */
 580    if ( index & _TNL_BITS_TEX_ANY )
 581       EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_4F_VIEWPORT, R128_CCE_VC_FRMT_RHW, 16 );
 582    else
 583       EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_3F_VIEWPORT, 0, 12 );
 584
 585    rmesa->coloroffset = offset;
 586 #if MESA_LITTLE_ENDIAN
 587    EMIT_ATTR( _TNL_ATTRIB_COLOR0, EMIT_4UB_4F_BGRA,
 588       R128_CCE_VC_FRMT_DIFFUSE_ARGB, 4 );
 589 #else
 590    EMIT_ATTR( _TNL_ATTRIB_COLOR0, EMIT_4UB_4F_ARGB,
 591       R128_CCE_VC_FRMT_DIFFUSE_ARGB, 4 );
 592 #endif
 593
 594    if ( index & (_TNL_BIT_COLOR1|_TNL_BIT_FOG) ) {
 595 #if MESA_LITTLE_ENDIAN
 596       if ( index & _TNL_BIT_COLOR1) {
 597          rmesa->specoffset = offset;
 598          EMIT_ATTR( _TNL_ATTRIB_COLOR1, EMIT_3UB_3F_RGB,
 599             R128_CCE_VC_FRMT_SPEC_FRGB, 3 );
 600       } else
 601          EMIT_PAD( 3 );
 602
 603       if (index & _TNL_BIT_FOG)
 604          EMIT_ATTR( _TNL_ATTRIB_FOG, EMIT_1UB_1F, R128_CCE_VC_FRMT_SPEC_FRGB,
 605                     1 );
 606       else
 607          EMIT_PAD( 1 );
 608 #else
 609       if (index & _TNL_BIT_FOG)
 610          EMIT_ATTR( _TNL_ATTRIB_FOG, EMIT_1UB_1F, R128_CCE_VC_FRMT_SPEC_FRGB,
 611                     1 );
 612       else
 613          EMIT_PAD( 1 );
 614
 615       if ( index & _TNL_BIT_COLOR1) {
 616          rmesa->specoffset = offset;
 617          EMIT_ATTR( _TNL_ATTRIB_COLOR1, EMIT_3UB_3F_RGB,
 618             R128_CCE_VC_FRMT_SPEC_FRGB, 3 );
 619       } else
 620          EMIT_PAD( 3 );
 621 #endif
 622    }
 623
 624    if ( index & _TNL_BIT_TEX(rmesa->tmu_source[0]) ) {
 625       if ( VB->TexCoordPtr[rmesa->tmu_source[0]]->size > 2 )
 626          fallback_projtex = GL_TRUE;
 627       EMIT_ATTR( _TNL_ATTRIB_TEX0, EMIT_2F, R128_CCE_VC_FRMT_S_T, 8 );
 628    }
 629    if ( index & _TNL_BIT_TEX(rmesa->tmu_source[1]) ) {
 630       if ( VB->TexCoordPtr[rmesa->tmu_source[1]]->size > 2 )
 631          fallback_projtex = GL_TRUE;
 632       EMIT_ATTR( _TNL_ATTRIB_TEX1, EMIT_2F, R128_CCE_VC_FRMT_S2_T2, 8 );
 633    }
 634
 635    /* projective textures are not supported by the hardware */
 636    FALLBACK( rmesa, R128_FALLBACK_PROJTEX, fallback_projtex );
 637
 638    /* Only need to change the vertex emit code if there has been a
 639     * statechange to a TNL index.
 640     */
 641    if ( index != rmesa->tnl_state ) {
 642       FLUSH_BATCH( rmesa );
 643       rmesa->dirty |= R128_UPLOAD_CONTEXT;
 644
 645       rmesa->vertex_size =
 646          _tnl_install_attrs( ctx,
 647                              rmesa->vertex_attrs,
 648                              rmesa->vertex_attr_count,
 649                              rmesa->hw_viewport, 0 );
 650       rmesa->vertex_size >>= 2;
 651
 652       rmesa->vertex_format = vc_frmt;
 653    }
 654 }
 655
 656 static void r128RenderFinish( GLcontext *ctx )
 657 {
 658    if (R128_CONTEXT(ctx)->RenderIndex & R128_FALLBACK_BIT)
 659       _swrast_flush( ctx );
 660 }
 661
 662
 663 /**********************************************************************/
 664 /*           Transition to/from hardware rasterization.               */
 665 /**********************************************************************/
 666
 667 static const char * const fallbackStrings[] = {
 668    "Texture mode",
 669    "glDrawBuffer(GL_FRONT_AND_BACK)",
 670    "glReadBuffer",
 671    "glEnable(GL_STENCIL) without hw stencil buffer",
 672    "glRenderMode(selection or feedback)",
 673    "glLogicOp (mode != GL_COPY)",
 674    "GL_SEPARATE_SPECULAR_COLOR",
 675    "glBlendEquation(mode != ADD)",
 676    "glBlendFunc",
 677    "Projective texture",
 678    "Rasterization disable",
 679 };
 680
 681
 682 static const char *getFallbackString(GLuint bit)
 683 {
 684    int i = 0;
 685    while (bit > 1) {
 686       i++;
 687       bit >>= 1;
 688    }
 689    return fallbackStrings[i];
 690 }
 691
 692 void r128Fallback( GLcontext *ctx, GLuint bit, GLboolean mode )
 693 {
 694    TNLcontext *tnl = TNL_CONTEXT(ctx);
 695    r128ContextPtr rmesa = R128_CONTEXT(ctx);
 696    GLuint oldfallback = rmesa->Fallback;
 697
 698    if (mode) {
 699       rmesa->Fallback |= bit;
 700       if (oldfallback == 0) {
 701          FLUSH_BATCH( rmesa );
 702          _swsetup_Wakeup( ctx );
 703          rmesa->RenderIndex = ~0;
 704          if ( R128_DEBUG & DEBUG_VERBOSE_FALL ) {
 705              fprintf(stderr, "R128 begin rasterization fallback: 0x%x %s\n",
 706                      bit, getFallbackString(bit));
 707          }
 708       }
 709    }
 710    else {
 711       rmesa->Fallback &= ~bit;
 712       if (oldfallback == bit) {
 713          _swrast_flush( ctx );
 714          tnl->Driver.Render.Start = r128RenderStart;
 715          tnl->Driver.Render.PrimitiveNotify = r128RenderPrimitive;
 716          tnl->Driver.Render.Finish = r128RenderFinish;
 717
 718          tnl->Driver.Render.BuildVertices = _tnl_build_vertices;
 719          tnl->Driver.Render.CopyPV = _tnl_copy_pv;
 720          tnl->Driver.Render.Interp = _tnl_interp;
 721
 722          _tnl_invalidate_vertex_state( ctx, ~0 );
 723          _tnl_invalidate_vertices( ctx, ~0 );
 724          _tnl_install_attrs( ctx,
 725                              rmesa->vertex_attrs,
 726                              rmesa->vertex_attr_count,
 727                              rmesa->hw_viewport, 0 );
 728
 729          rmesa->NewGLState |= _R128_NEW_RENDER_STATE;
 730          if ( R128_DEBUG & DEBUG_VERBOSE_FALL ) {
 731              fprintf(stderr, "R128 end rasterization fallback: 0x%x %s\n",
 732                      bit, getFallbackString(bit));
 733          }
 734       }
 735    }
 736 }
 737
 738
 739 /**********************************************************************/
 740 /*                            Initialization.                         */
 741 /**********************************************************************/
 742
 743 void r128InitTriFuncs( GLcontext *ctx )
 744 {
 745    r128ContextPtr rmesa = R128_CONTEXT(ctx);
 746    TNLcontext *tnl = TNL_CONTEXT(ctx);
 747    static int firsttime = 1;
 748
 749    if (firsttime) {
 750       init_rast_tab();
 751       firsttime = 0;
 752    }
 753
 754    tnl->Driver.RunPipeline = r128RunPipeline;
 755    tnl->Driver.Render.Start = r128RenderStart;
 756    tnl->Driver.Render.Finish = r128RenderFinish;
 757    tnl->Driver.Render.PrimitiveNotify = r128RenderPrimitive;
 758    tnl->Driver.Render.ResetLineStipple = _swrast_ResetLineStipple;
 759    tnl->Driver.Render.BuildVertices = _tnl_build_vertices;
 760    tnl->Driver.Render.CopyPV = _tnl_copy_pv;
 761    tnl->Driver.Render.Interp = _tnl_interp;
 762
 763    _tnl_init_vertices( ctx, ctx->Const.MaxArrayLockSize + 12,
 764                        (6 + 2 * ctx->Const.MaxTextureUnits) * sizeof(GLfloat) );
 765    rmesa->verts = (char *)tnl->clipspace.vertex_buf;
 766    rmesa->tnl_state = -1;
 767
 768    rmesa->NewGLState |= _R128_NEW_RENDER_STATE;
 769 }