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    /* XXX: SpanRenderStart */
 353    _swrast_Triangle( ctx, &v[0], &v[1], &v[2] );
 354 }
 355
 356
 357 static void
 358 r128_fallback_line( r128ContextPtr rmesa,
 359                     r128Vertex *v0,
 360                     r128Vertex *v1 )
 361 {
 362    GLcontext *ctx = rmesa->glCtx;
 363    SWvertex v[2];
 364    _swsetup_Translate( ctx, v0, &v[0] );
 365    _swsetup_Translate( ctx, v1, &v[1] );
 366    _swrast_Line( ctx, &v[0], &v[1] );
 367 }
 368
 369
 370 static void
 371 r128_fallback_point( r128ContextPtr rmesa,
 372                      r128Vertex *v0 )
 373 {
 374    GLcontext *ctx = rmesa->glCtx;
 375    SWvertex v[1];
 376    _swsetup_Translate( ctx, v0, &v[0] );
 377    _swrast_Point( ctx, &v[0] );
 378 }
 379
 380
 381
 382 /**********************************************************************/
 383 /*               Render unclipped begin/end objects                   */
 384 /**********************************************************************/
 385
 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 );                       \
 398 } while (0)
 399 #undef LOCAL_VARS
 400 #define LOCAL_VARS                                              \
 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;       \
 405     (void) elt;
 406 #define RESET_STIPPLE
 407 #define RESET_OCCLUSION
 408 #define PRESERVE_VB_DEFS
 409 #define ELT(x) (x)
 410 #define TAG(x) r128_##x##_verts
 411 #include "tnl/t_vb_rendertmp.h"
 412 #undef ELT
 413 #undef TAG
 414 #define TAG(x) r128_##x##_elts
 415 #define ELT(x) elt[x]
 416 #include "tnl/t_vb_rendertmp.h"
 417
 418
 419 /**********************************************************************/
 420 /*                    Choose render functions                         */
 421 /**********************************************************************/
 422
 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)
 429
 430 static void r128ChooseRenderState(GLcontext *ctx)
 431 {
 432    r128ContextPtr rmesa = R128_CONTEXT(ctx);
 433    GLuint flags = ctx->_TriangleCaps;
 434    GLuint index = 0;
 435
 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;
 440
 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;
 445       }
 446
 447       /* Hook in fallbacks for specific primitives.
 448        */
 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;
 454       }
 455    }
 456
 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;
 464
 465       if (index == 0) {
 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;
 469       } else {
 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;
 473       }
 474
 475       rmesa->RenderIndex = index;
 476    }
 477 }
 478
 479 /**********************************************************************/
 480 /*                 Validate state at pipeline start                   */
 481 /**********************************************************************/
 482
 483 static void r128RunPipeline( GLcontext *ctx )
 484 {
 485    r128ContextPtr rmesa = R128_CONTEXT(ctx);
 486
 487    if (rmesa->new_state || rmesa->NewGLState & _NEW_TEXTURE)
 488       r128DDUpdateHWState( ctx );
 489
 490    if (!rmesa->Fallback && rmesa->NewGLState) {
 491       if (rmesa->NewGLState & _R128_NEW_RENDER_STATE)
 492          r128ChooseRenderState( ctx );
 493
 494       rmesa->NewGLState = 0;
 495    }
 496
 497    _tnl_run_pipeline( ctx );
 498 }
 499
 500 /**********************************************************************/
 501 /*                 High level hooks for t_vb_render.c                 */
 502 /**********************************************************************/
 503
 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.
 507  *
 508  * As the r128 uses triangles to render lines and points, it is
 509  * necessary to turn off hardware culling when rendering these
 510  * primitives.
 511  */
 512
 513 static void r128RasterPrimitive( GLcontext *ctx, GLuint hwprim )
 514 {
 515    r128ContextPtr rmesa = R128_CONTEXT(ctx);
 516
 517    rmesa->setup.dp_gui_master_cntl_c &= ~R128_GMC_BRUSH_NONE;
 518
 519    if ( ctx->Polygon.StippleFlag && hwprim == GL_TRIANGLES ) {
 520       rmesa->setup.dp_gui_master_cntl_c |= R128_GMC_BRUSH_32x32_MONO_FG_LA;
 521    }
 522    else {
 523       rmesa->setup.dp_gui_master_cntl_c |= R128_GMC_BRUSH_SOLID_COLOR;
 524    }
 525
 526    rmesa->new_state |= R128_NEW_CONTEXT;
 527    rmesa->dirty |= R128_UPLOAD_CONTEXT;
 528
 529    if (rmesa->hw_primitive != hwprim) {
 530       FLUSH_BATCH( rmesa );
 531       rmesa->hw_primitive = hwprim;
 532    }
 533 }
 534
 535 static void r128RenderPrimitive( GLcontext *ctx, GLenum prim )
 536 {
 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))
 541       return;
 542    r128RasterPrimitive( ctx, hw );
 543 }
 544
 545 #define EMIT_ATTR( ATTR, STYLE, VF, SIZE )                              \
 546 do {                                                                    \
 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++;                                          \
 550    vc_frmt |= (VF);                                                     \
 551    offset += (SIZE);                                                    \
 552 } while (0)
 553
 554 #define EMIT_PAD( SIZE )                                                \
 555 do {                                                                    \
 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++;                                          \
 560    offset += (SIZE);                                                    \
 561 } while (0)
 562
 563 static void r128RenderStart( GLcontext *ctx )
 564 {
 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;
 569    GLuint vc_frmt = 0;
 570    GLboolean fallback_projtex = GL_FALSE;
 571    GLuint offset = 0;
 572
 573    /* Important: */
 574    VB->AttribPtr[VERT_ATTRIB_POS] = VB->NdcPtr;
 575    rmesa->vertex_attr_count = 0;
 576    rmesa->specoffset = 0;
 577
 578    /* EMIT_ATTR's must be in order as they tell t_vertex.c how to
 579     * build up a hardware vertex.
 580     */
 581    if ( index & _TNL_BITS_TEX_ANY )
 582       EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_4F_VIEWPORT, R128_CCE_VC_FRMT_RHW, 16 );
 583    else
 584       EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_3F_VIEWPORT, 0, 12 );
 585
 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 );
 590 #else
 591    EMIT_ATTR( _TNL_ATTRIB_COLOR0, EMIT_4UB_4F_ARGB,
 592       R128_CCE_VC_FRMT_DIFFUSE_ARGB, 4 );
 593 #endif
 594
 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 );
 601       } else
 602          EMIT_PAD( 3 );
 603
 604       if (index & _TNL_BIT_FOG)
 605          EMIT_ATTR( _TNL_ATTRIB_FOG, EMIT_1UB_1F, R128_CCE_VC_FRMT_SPEC_FRGB,
 606                     1 );
 607       else
 608          EMIT_PAD( 1 );
 609 #else
 610       if (index & _TNL_BIT_FOG)
 611          EMIT_ATTR( _TNL_ATTRIB_FOG, EMIT_1UB_1F, R128_CCE_VC_FRMT_SPEC_FRGB,
 612                     1 );
 613       else
 614          EMIT_PAD( 1 );
 615
 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 );
 620       } else
 621          EMIT_PAD( 3 );
 622 #endif
 623    }
 624
 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 );
 629    }
 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 );
 634    }
 635
 636    /* projective textures are not supported by the hardware */
 637    FALLBACK( rmesa, R128_FALLBACK_PROJTEX, fallback_projtex );
 638
 639    /* Only need to change the vertex emit code if there has been a
 640     * statechange to a TNL index.
 641     */
 642    if ( index != rmesa->tnl_state ) {
 643       FLUSH_BATCH( rmesa );
 644       rmesa->dirty |= R128_UPLOAD_CONTEXT;
 645
 646       rmesa->vertex_size =
 647          _tnl_install_attrs( ctx,
 648                              rmesa->vertex_attrs,
 649                              rmesa->vertex_attr_count,
 650                              rmesa->hw_viewport, 0 );
 651       rmesa->vertex_size >>= 2;
 652
 653       rmesa->vertex_format = vc_frmt;
 654    }
 655 }
 656
 657 static void r128RenderFinish( GLcontext *ctx )
 658 {
 659    if (R128_CONTEXT(ctx)->RenderIndex & R128_FALLBACK_BIT)
 660       _swrast_flush( ctx );
 661 }
 662
 663
 664 /**********************************************************************/
 665 /*           Transition to/from hardware rasterization.               */
 666 /**********************************************************************/
 667
 668 static const char * const fallbackStrings[] = {
 669    "Texture mode",
 670    "glDrawBuffer(GL_FRONT_AND_BACK)",
 671    "glReadBuffer",
 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",
 677    "glBlendFunc(mode != ADD)",
 678    "Projective texture",
 679    "Rasterization disable",
 680 };
 681
 682
 683 static const char *getFallbackString(GLuint bit)
 684 {
 685    int i = 0;
 686    while (bit > 1) {
 687       i++;
 688       bit >>= 1;
 689    }
 690    return fallbackStrings[i];
 691 }
 692
 693 void r128Fallback( GLcontext *ctx, GLuint bit, GLboolean mode )
 694 {
 695    TNLcontext *tnl = TNL_CONTEXT(ctx);
 696    r128ContextPtr rmesa = R128_CONTEXT(ctx);
 697    GLuint oldfallback = rmesa->Fallback;
 698
 699    if (mode) {
 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));
 708          }
 709       }
 710    }
 711    else {
 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;
 718
 719          tnl->Driver.Render.BuildVertices = _tnl_build_vertices;
 720          tnl->Driver.Render.CopyPV = _tnl_copy_pv;
 721          tnl->Driver.Render.Interp = _tnl_interp;
 722
 723          _tnl_invalidate_vertex_state( ctx, ~0 );
 724          _tnl_invalidate_vertices( ctx, ~0 );
 725          _tnl_install_attrs( ctx,
 726                              rmesa->vertex_attrs,
 727                              rmesa->vertex_attr_count,
 728                              rmesa->hw_viewport, 0 );
 729
 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));
 734          }
 735       }
 736    }
 737 }
 738
 739
 740 /**********************************************************************/
 741 /*                            Initialization.                         */
 742 /**********************************************************************/
 743
 744 void r128InitTriFuncs( GLcontext *ctx )
 745 {
 746    r128ContextPtr rmesa = R128_CONTEXT(ctx);
 747    TNLcontext *tnl = TNL_CONTEXT(ctx);
 748    static int firsttime = 1;
 749
 750    if (firsttime) {
 751       init_rast_tab();
 752       firsttime = 0;
 753    }
 754
 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;
 763
 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;
 768
 769    rmesa->NewGLState |= _R128_NEW_RENDER_STATE;
 770 }