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

   1 /* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_tcl.c,v 1.2 2002/12/16 16:18:55 dawes Exp $ */
   2 /*
   3 Copyright (C) The Weather Channel, Inc.  2002.  All Rights Reserved.
   4
   5 The Weather Channel (TM) funded Tungsten Graphics to develop the
   6 initial release of the Radeon 8500 driver under the XFree86 license.
   7 This notice must be preserved.
   8
   9 Permission is hereby granted, free of charge, to any person obtaining
  10 a copy of this software and associated documentation files (the
  11 "Software"), to deal in the Software without restriction, including
  12 without limitation the rights to use, copy, modify, merge, publish,
  13 distribute, sublicense, and/or sell copies of the Software, and to
  14 permit persons to whom the Software is furnished to do so, subject to
  15 the following conditions:
  16
  17 The above copyright notice and this permission notice (including the
  18 next paragraph) shall be included in all copies or substantial
  19 portions of the Software.
  20
  21 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  24 IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
  25 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28
  29 **************************************************************************/
  30
  31 /*
  32  * Authors:
  33  *   Keith Whitwell <keith@tungstengraphics.com>
  34  */
  35
  36 #include "glheader.h"
  37 #include "imports.h"
  38 #include "mtypes.h"
  39 #include "enums.h"
  40 #include "colormac.h"
  41 #include "light.h"
  42
  43 #include "array_cache/acache.h"
  44 #include "tnl/tnl.h"
  45 #include "tnl/t_pipeline.h"
  46
  47 #include "r200_context.h"
  48 #include "r200_state.h"
  49 #include "r200_ioctl.h"
  50 #include "r200_tex.h"
  51 #include "r200_tcl.h"
  52 #include "r200_swtcl.h"
  53 #include "r200_maos.h"
  54
  55
  56
  57 #define HAVE_POINTS      1
  58 #define HAVE_LINES       1
  59 #define HAVE_LINE_LOOP   0
  60 #define HAVE_LINE_STRIPS 1
  61 #define HAVE_TRIANGLES   1
  62 #define HAVE_TRI_STRIPS  1
  63 #define HAVE_TRI_STRIP_1 0
  64 #define HAVE_TRI_FANS    1
  65 #define HAVE_QUADS       0      /* hw quad verts in wrong order??? */
  66 #define HAVE_QUAD_STRIPS 1
  67 #define HAVE_POLYGONS    1
  68 #define HAVE_ELTS        1
  69
  70
  71 #define HW_POINTS           R200_VF_PRIM_POINTS
  72 #define HW_LINES            R200_VF_PRIM_LINES
  73 #define HW_LINE_LOOP        0
  74 #define HW_LINE_STRIP       R200_VF_PRIM_LINE_STRIP
  75 #define HW_TRIANGLES        R200_VF_PRIM_TRIANGLES
  76 #define HW_TRIANGLE_STRIP_0 R200_VF_PRIM_TRIANGLE_STRIP
  77 #define HW_TRIANGLE_STRIP_1 0
  78 #define HW_TRIANGLE_FAN     R200_VF_PRIM_TRIANGLE_FAN
  79 #define HW_QUADS            R200_VF_PRIM_QUADS
  80 #define HW_QUAD_STRIP       R200_VF_PRIM_QUAD_STRIP
  81 #define HW_POLYGON          R200_VF_PRIM_POLYGON
  82
  83
  84 static GLboolean discrete_prim[0x10] = {
  85    0,                           /* 0 none */
  86    1,                           /* 1 points */
  87    1,                           /* 2 lines */
  88    0,                           /* 3 line_strip */
  89    1,                           /* 4 tri_list */
  90    0,                           /* 5 tri_fan */
  91    0,                           /* 6 tri_strip */
  92    0,                           /* 7 tri_w_flags */
  93    1,                           /* 8 rect list (unused) */
  94    1,                           /* 9 3vert point */
  95    1,                           /* a 3vert line */
  96    0,                           /* b point sprite */
  97    0,                           /* c line loop */
  98    1,                           /* d quads */
  99    0,                           /* e quad strip */
 100    0,                           /* f polygon */
 101 };
 102
 103
 104 #define LOCAL_VARS r200ContextPtr rmesa = R200_CONTEXT(ctx)
 105 #define ELT_TYPE  GLushort
 106
 107 #define ELT_INIT(prim, hw_prim) \
 108    r200TclPrimitive( ctx, prim, hw_prim | R200_VF_PRIM_WALK_IND )
 109
 110 #define GET_MESA_ELTS() rmesa->tcl.Elts
 111
 112
 113 /* Don't really know how many elts will fit in what's left of cmdbuf,
 114  * as there is state to emit, etc:
 115  */
 116
 117 /* Testing on isosurf shows a maximum around here.  Don't know if it's
 118  * the card or driver or kernel module that is causing the behaviour.
 119  */
 120 #define GET_MAX_HW_ELTS() 300
 121
 122 #define RESET_STIPPLE() do {                    \
 123    R200_STATECHANGE( rmesa, lin );              \
 124    r200EmitState( rmesa );                      \
 125 } while (0)
 126
 127 #define AUTO_STIPPLE( mode )  do {              \
 128    R200_STATECHANGE( rmesa, lin );              \
 129    if (mode)                                    \
 130       rmesa->hw.lin.cmd[LIN_RE_LINE_PATTERN] |= \
 131          R200_LINE_PATTERN_AUTO_RESET;  \
 132    else                                         \
 133       rmesa->hw.lin.cmd[LIN_RE_LINE_PATTERN] &= \
 134          ~R200_LINE_PATTERN_AUTO_RESET; \
 135    r200EmitState( rmesa );                      \
 136 } while (0)
 137
 138
 139 #define ALLOC_ELTS(nr)  r200AllocElts( rmesa, nr )
 140
 141 static GLushort *r200AllocElts( r200ContextPtr rmesa, GLuint nr )
 142 {
 143    if (rmesa->dma.flush)
 144       rmesa->dma.flush( rmesa );
 145
 146    r200EmitAOS( rmesa,
 147                 rmesa->tcl.aos_components,
 148                 rmesa->tcl.nr_aos_components, 0 );
 149
 150    return r200AllocEltsOpenEnded( rmesa, rmesa->tcl.hw_primitive, nr );
 151 }
 152
 153
 154 #define CLOSE_ELTS()  R200_NEWPRIM( rmesa )
 155
 156
 157 /* TODO: Try to extend existing primitive if both are identical,
 158  * discrete and there are no intervening state changes.  (Somewhat
 159  * duplicates changes to DrawArrays code)
 160  */
 161 static void EMIT_PRIM( GLcontext *ctx,
 162                        GLenum prim,
 163                        GLuint hwprim,
 164                        GLuint start,
 165                        GLuint count)
 166 {
 167    r200ContextPtr rmesa = R200_CONTEXT( ctx );
 168    r200TclPrimitive( ctx, prim, hwprim );
 169
 170    r200EmitAOS( rmesa,
 171                   rmesa->tcl.aos_components,
 172                   rmesa->tcl.nr_aos_components,
 173                   start );
 174
 175    /* Why couldn't this packet have taken an offset param?
 176     */
 177    r200EmitVbufPrim( rmesa,
 178                      rmesa->tcl.hw_primitive,
 179                      count - start );
 180 }
 181
 182
 183
 184 /* Try & join small primitives
 185  */
 186 #if 0
 187 #define PREFER_DISCRETE_ELT_PRIM( NR, PRIM ) 0
 188 #else
 189 #define PREFER_DISCRETE_ELT_PRIM( NR, PRIM )                    \
 190   ((NR) < 20 ||                                                 \
 191    ((NR) < 40 &&                                                \
 192     rmesa->tcl.hw_primitive == (PRIM|                           \
 193                             R200_VF_TCL_OUTPUT_VTX_ENABLE|      \
 194                                 R200_VF_PRIM_WALK_IND)))
 195 #endif
 196
 197 #ifdef MESA_BIG_ENDIAN
 198 /* We could do without (most of) this ugliness if dest was always 32 bit word aligned... */
 199 #define EMIT_ELT(dest, offset, x) do {                                \
 200         int off = offset + ( ( (GLuint)dest & 0x2 ) >> 1 );     \
 201         GLushort *des = (GLushort *)( (GLuint)dest & ~0x2 );    \
 202         (des)[ off + 1 - 2 * ( off & 1 ) ] = (GLushort)(x); } while (0)
 203 #else
 204 #define EMIT_ELT(dest, offset, x) (dest)[offset] = (GLushort) (x)
 205 #endif
 206
 207 #define EMIT_TWO_ELTS(dest, offset, x, y)  *(GLuint *)((dest)+offset) = ((y)<<16)|(x);
 208
 209
 210
 211 #define TAG(x) tcl_##x
 212 #include "tnl_dd/t_dd_dmatmp2.h"
 213
 214 /**********************************************************************/
 215 /*                          External entrypoints                     */
 216 /**********************************************************************/
 217
 218 void r200EmitPrimitive( GLcontext *ctx,
 219                           GLuint first,
 220                           GLuint last,
 221                           GLuint flags )
 222 {
 223    tcl_render_tab_verts[flags&PRIM_MODE_MASK]( ctx, first, last, flags );
 224 }
 225
 226 void r200EmitEltPrimitive( GLcontext *ctx,
 227                              GLuint first,
 228                              GLuint last,
 229                              GLuint flags )
 230 {
 231    tcl_render_tab_elts[flags&PRIM_MODE_MASK]( ctx, first, last, flags );
 232 }
 233
 234 void r200TclPrimitive( GLcontext *ctx,
 235                          GLenum prim,
 236                          int hw_prim )
 237 {
 238    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 239    GLuint newprim = hw_prim | R200_VF_TCL_OUTPUT_VTX_ENABLE;
 240
 241    if (newprim != rmesa->tcl.hw_primitive ||
 242        !discrete_prim[hw_prim&0xf]) {
 243       R200_NEWPRIM( rmesa );
 244       rmesa->tcl.hw_primitive = newprim;
 245    }
 246 }
 247
 248
 249 /**********************************************************************/
 250 /*                          Render pipeline stage                     */
 251 /**********************************************************************/
 252
 253
 254 /* TCL render.
 255  */
 256 static GLboolean r200_run_tcl_render( GLcontext *ctx,
 257                                       struct tnl_pipeline_stage *stage )
 258 {
 259    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 260    TNLcontext *tnl = TNL_CONTEXT(ctx);
 261    struct vertex_buffer *VB = &tnl->vb;
 262    GLuint i;
 263
 264    /* TODO: separate this from the swtnl pipeline
 265     */
 266    if (rmesa->TclFallback)
 267       return GL_TRUE;   /* fallback to software t&l */
 268
 269    if (R200_DEBUG & DEBUG_PRIMS)
 270       fprintf(stderr, "%s\n", __FUNCTION__);
 271
 272    if (VB->Count == 0)
 273       return GL_FALSE;
 274
 275    r200ReleaseArrays( ctx, ~0 /* stage->changed_inputs */ );
 276    r200EmitArrays( ctx, stage->inputs );
 277
 278    rmesa->tcl.Elts = VB->Elts;
 279
 280    for (i = 0 ; i < VB->PrimitiveCount ; i++)
 281    {
 282       GLuint prim = VB->Primitive[i].mode;
 283       GLuint start = VB->Primitive[i].start;
 284       GLuint length = VB->Primitive[i].count;
 285
 286       if (!length)
 287          continue;
 288
 289       if (rmesa->tcl.Elts)
 290          r200EmitEltPrimitive( ctx, start, start+length, prim );
 291       else
 292          r200EmitPrimitive( ctx, start, start+length, prim );
 293    }
 294
 295    return GL_FALSE;             /* finished the pipe */
 296 }
 297
 298
 299
 300 static void r200_check_tcl_render( GLcontext *ctx,
 301                                    struct tnl_pipeline_stage *stage )
 302 {
 303    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 304    GLuint inputs = VERT_BIT_POS;
 305
 306    /* Validate state:
 307     */
 308    if (rmesa->NewGLState)
 309       r200ValidateState( ctx );
 310
 311    if (ctx->RenderMode == GL_RENDER) {
 312       /* Make all this event-driven:
 313        */
 314       if (ctx->Light.Enabled) {
 315          inputs |= VERT_BIT_NORMAL;
 316
 317          if (1 || ctx->Light.ColorMaterialEnabled) {
 318             inputs |= VERT_BIT_COLOR0;
 319          }
 320       }
 321       else {
 322          inputs |= VERT_BIT_COLOR0;
 323
 324          if (ctx->_TriangleCaps & DD_SEPARATE_SPECULAR) {
 325             inputs |= VERT_BIT_COLOR1;
 326          }
 327       }
 328
 329       if (ctx->Texture.Unit[0]._ReallyEnabled) {
 330          if (ctx->Texture.Unit[0].TexGenEnabled) {
 331             if (rmesa->TexGenNeedNormals[0]) {
 332                inputs |= VERT_BIT_NORMAL;
 333             }
 334          } else {
 335             inputs |= VERT_BIT_TEX0;
 336          }
 337       }
 338
 339       if (ctx->Texture.Unit[1]._ReallyEnabled) {
 340          if (ctx->Texture.Unit[1].TexGenEnabled) {
 341             if (rmesa->TexGenNeedNormals[1]) {
 342                inputs |= VERT_BIT_NORMAL;
 343             }
 344          } else {
 345             inputs |= VERT_BIT_TEX1;
 346          }
 347       }
 348
 349       stage->inputs = inputs;
 350       stage->active = 1;
 351    }
 352    else
 353       stage->active = 0;
 354 }
 355
 356 static void r200_init_tcl_render( GLcontext *ctx,
 357                                     struct tnl_pipeline_stage *stage )
 358 {
 359    stage->check = r200_check_tcl_render;
 360    stage->check( ctx, stage );
 361 }
 362
 363 static void dtr( struct tnl_pipeline_stage *stage )
 364 {
 365    (void)stage;
 366 }
 367
 368
 369 /* Initial state for tcl stage.
 370  */
 371 const struct tnl_pipeline_stage _r200_tcl_stage =
 372 {
 373    "r200 render",
 374    (_DD_NEW_SEPARATE_SPECULAR |
 375     _NEW_LIGHT|
 376     _NEW_TEXTURE|
 377     _NEW_FOG|
 378     _NEW_RENDERMODE),           /* re-check (new inputs) */
 379    0,                           /* re-run (always runs) */
 380    GL_TRUE,                     /* active */
 381    0, 0,                        /* inputs (set in check_render), outputs */
 382    0, 0,                        /* changed_inputs, private */
 383    dtr,                         /* destructor */
 384    r200_init_tcl_render,        /* check - initially set to alloc data */
 385    r200_run_tcl_render  /* run */
 386 };
 387
 388
 389
 390 /**********************************************************************/
 391 /*                 Validate state at pipeline start                   */
 392 /**********************************************************************/
 393
 394
 395 /*-----------------------------------------------------------------------
 396  * Manage TCL fallbacks
 397  */
 398
 399
 400 static void transition_to_swtnl( GLcontext *ctx )
 401 {
 402    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 403    TNLcontext *tnl = TNL_CONTEXT(ctx);
 404
 405    R200_NEWPRIM( rmesa );
 406
 407    r200ChooseVertexState( ctx );
 408    r200ChooseRenderState( ctx );
 409
 410    _mesa_validate_all_lighting_tables( ctx );
 411
 412    tnl->Driver.NotifyMaterialChange =
 413       _mesa_validate_all_lighting_tables;
 414
 415    r200ReleaseArrays( ctx, ~0 );
 416
 417    /* Still using the D3D based hardware-rasterizer from the radeon;
 418     * need to put the card into D3D mode to make it work:
 419     */
 420    R200_STATECHANGE( rmesa, vap );
 421    rmesa->hw.vap.cmd[VAP_SE_VAP_CNTL] &= ~R200_VAP_TCL_ENABLE;
 422    rmesa->hw.vap.cmd[VAP_SE_VAP_CNTL] |= R200_VAP_D3D_TEX_DEFAULT;
 423
 424    R200_STATECHANGE( rmesa, vte );
 425    rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL] &= ~R200_VTX_W0_FMT;
 426
 427    R200_STATECHANGE( rmesa, set );
 428    rmesa->hw.set.cmd[SET_RE_CNTL] |= (R200_VTX_STQ0_D3D |
 429                                       R200_VTX_STQ1_D3D);
 430 }
 431
 432
 433 static void transition_to_hwtnl( GLcontext *ctx )
 434 {
 435    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 436    TNLcontext *tnl = TNL_CONTEXT(ctx);
 437
 438    _tnl_need_projected_coords( ctx, GL_FALSE );
 439
 440    r200UpdateMaterial( ctx );
 441
 442    tnl->Driver.NotifyMaterialChange = r200UpdateMaterial;
 443
 444    if ( rmesa->dma.flush )
 445       rmesa->dma.flush( rmesa );
 446
 447    rmesa->dma.flush = 0;
 448
 449    if (rmesa->swtcl.indexed_verts.buf)
 450       r200ReleaseDmaRegion( rmesa, &rmesa->swtcl.indexed_verts,
 451                               __FUNCTION__ );
 452
 453    R200_STATECHANGE( rmesa, vap );
 454    rmesa->hw.vap.cmd[VAP_SE_VAP_CNTL] |= R200_VAP_TCL_ENABLE;
 455    rmesa->hw.vap.cmd[VAP_SE_VAP_CNTL] &= ~(R200_VAP_FORCE_W_TO_ONE |
 456                                            R200_VAP_D3D_TEX_DEFAULT);
 457
 458    R200_STATECHANGE( rmesa, vte );
 459    rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL] &= ~(R200_VTX_XY_FMT|R200_VTX_Z_FMT);
 460    rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL] |= R200_VTX_W0_FMT;
 461
 462    R200_STATECHANGE( rmesa, set );
 463    rmesa->hw.set.cmd[SET_RE_CNTL] &= ~(R200_VTX_STQ0_D3D |
 464                                        R200_VTX_STQ1_D3D);
 465
 466
 467    if (R200_DEBUG & DEBUG_FALLBACKS)
 468       fprintf(stderr, "R200 end tcl fallback\n");
 469 }
 470
 471
 472 static char *fallbackStrings[] = {
 473    "Rasterization fallback",
 474    "Unfilled triangles",
 475    "Twosided lighting, differing materials",
 476    "Materials in VB (maybe between begin/end)",
 477    "Texgen unit 0",
 478    "Texgen unit 1",
 479    "Texgen unit 2",
 480    "User disable"
 481 };
 482
 483
 484 static char *getFallbackString(GLuint bit)
 485 {
 486    int i = 0;
 487    while (bit > 1) {
 488       i++;
 489       bit >>= 1;
 490    }
 491    return fallbackStrings[i];
 492 }
 493
 494
 495
 496 void r200TclFallback( GLcontext *ctx, GLuint bit, GLboolean mode )
 497 {
 498    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 499    GLuint oldfallback = rmesa->TclFallback;
 500
 501    if (mode) {
 502       rmesa->TclFallback |= bit;
 503       if (oldfallback == 0) {
 504          if (R200_DEBUG & DEBUG_FALLBACKS)
 505             fprintf(stderr, "R200 begin tcl fallback %s\n",
 506                     getFallbackString( bit ));
 507          transition_to_swtnl( ctx );
 508       }
 509    }
 510    else {
 511       rmesa->TclFallback &= ~bit;
 512       if (oldfallback == bit) {
 513          if (R200_DEBUG & DEBUG_FALLBACKS)
 514             fprintf(stderr, "R200 end tcl fallback %s\n",
 515                     getFallbackString( bit ));
 516          transition_to_hwtnl( ctx );
 517       }
 518    }
 519 }