src/mesa/drivers/dri/r200/r200_swtcl.c

   1 /*
   2 Copyright (C) The Weather Channel, Inc.  2002.  All Rights Reserved.
   3
   4 The Weather Channel (TM) funded Tungsten Graphics to develop the
   5 initial release of the Radeon 8500 driver under the XFree86 license.
   6 This notice must be preserved.
   7
   8 Permission is hereby granted, free of charge, to any person obtaining
   9 a copy of this software and associated documentation files (the
  10 "Software"), to deal in the Software without restriction, including
  11 without limitation the rights to use, copy, modify, merge, publish,
  12 distribute, sublicense, and/or sell copies of the Software, and to
  13 permit persons to whom the Software is furnished to do so, subject to
  14 the following conditions:
  15
  16 The above copyright notice and this permission notice (including the
  17 next paragraph) shall be included in all copies or substantial
  18 portions of the Software.
  19
  20 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  23 IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
  24 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27
  28 **************************************************************************/
  29
  30 /*
  31  * Authors:
  32  *   Keith Whitwell <keith@tungstengraphics.com>
  33  */
  34
  35 #include "main/glheader.h"
  36 #include "main/mtypes.h"
  37 #include "main/colormac.h"
  38 #include "main/enums.h"
  39 #include "main/image.h"
  40 #include "main/imports.h"
  41 #include "main/macros.h"
  42 #include "main/simple_list.h"
  43
  44 #include "swrast/s_context.h"
  45 #include "swrast/s_fog.h"
  46 #include "swrast_setup/swrast_setup.h"
  47 #include "math/m_translate.h"
  48 #include "tnl/tnl.h"
  49 #include "tnl/t_context.h"
  50 #include "tnl/t_pipeline.h"
  51
  52 #include "r200_context.h"
  53 #include "r200_ioctl.h"
  54 #include "r200_state.h"
  55 #include "r200_swtcl.h"
  56 #include "r200_tcl.h"
  57
  58
  59 /***********************************************************************
  60  *                         Initialization
  61  ***********************************************************************/
  62
  63 #define EMIT_ATTR( ATTR, STYLE, F0 )                                    \
  64 do {                                                                    \
  65    rmesa->radeon.swtcl.vertex_attrs[rmesa->radeon.swtcl.vertex_attr_count].attrib = (ATTR);     \
  66    rmesa->radeon.swtcl.vertex_attrs[rmesa->radeon.swtcl.vertex_attr_count].format = (STYLE);    \
  67    rmesa->radeon.swtcl.vertex_attr_count++;                                     \
  68    fmt_0 |= F0;                                                         \
  69 } while (0)
  70
  71 #define EMIT_PAD( N )                                                   \
  72 do {                                                                    \
  73    rmesa->radeon.swtcl.vertex_attrs[rmesa->radeon.swtcl.vertex_attr_count].attrib = 0;          \
  74    rmesa->radeon.swtcl.vertex_attrs[rmesa->radeon.swtcl.vertex_attr_count].format = EMIT_PAD;   \
  75    rmesa->radeon.swtcl.vertex_attrs[rmesa->radeon.swtcl.vertex_attr_count].offset = (N);                \
  76    rmesa->radeon.swtcl.vertex_attr_count++;                                     \
  77 } while (0)
  78
  79 static void r200SetVertexFormat( GLcontext *ctx )
  80 {
  81    r200ContextPtr rmesa = R200_CONTEXT( ctx );
  82    TNLcontext *tnl = TNL_CONTEXT(ctx);
  83    struct vertex_buffer *VB = &tnl->vb;
  84    DECLARE_RENDERINPUTS(index_bitset);
  85    int fmt_0 = 0;
  86    int fmt_1 = 0;
  87    int offset = 0;
  88
  89    RENDERINPUTS_COPY( index_bitset, tnl->render_inputs_bitset );
  90
  91    /* Important:
  92     */
  93    if ( VB->NdcPtr != NULL ) {
  94       VB->AttribPtr[VERT_ATTRIB_POS] = VB->NdcPtr;
  95    }
  96    else {
  97       VB->AttribPtr[VERT_ATTRIB_POS] = VB->ClipPtr;
  98    }
  99
 100    assert( VB->AttribPtr[VERT_ATTRIB_POS] != NULL );
 101    rmesa->radeon.swtcl.vertex_attr_count = 0;
 102
 103    /* EMIT_ATTR's must be in order as they tell t_vertex.c how to
 104     * build up a hardware vertex.
 105     */
 106    if ( !rmesa->swtcl.needproj ||
 107        RENDERINPUTS_TEST_RANGE( index_bitset, _TNL_FIRST_TEX, _TNL_LAST_TEX )) { /* need w coord for projected textures */
 108       EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_4F, R200_VTX_XY | R200_VTX_Z0 | R200_VTX_W0 );
 109       offset = 4;
 110    }
 111    else {
 112       EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_3F, R200_VTX_XY | R200_VTX_Z0 );
 113       offset = 3;
 114    }
 115
 116    if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_POINTSIZE )) {
 117       EMIT_ATTR( _TNL_ATTRIB_POINTSIZE, EMIT_1F, R200_VTX_POINT_SIZE );
 118       offset += 1;
 119    }
 120
 121    rmesa->swtcl.coloroffset = offset;
 122 #if MESA_LITTLE_ENDIAN
 123    EMIT_ATTR( _TNL_ATTRIB_COLOR0, EMIT_4UB_4F_RGBA, (R200_VTX_PK_RGBA << R200_VTX_COLOR_0_SHIFT) );
 124 #else
 125    EMIT_ATTR( _TNL_ATTRIB_COLOR0, EMIT_4UB_4F_ABGR, (R200_VTX_PK_RGBA << R200_VTX_COLOR_0_SHIFT) );
 126 #endif
 127    offset += 1;
 128
 129    rmesa->swtcl.specoffset = 0;
 130    if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_COLOR1 ) ||
 131        RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_FOG )) {
 132
 133 #if MESA_LITTLE_ENDIAN
 134       if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_COLOR1 )) {
 135          rmesa->swtcl.specoffset = offset;
 136          EMIT_ATTR( _TNL_ATTRIB_COLOR1, EMIT_3UB_3F_RGB, (R200_VTX_PK_RGBA << R200_VTX_COLOR_1_SHIFT) );
 137       }
 138       else {
 139          EMIT_PAD( 3 );
 140       }
 141
 142       if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_FOG )) {
 143          EMIT_ATTR( _TNL_ATTRIB_FOG, EMIT_1UB_1F, (R200_VTX_PK_RGBA << R200_VTX_COLOR_1_SHIFT) );
 144       }
 145       else {
 146          EMIT_PAD( 1 );
 147       }
 148 #else
 149       if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_FOG )) {
 150          EMIT_ATTR( _TNL_ATTRIB_FOG, EMIT_1UB_1F, (R200_VTX_PK_RGBA << R200_VTX_COLOR_1_SHIFT) );
 151       }
 152       else {
 153          EMIT_PAD( 1 );
 154       }
 155
 156       if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_COLOR1 )) {
 157          rmesa->swtcl.specoffset = offset;
 158          EMIT_ATTR( _TNL_ATTRIB_COLOR1, EMIT_3UB_3F_BGR, (R200_VTX_PK_RGBA << R200_VTX_COLOR_1_SHIFT) );
 159       }
 160       else {
 161          EMIT_PAD( 3 );
 162       }
 163 #endif
 164    }
 165
 166    if (RENDERINPUTS_TEST_RANGE( index_bitset, _TNL_FIRST_TEX, _TNL_LAST_TEX )) {
 167       int i;
 168
 169       for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {
 170          if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_TEX(i) )) {
 171             GLuint sz = VB->AttribPtr[_TNL_ATTRIB_TEX0 + i]->size;
 172
 173             fmt_1 |= sz << (3 * i);
 174             EMIT_ATTR( _TNL_ATTRIB_TEX0+i, EMIT_1F + sz - 1, 0 );
 175          }
 176       }
 177    }
 178
 179    if ( (rmesa->hw.ctx.cmd[CTX_PP_FOG_COLOR] & R200_FOG_USE_MASK)
 180       != R200_FOG_USE_SPEC_ALPHA ) {
 181       R200_STATECHANGE( rmesa, ctx );
 182       rmesa->hw.ctx.cmd[CTX_PP_FOG_COLOR] &= ~R200_FOG_USE_MASK;
 183       rmesa->hw.ctx.cmd[CTX_PP_FOG_COLOR] |= R200_FOG_USE_SPEC_ALPHA;
 184    }
 185
 186    if (!RENDERINPUTS_EQUAL( rmesa->radeon.tnl_index_bitset, index_bitset ) ||
 187         (rmesa->hw.vtx.cmd[VTX_VTXFMT_0] != fmt_0) ||
 188         (rmesa->hw.vtx.cmd[VTX_VTXFMT_1] != fmt_1) ) {
 189       R200_NEWPRIM(rmesa);
 190       R200_STATECHANGE( rmesa, vtx );
 191       rmesa->hw.vtx.cmd[VTX_VTXFMT_0] = fmt_0;
 192       rmesa->hw.vtx.cmd[VTX_VTXFMT_1] = fmt_1;
 193
 194       rmesa->radeon.swtcl.vertex_size =
 195           _tnl_install_attrs( ctx,
 196                               rmesa->radeon.swtcl.vertex_attrs,
 197                               rmesa->radeon.swtcl.vertex_attr_count,
 198                               NULL, 0 );
 199       rmesa->radeon.swtcl.vertex_size /= 4;
 200       RENDERINPUTS_COPY( rmesa->radeon.tnl_index_bitset, index_bitset );
 201    }
 202 }
 203
 204 static void r200_predict_emit_size( r200ContextPtr rmesa )
 205 {
 206    if (RADEON_DEBUG & RADEON_VERTS)
 207       fprintf(stderr, "%s\n", __func__);
 208    const int vertex_array_size = 7;
 209    const int prim_size = 3;
 210    if (!rmesa->radeon.swtcl.emit_prediction) {
 211       const int state_size = radeonCountStateEmitSize(&rmesa->radeon);
 212       if (rcommonEnsureCmdBufSpace(&rmesa->radeon,
 213                state_size +
 214                vertex_array_size + prim_size,
 215                __FUNCTION__))
 216          rmesa->radeon.swtcl.emit_prediction = radeonCountStateEmitSize(&rmesa->radeon);
 217       else
 218          rmesa->radeon.swtcl.emit_prediction = state_size;
 219       rmesa->radeon.swtcl.emit_prediction += vertex_array_size + prim_size
 220          + rmesa->radeon.cmdbuf.cs->cdw;
 221    }
 222 }
 223
 224
 225 static void r200RenderStart( GLcontext *ctx )
 226 {
 227    r200SetVertexFormat( ctx );
 228    if (RADEON_DEBUG & RADEON_VERTS)
 229       fprintf(stderr, "%s\n", __func__);
 230 }
 231
 232
 233 /**
 234  * Set vertex state for SW TCL.  The primary purpose of this function is to
 235  * determine in advance whether or not the hardware can / should do the
 236  * projection divide or Mesa should do it.
 237  */
 238 void r200ChooseVertexState( GLcontext *ctx )
 239 {
 240    r200ContextPtr rmesa = R200_CONTEXT( ctx );
 241    TNLcontext *tnl = TNL_CONTEXT(ctx);
 242    GLuint vte;
 243    GLuint vap;
 244
 245    /* We must ensure that we don't do _tnl_need_projected_coords while in a
 246     * rasterization fallback.  As this function will be called again when we
 247     * leave a rasterization fallback, we can just skip it for now.
 248     */
 249    if (rmesa->radeon.Fallback != 0)
 250       return;
 251
 252    vte = rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL];
 253    vap = rmesa->hw.vap.cmd[VAP_SE_VAP_CNTL];
 254
 255    /* HW perspective divide is a win, but tiny vertex formats are a
 256     * bigger one.
 257     */
 258    if (!RENDERINPUTS_TEST_RANGE( tnl->render_inputs_bitset, _TNL_FIRST_TEX, _TNL_LAST_TEX )
 259         || (ctx->_TriangleCaps & (DD_TRI_LIGHT_TWOSIDE|DD_TRI_UNFILLED))) {
 260       rmesa->swtcl.needproj = GL_TRUE;
 261       vte |= R200_VTX_XY_FMT | R200_VTX_Z_FMT;
 262       vte &= ~R200_VTX_W0_FMT;
 263       if (RENDERINPUTS_TEST_RANGE( tnl->render_inputs_bitset, _TNL_FIRST_TEX, _TNL_LAST_TEX )) {
 264          vap &= ~R200_VAP_FORCE_W_TO_ONE;
 265       }
 266       else {
 267          vap |= R200_VAP_FORCE_W_TO_ONE;
 268       }
 269    }
 270    else {
 271       rmesa->swtcl.needproj = GL_FALSE;
 272       vte &= ~(R200_VTX_XY_FMT | R200_VTX_Z_FMT);
 273       vte |= R200_VTX_W0_FMT;
 274       vap &= ~R200_VAP_FORCE_W_TO_ONE;
 275    }
 276
 277    _tnl_need_projected_coords( ctx, rmesa->swtcl.needproj );
 278
 279    if (vte != rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL]) {
 280       R200_STATECHANGE( rmesa, vte );
 281       rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL] = vte;
 282    }
 283
 284    if (vap != rmesa->hw.vap.cmd[VAP_SE_VAP_CNTL]) {
 285       R200_STATECHANGE( rmesa, vap );
 286       rmesa->hw.vap.cmd[VAP_SE_VAP_CNTL] = vap;
 287    }
 288 }
 289
 290 void r200_swtcl_flush(GLcontext *ctx, uint32_t current_offset)
 291 {
 292    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 293    if (RADEON_DEBUG & RADEON_VERTS)
 294       fprintf(stderr, "%s\n", __func__);
 295
 296
 297    radeonEmitState(&rmesa->radeon);
 298    r200EmitVertexAOS( rmesa,
 299                       rmesa->radeon.swtcl.vertex_size,
 300                       first_elem(&rmesa->radeon.dma.reserved)->bo,
 301                       current_offset);
 302
 303
 304    r200EmitVbufPrim( rmesa,
 305                      rmesa->radeon.swtcl.hw_primitive,
 306                      rmesa->radeon.swtcl.numverts);
 307    if ( rmesa->radeon.swtcl.emit_prediction < rmesa->radeon.cmdbuf.cs->cdw )
 308       WARN_ONCE("Rendering was %d commands larger than predicted size."
 309             " We might overflow  command buffer.\n",
 310             rmesa->radeon.cmdbuf.cs->cdw - rmesa->radeon.swtcl.emit_prediction );
 311
 312    rmesa->radeon.swtcl.emit_prediction = 0;
 313
 314 }
 315
 316 /**************************************************************************/
 317
 318
 319 static INLINE GLuint reduced_hw_prim( GLcontext *ctx, GLuint prim)
 320 {
 321    switch (prim) {
 322    case GL_POINTS:
 323       return (ctx->Point.PointSprite ||
 324          ((ctx->_TriangleCaps & (DD_POINT_SIZE | DD_POINT_ATTEN)) &&
 325          !(ctx->_TriangleCaps & (DD_POINT_SMOOTH)))) ?
 326          R200_VF_PRIM_POINT_SPRITES : R200_VF_PRIM_POINTS;
 327    case GL_LINES:
 328    /* fallthrough */
 329    case GL_LINE_LOOP:
 330    /* fallthrough */
 331    case GL_LINE_STRIP:
 332       return R200_VF_PRIM_LINES;
 333    default:
 334    /* all others reduced to triangles */
 335       return R200_VF_PRIM_TRIANGLES;
 336    }
 337 }
 338
 339
 340 static void r200RasterPrimitive( GLcontext *ctx, GLuint hwprim );
 341 static void r200RenderPrimitive( GLcontext *ctx, GLenum prim );
 342 static void r200ResetLineStipple( GLcontext *ctx );
 343
 344 /***********************************************************************
 345  *                    Emit primitives as inline vertices               *
 346  ***********************************************************************/
 347
 348 #define HAVE_POINTS      1
 349 #define HAVE_LINES       1
 350 #define HAVE_LINE_STRIPS 1
 351 #define HAVE_TRIANGLES   1
 352 #define HAVE_TRI_STRIPS  1
 353 #define HAVE_TRI_STRIP_1 0
 354 #define HAVE_TRI_FANS    1
 355 #define HAVE_QUADS       0
 356 #define HAVE_QUAD_STRIPS 0
 357 #define HAVE_POLYGONS    1
 358 #define HAVE_ELTS        0
 359
 360 static void* r200_alloc_verts( r200ContextPtr rmesa, GLuint n, GLuint size)
 361 {
 362    void *rv;
 363    do {
 364       r200_predict_emit_size( rmesa );
 365       rv = rcommonAllocDmaLowVerts( &rmesa->radeon, n, size * 4 );
 366    } while(!rv);
 367    return rv;
 368 }
 369
 370 #undef LOCAL_VARS
 371 #undef ALLOC_VERTS
 372 #define CTX_ARG r200ContextPtr rmesa
 373 #define GET_VERTEX_DWORDS() rmesa->radeon.swtcl.vertex_size
 374 #define ALLOC_VERTS( n, size ) r200_alloc_verts(rmesa, n, size)
 375 #define LOCAL_VARS                                              \
 376    r200ContextPtr rmesa = R200_CONTEXT(ctx);            \
 377    const char *r200verts = (char *)rmesa->radeon.swtcl.verts;
 378 #define VERT(x) (radeonVertex *)(r200verts + ((x) * vertsize * sizeof(int)))
 379 #define VERTEX radeonVertex
 380 #define DO_DEBUG_VERTS (1 && (R200_DEBUG & RADEON_VERTS))
 381
 382 #undef TAG
 383 #define TAG(x) r200_##x
 384 #include "tnl_dd/t_dd_triemit.h"
 385
 386
 387 /***********************************************************************
 388  *          Macros for t_dd_tritmp.h to draw basic primitives          *
 389  ***********************************************************************/
 390
 391 #define QUAD( a, b, c, d ) r200_quad( rmesa, a, b, c, d )
 392 #define TRI( a, b, c )     r200_triangle( rmesa, a, b, c )
 393 #define LINE( a, b )       r200_line( rmesa, a, b )
 394 #define POINT( a )         r200_point( rmesa, a )
 395
 396 /***********************************************************************
 397  *              Build render functions from dd templates               *
 398  ***********************************************************************/
 399
 400 #define R200_TWOSIDE_BIT        0x01
 401 #define R200_UNFILLED_BIT       0x02
 402 #define R200_MAX_TRIFUNC        0x04
 403
 404
 405 static struct {
 406    tnl_points_func              points;
 407    tnl_line_func                line;
 408    tnl_triangle_func    triangle;
 409    tnl_quad_func                quad;
 410 } rast_tab[R200_MAX_TRIFUNC];
 411
 412
 413 #define DO_FALLBACK  0
 414 #define DO_UNFILLED (IND & R200_UNFILLED_BIT)
 415 #define DO_TWOSIDE  (IND & R200_TWOSIDE_BIT)
 416 #define DO_FLAT      0
 417 #define DO_OFFSET     0
 418 #define DO_TRI       1
 419 #define DO_QUAD      1
 420 #define DO_LINE      1
 421 #define DO_POINTS    1
 422 #define DO_FULL_QUAD 1
 423
 424 #define HAVE_RGBA   1
 425 #define HAVE_SPEC   1
 426 #define HAVE_BACK_COLORS  0
 427 #define HAVE_HW_FLATSHADE 1
 428 #define TAB rast_tab
 429
 430 #define DEPTH_SCALE 1.0
 431 #define UNFILLED_TRI unfilled_tri
 432 #define UNFILLED_QUAD unfilled_quad
 433 #define VERT_X(_v) _v->v.x
 434 #define VERT_Y(_v) _v->v.y
 435 #define VERT_Z(_v) _v->v.z
 436 #define AREA_IS_CCW( a ) (a < 0)
 437 #define GET_VERTEX(e) (rmesa->radeon.swtcl.verts + (e*rmesa->radeon.swtcl.vertex_size*sizeof(int)))
 438
 439 #define VERT_SET_RGBA( v, c )                                   \
 440 do {                                                            \
 441    radeon_color_t *color = (radeon_color_t *)&((v)->ui[coloroffset]);   \
 442    UNCLAMPED_FLOAT_TO_UBYTE(color->red, (c)[0]);                \
 443    UNCLAMPED_FLOAT_TO_UBYTE(color->green, (c)[1]);              \
 444    UNCLAMPED_FLOAT_TO_UBYTE(color->blue, (c)[2]);               \
 445    UNCLAMPED_FLOAT_TO_UBYTE(color->alpha, (c)[3]);              \
 446 } while (0)
 447
 448 #define VERT_COPY_RGBA( v0, v1 ) v0->ui[coloroffset] = v1->ui[coloroffset]
 449
 450 #define VERT_SET_SPEC( v, c )                                   \
 451 do {                                                            \
 452    if (specoffset) {                                            \
 453       radeon_color_t *spec = (radeon_color_t *)&((v)->ui[specoffset]);  \
 454       UNCLAMPED_FLOAT_TO_UBYTE(spec->red, (c)[0]);      \
 455       UNCLAMPED_FLOAT_TO_UBYTE(spec->green, (c)[1]);    \
 456       UNCLAMPED_FLOAT_TO_UBYTE(spec->blue, (c)[2]);     \
 457    }                                                            \
 458 } while (0)
 459 #define VERT_COPY_SPEC( v0, v1 )                        \
 460 do {                                                    \
 461    if (specoffset) {                                    \
 462       radeon_color_t *spec0 = (radeon_color_t *)&((v0)->ui[specoffset]);        \
 463       radeon_color_t *spec1 = (radeon_color_t *)&((v1)->ui[specoffset]);        \
 464       spec0->red   = spec1->red;        \
 465       spec0->green = spec1->green;      \
 466       spec0->blue  = spec1->blue;       \
 467    }                                                    \
 468 } while (0)
 469
 470 /* These don't need LE32_TO_CPU() as they used to save and restore
 471  * colors which are already in the correct format.
 472  */
 473 #define VERT_SAVE_RGBA( idx )    color[idx] = v[idx]->ui[coloroffset]
 474 #define VERT_RESTORE_RGBA( idx ) v[idx]->ui[coloroffset] = color[idx]
 475 #define VERT_SAVE_SPEC( idx )    if (specoffset) spec[idx] = v[idx]->ui[specoffset]
 476 #define VERT_RESTORE_SPEC( idx ) if (specoffset) v[idx]->ui[specoffset] = spec[idx]
 477
 478 #undef LOCAL_VARS
 479 #undef TAG
 480 #undef INIT
 481
 482 #define LOCAL_VARS(n)                                                   \
 483    r200ContextPtr rmesa = R200_CONTEXT(ctx);                    \
 484    GLuint color[n] = {0}, spec[n] = {0};                                                \
 485    GLuint coloroffset = rmesa->swtcl.coloroffset;       \
 486    GLuint specoffset = rmesa->swtcl.specoffset;                 \
 487    (void) color; (void) spec; (void) coloroffset; (void) specoffset;
 488
 489 /***********************************************************************
 490  *                Helpers for rendering unfilled primitives            *
 491  ***********************************************************************/
 492
 493 #define RASTERIZE(x) r200RasterPrimitive( ctx, reduced_hw_prim(ctx, x) )
 494 #define RENDER_PRIMITIVE rmesa->radeon.swtcl.render_primitive
 495 #undef TAG
 496 #define TAG(x) x
 497 #include "tnl_dd/t_dd_unfilled.h"
 498 #undef IND
 499
 500
 501 /***********************************************************************
 502  *                      Generate GL render functions                   *
 503  ***********************************************************************/
 504
 505
 506 #define IND (0)
 507 #define TAG(x) x
 508 #include "tnl_dd/t_dd_tritmp.h"
 509
 510 #define IND (R200_TWOSIDE_BIT)
 511 #define TAG(x) x##_twoside
 512 #include "tnl_dd/t_dd_tritmp.h"
 513
 514 #define IND (R200_UNFILLED_BIT)
 515 #define TAG(x) x##_unfilled
 516 #include "tnl_dd/t_dd_tritmp.h"
 517
 518 #define IND (R200_TWOSIDE_BIT|R200_UNFILLED_BIT)
 519 #define TAG(x) x##_twoside_unfilled
 520 #include "tnl_dd/t_dd_tritmp.h"
 521
 522
 523 static void init_rast_tab( void )
 524 {
 525    init();
 526    init_twoside();
 527    init_unfilled();
 528    init_twoside_unfilled();
 529 }
 530
 531 /**********************************************************************/
 532 /*               Render unclipped begin/end objects                   */
 533 /**********************************************************************/
 534
 535 #define RENDER_POINTS( start, count )           \
 536    for ( ; start < count ; start++)             \
 537       r200_point( rmesa, VERT(start) )
 538 #define RENDER_LINE( v0, v1 ) \
 539    r200_line( rmesa, VERT(v0), VERT(v1) )
 540 #define RENDER_TRI( v0, v1, v2 )  \
 541    r200_triangle( rmesa, VERT(v0), VERT(v1), VERT(v2) )
 542 #define RENDER_QUAD( v0, v1, v2, v3 ) \
 543    r200_quad( rmesa, VERT(v0), VERT(v1), VERT(v2), VERT(v3) )
 544 #define INIT(x) do {                                    \
 545    r200RenderPrimitive( ctx, x );                       \
 546 } while (0)
 547 #undef LOCAL_VARS
 548 #define LOCAL_VARS                                              \
 549    r200ContextPtr rmesa = R200_CONTEXT(ctx);            \
 550    const GLuint vertsize = rmesa->radeon.swtcl.vertex_size;             \
 551    const char *r200verts = (char *)rmesa->radeon.swtcl.verts;           \
 552    const GLuint * const elt = TNL_CONTEXT(ctx)->vb.Elts;        \
 553    const GLboolean stipple = ctx->Line.StippleFlag;             \
 554    (void) elt; (void) stipple;
 555 #define RESET_STIPPLE   if ( stipple ) r200ResetLineStipple( ctx );
 556 #define RESET_OCCLUSION
 557 #define PRESERVE_VB_DEFS
 558 #define ELT(x) (x)
 559 #define TAG(x) r200_##x##_verts
 560 #include "tnl/t_vb_rendertmp.h"
 561 #undef ELT
 562 #undef TAG
 563 #define TAG(x) r200_##x##_elts
 564 #define ELT(x) elt[x]
 565 #include "tnl/t_vb_rendertmp.h"
 566
 567
 568
 569 /**********************************************************************/
 570 /*                    Choose render functions                         */
 571 /**********************************************************************/
 572
 573 void r200ChooseRenderState( GLcontext *ctx )
 574 {
 575    TNLcontext *tnl = TNL_CONTEXT(ctx);
 576    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 577    GLuint index = 0;
 578    GLuint flags = ctx->_TriangleCaps;
 579
 580    if (!rmesa->radeon.TclFallback || rmesa->radeon.Fallback)
 581       return;
 582
 583    if (flags & DD_TRI_LIGHT_TWOSIDE) index |= R200_TWOSIDE_BIT;
 584    if (flags & DD_TRI_UNFILLED)      index |= R200_UNFILLED_BIT;
 585
 586    if (index != rmesa->radeon.swtcl.RenderIndex) {
 587       tnl->Driver.Render.Points = rast_tab[index].points;
 588       tnl->Driver.Render.Line = rast_tab[index].line;
 589       tnl->Driver.Render.ClippedLine = rast_tab[index].line;
 590       tnl->Driver.Render.Triangle = rast_tab[index].triangle;
 591       tnl->Driver.Render.Quad = rast_tab[index].quad;
 592
 593       if (index == 0) {
 594          tnl->Driver.Render.PrimTabVerts = r200_render_tab_verts;
 595          tnl->Driver.Render.PrimTabElts = r200_render_tab_elts;
 596          tnl->Driver.Render.ClippedPolygon = r200_fast_clipped_poly;
 597       } else {
 598          tnl->Driver.Render.PrimTabVerts = _tnl_render_tab_verts;
 599          tnl->Driver.Render.PrimTabElts = _tnl_render_tab_elts;
 600          tnl->Driver.Render.ClippedPolygon = _tnl_RenderClippedPolygon;
 601       }
 602
 603       rmesa->radeon.swtcl.RenderIndex = index;
 604    }
 605 }
 606
 607
 608 /**********************************************************************/
 609 /*                 High level hooks for t_vb_render.c                 */
 610 /**********************************************************************/
 611
 612
 613 static void r200RasterPrimitive( GLcontext *ctx, GLuint hwprim )
 614 {
 615    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 616
 617    if (rmesa->radeon.swtcl.hw_primitive != hwprim) {
 618       /* need to disable perspective-correct texturing for point sprites */
 619       if ((hwprim & 0xf) == R200_VF_PRIM_POINT_SPRITES && ctx->Point.PointSprite) {
 620          if (rmesa->hw.set.cmd[SET_RE_CNTL] & R200_PERSPECTIVE_ENABLE) {
 621             R200_STATECHANGE( rmesa, set );
 622             rmesa->hw.set.cmd[SET_RE_CNTL] &= ~R200_PERSPECTIVE_ENABLE;
 623          }
 624       }
 625       else if (!(rmesa->hw.set.cmd[SET_RE_CNTL] & R200_PERSPECTIVE_ENABLE)) {
 626          R200_STATECHANGE( rmesa, set );
 627          rmesa->hw.set.cmd[SET_RE_CNTL] |= R200_PERSPECTIVE_ENABLE;
 628       }
 629       R200_NEWPRIM( rmesa );
 630       rmesa->radeon.swtcl.hw_primitive = hwprim;
 631    }
 632 }
 633
 634 static void r200RenderPrimitive( GLcontext *ctx, GLenum prim )
 635 {
 636    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 637    rmesa->radeon.swtcl.render_primitive = prim;
 638    if (prim < GL_TRIANGLES || !(ctx->_TriangleCaps & DD_TRI_UNFILLED))
 639       r200RasterPrimitive( ctx, reduced_hw_prim(ctx, prim) );
 640 }
 641
 642 static void r200RenderFinish( GLcontext *ctx )
 643 {
 644 }
 645
 646 static void r200ResetLineStipple( GLcontext *ctx )
 647 {
 648    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 649    R200_STATECHANGE( rmesa, lin );
 650 }
 651
 652
 653 /**********************************************************************/
 654 /*           Transition to/from hardware rasterization.               */
 655 /**********************************************************************/
 656
 657 static const char * const fallbackStrings[] = {
 658    "Texture mode",
 659    "glDrawBuffer(GL_FRONT_AND_BACK)",
 660    "glEnable(GL_STENCIL) without hw stencil buffer",
 661    "glRenderMode(selection or feedback)",
 662    "R200_NO_RAST",
 663    "Mixing GL_CLAMP_TO_BORDER and GL_CLAMP (or GL_MIRROR_CLAMP_ATI)"
 664 };
 665
 666
 667 static const char *getFallbackString(GLuint bit)
 668 {
 669    int i = 0;
 670    while (bit > 1) {
 671       i++;
 672       bit >>= 1;
 673    }
 674    return fallbackStrings[i];
 675 }
 676
 677
 678 void r200Fallback( GLcontext *ctx, GLuint bit, GLboolean mode )
 679 {
 680    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 681    TNLcontext *tnl = TNL_CONTEXT(ctx);
 682    GLuint oldfallback = rmesa->radeon.Fallback;
 683
 684    if (mode) {
 685       rmesa->radeon.Fallback |= bit;
 686       if (oldfallback == 0) {
 687          radeon_firevertices(&rmesa->radeon);
 688          TCL_FALLBACK( ctx, R200_TCL_FALLBACK_RASTER, GL_TRUE );
 689          _swsetup_Wakeup( ctx );
 690          rmesa->radeon.swtcl.RenderIndex = ~0;
 691          if (R200_DEBUG & RADEON_FALLBACKS) {
 692             fprintf(stderr, "R200 begin rasterization fallback: 0x%x %s\n",
 693                     bit, getFallbackString(bit));
 694          }
 695       }
 696    }
 697    else {
 698       rmesa->radeon.Fallback &= ~bit;
 699       if (oldfallback == bit) {
 700
 701          _swrast_flush( ctx );
 702          tnl->Driver.Render.Start = r200RenderStart;
 703          tnl->Driver.Render.PrimitiveNotify = r200RenderPrimitive;
 704          tnl->Driver.Render.Finish = r200RenderFinish;
 705
 706          tnl->Driver.Render.BuildVertices = _tnl_build_vertices;
 707          tnl->Driver.Render.CopyPV = _tnl_copy_pv;
 708          tnl->Driver.Render.Interp = _tnl_interp;
 709
 710          tnl->Driver.Render.ResetLineStipple = r200ResetLineStipple;
 711          TCL_FALLBACK( ctx, R200_TCL_FALLBACK_RASTER, GL_FALSE );
 712          if (rmesa->radeon.TclFallback) {
 713             /* These are already done if rmesa->radeon.TclFallback goes to
 714              * zero above. But not if it doesn't (R200_NO_TCL for
 715              * example?)
 716              */
 717             _tnl_invalidate_vertex_state( ctx, ~0 );
 718             _tnl_invalidate_vertices( ctx, ~0 );
 719             RENDERINPUTS_ZERO( rmesa->radeon.tnl_index_bitset );
 720             r200ChooseVertexState( ctx );
 721             r200ChooseRenderState( ctx );
 722          }
 723          if (R200_DEBUG & RADEON_FALLBACKS) {
 724             fprintf(stderr, "R200 end rasterization fallback: 0x%x %s\n",
 725                     bit, getFallbackString(bit));
 726          }
 727       }
 728    }
 729 }
 730
 731
 732
 733
 734 /**
 735  * Cope with depth operations by drawing individual pixels as points.
 736  *
 737  * \todo
 738  * The way the vertex state is set in this routine is hokey.  It seems to
 739  * work, but it's very hackish.  This whole routine is pretty hackish.  If
 740  * the bitmap is small enough, it seems like it would be faster to copy it
 741  * to AGP memory and use it as a non-power-of-two texture (i.e.,
 742  * NV_texture_rectangle).
 743  */
 744 void
 745 r200PointsBitmap( GLcontext *ctx, GLint px, GLint py,
 746                   GLsizei width, GLsizei height,
 747                   const struct gl_pixelstore_attrib *unpack,
 748                   const GLubyte *bitmap )
 749 {
 750    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 751    const GLfloat *rc = ctx->Current.RasterColor;
 752    GLint row, col;
 753    radeonVertex vert;
 754    GLuint orig_vte;
 755    GLuint h;
 756
 757
 758    /* Turn off tcl.
 759     */
 760    TCL_FALLBACK( ctx, R200_TCL_FALLBACK_BITMAP, 1 );
 761
 762    /* Choose tiny vertex format
 763     */
 764    {
 765       const GLuint fmt_0 = R200_VTX_XY | R200_VTX_Z0 | R200_VTX_W0
 766           | (R200_VTX_PK_RGBA << R200_VTX_COLOR_0_SHIFT);
 767       const GLuint fmt_1 = 0;
 768       GLuint vte = rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL];
 769       GLuint vap = rmesa->hw.vap.cmd[VAP_SE_VAP_CNTL];
 770
 771       vte &= ~(R200_VTX_XY_FMT | R200_VTX_Z_FMT);
 772       vte |= R200_VTX_W0_FMT;
 773       vap &= ~R200_VAP_FORCE_W_TO_ONE;
 774
 775       rmesa->radeon.swtcl.vertex_size = 5;
 776
 777       if ( (rmesa->hw.vtx.cmd[VTX_VTXFMT_0] != fmt_0)
 778            || (rmesa->hw.vtx.cmd[VTX_VTXFMT_1] != fmt_1) ) {
 779          R200_NEWPRIM(rmesa);
 780          R200_STATECHANGE( rmesa, vtx );
 781          rmesa->hw.vtx.cmd[VTX_VTXFMT_0] = fmt_0;
 782          rmesa->hw.vtx.cmd[VTX_VTXFMT_1] = fmt_1;
 783       }
 784
 785       if (vte != rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL]) {
 786          R200_STATECHANGE( rmesa, vte );
 787          rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL] = vte;
 788       }
 789
 790       if (vap != rmesa->hw.vap.cmd[VAP_SE_VAP_CNTL]) {
 791          R200_STATECHANGE( rmesa, vap );
 792          rmesa->hw.vap.cmd[VAP_SE_VAP_CNTL] = vap;
 793       }
 794    }
 795
 796    /* Ready for point primitives:
 797     */
 798    r200RenderPrimitive( ctx, GL_POINTS );
 799
 800    /* Turn off the hw viewport transformation:
 801     */
 802    R200_STATECHANGE( rmesa, vte );
 803    orig_vte = rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL];
 804    rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL] &= ~(R200_VPORT_X_SCALE_ENA |
 805                                            R200_VPORT_Y_SCALE_ENA |
 806                                            R200_VPORT_Z_SCALE_ENA |
 807                                            R200_VPORT_X_OFFSET_ENA |
 808                                            R200_VPORT_Y_OFFSET_ENA |
 809                                            R200_VPORT_Z_OFFSET_ENA);
 810
 811    /* Turn off other stuff:  Stipple?, texture?, blending?, etc.
 812     */
 813
 814
 815    /* Populate the vertex
 816     *
 817     * Incorporate FOG into RGBA
 818     */
 819    if (ctx->Fog.Enabled) {
 820       const GLfloat *fc = ctx->Fog.Color;
 821       GLfloat color[4];
 822       GLfloat f;
 823
 824       if (ctx->Fog.FogCoordinateSource == GL_FOG_COORDINATE_EXT)
 825          f = _swrast_z_to_fogfactor(ctx, ctx->Current.Attrib[VERT_ATTRIB_FOG][0]);
 826       else
 827          f = _swrast_z_to_fogfactor(ctx, ctx->Current.RasterDistance);
 828
 829       color[0] = f * rc[0] + (1.F - f) * fc[0];
 830       color[1] = f * rc[1] + (1.F - f) * fc[1];
 831       color[2] = f * rc[2] + (1.F - f) * fc[2];
 832       color[3] = rc[3];
 833
 834       UNCLAMPED_FLOAT_TO_CHAN(vert.tv.color.red,   color[0]);
 835       UNCLAMPED_FLOAT_TO_CHAN(vert.tv.color.green, color[1]);
 836       UNCLAMPED_FLOAT_TO_CHAN(vert.tv.color.blue,  color[2]);
 837       UNCLAMPED_FLOAT_TO_CHAN(vert.tv.color.alpha, color[3]);
 838    }
 839    else {
 840       UNCLAMPED_FLOAT_TO_CHAN(vert.tv.color.red,   rc[0]);
 841       UNCLAMPED_FLOAT_TO_CHAN(vert.tv.color.green, rc[1]);
 842       UNCLAMPED_FLOAT_TO_CHAN(vert.tv.color.blue,  rc[2]);
 843       UNCLAMPED_FLOAT_TO_CHAN(vert.tv.color.alpha, rc[3]);
 844    }
 845
 846
 847    vert.tv.z = ctx->Current.RasterPos[2];
 848
 849
 850    /* Update window height
 851     */
 852    LOCK_HARDWARE( &rmesa->radeon );
 853    UNLOCK_HARDWARE( &rmesa->radeon );
 854    h = radeon_get_drawable(&rmesa->radeon)->h + radeon_get_drawable(&rmesa->radeon)->y;
 855    px += radeon_get_drawable(&rmesa->radeon)->x;
 856
 857    /* Clipping handled by existing mechansims in r200_ioctl.c?
 858     */
 859    for (row=0; row<height; row++) {
 860       const GLubyte *src = (const GLubyte *)
 861          _mesa_image_address2d(unpack, bitmap, width, height,
 862                                GL_COLOR_INDEX, GL_BITMAP, row, 0 );
 863
 864       if (unpack->LsbFirst) {
 865          /* Lsb first */
 866          GLubyte mask = 1U << (unpack->SkipPixels & 0x7);
 867          for (col=0; col<width; col++) {
 868             if (*src & mask) {
 869                vert.tv.x = px+col;
 870                vert.tv.y = h - (py+row) - 1;
 871                r200_point( rmesa, &vert );
 872             }
 873             src += (mask >> 7);
 874             mask = ((mask << 1) & 0xff) | (mask >> 7);
 875          }
 876
 877          /* get ready for next row */
 878          if (mask != 1)
 879             src++;
 880       }
 881       else {
 882          /* Msb first */
 883          GLubyte mask = 128U >> (unpack->SkipPixels & 0x7);
 884          for (col=0; col<width; col++) {
 885             if (*src & mask) {
 886                vert.tv.x = px+col;
 887                vert.tv.y = h - (py+row) - 1;
 888                r200_point( rmesa, &vert );
 889             }
 890             src += mask & 1;
 891             mask = ((mask << 7) & 0xff) | (mask >> 1);
 892          }
 893          /* get ready for next row */
 894          if (mask != 128)
 895             src++;
 896       }
 897    }
 898
 899    /* Fire outstanding vertices, restore state
 900     */
 901    R200_STATECHANGE( rmesa, vte );
 902    rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL] = orig_vte;
 903
 904    /* Unfallback
 905     */
 906    TCL_FALLBACK( ctx, R200_TCL_FALLBACK_BITMAP, 0 );
 907
 908    /* Need to restore vertexformat?
 909     */
 910    if (rmesa->radeon.TclFallback)
 911       r200ChooseVertexState( ctx );
 912 }
 913
 914
 915
 916 /**********************************************************************/
 917 /*                            Initialization.                         */
 918 /**********************************************************************/
 919
 920 void r200InitSwtcl( GLcontext *ctx )
 921 {
 922    TNLcontext *tnl = TNL_CONTEXT(ctx);
 923    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 924    static int firsttime = 1;
 925
 926    if (firsttime) {
 927       init_rast_tab();
 928       firsttime = 0;
 929    }
 930    rmesa->radeon.swtcl.emit_prediction = 0;
 931
 932    tnl->Driver.Render.Start = r200RenderStart;
 933    tnl->Driver.Render.Finish = r200RenderFinish;
 934    tnl->Driver.Render.PrimitiveNotify = r200RenderPrimitive;
 935    tnl->Driver.Render.ResetLineStipple = r200ResetLineStipple;
 936    tnl->Driver.Render.BuildVertices = _tnl_build_vertices;
 937    tnl->Driver.Render.CopyPV = _tnl_copy_pv;
 938    tnl->Driver.Render.Interp = _tnl_interp;
 939
 940    /* FIXME: what are these numbers? */
 941    _tnl_init_vertices( ctx, ctx->Const.MaxArrayLockSize + 12,
 942                        36 * sizeof(GLfloat) );
 943
 944    rmesa->radeon.swtcl.verts = (GLubyte *)tnl->clipspace.vertex_buf;
 945    rmesa->radeon.swtcl.RenderIndex = ~0;
 946    rmesa->radeon.swtcl.render_primitive = GL_TRIANGLES;
 947    rmesa->radeon.swtcl.hw_primitive = 0;
 948 }
 949