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); (void)rmesa
 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 == r200FlushElts &&
 144        rmesa->store.cmd_used + nr*2 < R200_CMD_BUF_SZ) {
 145
 146       GLushort *dest = (GLushort *)(rmesa->store.cmd_buf +
 147                                     rmesa->store.cmd_used);
 148
 149       rmesa->store.cmd_used += nr*2;
 150
 151       return dest;
 152    }
 153    else {
 154       if (rmesa->dma.flush)
 155          rmesa->dma.flush( rmesa );
 156
 157       r200EnsureCmdBufSpace( rmesa, AOS_BUFSZ(rmesa->tcl.nr_aos_components) +
 158                              rmesa->hw.max_state_size + ELTS_BUFSZ(nr) );
 159
 160       r200EmitAOS( rmesa,
 161                    rmesa->tcl.aos_components,
 162                    rmesa->tcl.nr_aos_components, 0 );
 163
 164       return r200AllocEltsOpenEnded( rmesa, rmesa->tcl.hw_primitive, nr );
 165    }
 166 }
 167
 168
 169 #define CLOSE_ELTS()                            \
 170 do {                                            \
 171    if (0) R200_NEWPRIM( rmesa );                \
 172 }                                               \
 173 while (0)
 174
 175
 176 /* TODO: Try to extend existing primitive if both are identical,
 177  * discrete and there are no intervening state changes.  (Somewhat
 178  * duplicates changes to DrawArrays code)
 179  */
 180 static void EMIT_PRIM( GLcontext *ctx,
 181                        GLenum prim,
 182                        GLuint hwprim,
 183                        GLuint start,
 184                        GLuint count)
 185 {
 186    r200ContextPtr rmesa = R200_CONTEXT( ctx );
 187    r200TclPrimitive( ctx, prim, hwprim );
 188
 189    r200EnsureCmdBufSpace( rmesa, AOS_BUFSZ(rmesa->tcl.nr_aos_components) +
 190                           rmesa->hw.max_state_size + VBUF_BUFSZ );
 191
 192    r200EmitAOS( rmesa,
 193                   rmesa->tcl.aos_components,
 194                   rmesa->tcl.nr_aos_components,
 195                   start );
 196
 197    /* Why couldn't this packet have taken an offset param?
 198     */
 199    r200EmitVbufPrim( rmesa,
 200                      rmesa->tcl.hw_primitive,
 201                      count - start );
 202 }
 203
 204
 205
 206 /* Try & join small primitives
 207  */
 208 #if 0
 209 #define PREFER_DISCRETE_ELT_PRIM( NR, PRIM ) 0
 210 #else
 211 #define PREFER_DISCRETE_ELT_PRIM( NR, PRIM )                    \
 212   ((NR) < 20 ||                                                 \
 213    ((NR) < 40 &&                                                \
 214     rmesa->tcl.hw_primitive == (PRIM|                           \
 215                             R200_VF_TCL_OUTPUT_VTX_ENABLE|      \
 216                                 R200_VF_PRIM_WALK_IND)))
 217 #endif
 218
 219 #ifdef MESA_BIG_ENDIAN
 220 /* We could do without (most of) this ugliness if dest was always 32 bit word aligned... */
 221 #define EMIT_ELT(dest, offset, x) do {                                \
 222         int off = offset + ( ( (GLuint)dest & 0x2 ) >> 1 );     \
 223         GLushort *des = (GLushort *)( (GLuint)dest & ~0x2 );    \
 224         (des)[ off + 1 - 2 * ( off & 1 ) ] = (GLushort)(x); } while (0)
 225 #else
 226 #define EMIT_ELT(dest, offset, x) (dest)[offset] = (GLushort) (x)
 227 #endif
 228
 229 #define EMIT_TWO_ELTS(dest, offset, x, y)  *(GLuint *)((dest)+offset) = ((y)<<16)|(x);
 230
 231
 232
 233 #define TAG(x) tcl_##x
 234 #include "tnl_dd/t_dd_dmatmp2.h"
 235
 236 /**********************************************************************/
 237 /*                          External entrypoints                     */
 238 /**********************************************************************/
 239
 240 void r200EmitPrimitive( GLcontext *ctx,
 241                           GLuint first,
 242                           GLuint last,
 243                           GLuint flags )
 244 {
 245    tcl_render_tab_verts[flags&PRIM_MODE_MASK]( ctx, first, last, flags );
 246 }
 247
 248 void r200EmitEltPrimitive( GLcontext *ctx,
 249                              GLuint first,
 250                              GLuint last,
 251                              GLuint flags )
 252 {
 253    tcl_render_tab_elts[flags&PRIM_MODE_MASK]( ctx, first, last, flags );
 254 }
 255
 256 void r200TclPrimitive( GLcontext *ctx,
 257                          GLenum prim,
 258                          int hw_prim )
 259 {
 260    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 261    GLuint newprim = hw_prim | R200_VF_TCL_OUTPUT_VTX_ENABLE;
 262
 263    if (newprim != rmesa->tcl.hw_primitive ||
 264        !discrete_prim[hw_prim&0xf]) {
 265       R200_NEWPRIM( rmesa );
 266       rmesa->tcl.hw_primitive = newprim;
 267    }
 268 }
 269
 270
 271 /**********************************************************************/
 272 /*                          Render pipeline stage                     */
 273 /**********************************************************************/
 274
 275
 276 /* TCL render.
 277  */
 278 static GLboolean r200_run_tcl_render( GLcontext *ctx,
 279                                       struct tnl_pipeline_stage *stage )
 280 {
 281    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 282    TNLcontext *tnl = TNL_CONTEXT(ctx);
 283    struct vertex_buffer *VB = &tnl->vb;
 284    GLuint i;
 285
 286    /* TODO: separate this from the swtnl pipeline
 287     */
 288    if (rmesa->TclFallback)
 289       return GL_TRUE;   /* fallback to software t&l */
 290
 291    if (R200_DEBUG & DEBUG_PRIMS)
 292       fprintf(stderr, "%s\n", __FUNCTION__);
 293
 294    if (VB->Count == 0)
 295       return GL_FALSE;
 296
 297    r200ReleaseArrays( ctx, ~0 /* stage->changed_inputs */ );
 298    r200EmitArrays( ctx, stage->inputs );
 299
 300    rmesa->tcl.Elts = VB->Elts;
 301
 302    for (i = 0 ; i < VB->PrimitiveCount ; i++)
 303    {
 304       GLuint prim = VB->Primitive[i].mode;
 305       GLuint start = VB->Primitive[i].start;
 306       GLuint length = VB->Primitive[i].count;
 307
 308       if (!length)
 309          continue;
 310
 311       if (rmesa->tcl.Elts)
 312          r200EmitEltPrimitive( ctx, start, start+length, prim );
 313       else
 314          r200EmitPrimitive( ctx, start, start+length, prim );
 315    }
 316
 317    return GL_FALSE;             /* finished the pipe */
 318 }
 319
 320
 321
 322 static void r200_check_tcl_render( GLcontext *ctx,
 323                                    struct tnl_pipeline_stage *stage )
 324 {
 325    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 326    GLuint inputs = VERT_BIT_POS;
 327    GLuint unit;
 328
 329    /* Validate state:
 330     */
 331    if (rmesa->NewGLState)
 332       r200ValidateState( ctx );
 333
 334    if (ctx->RenderMode == GL_RENDER) {
 335       /* Make all this event-driven:
 336        */
 337       if (ctx->Light.Enabled) {
 338          inputs |= VERT_BIT_NORMAL;
 339
 340          if (1 || ctx->Light.ColorMaterialEnabled) {
 341             inputs |= VERT_BIT_COLOR0;
 342          }
 343       }
 344       else {
 345          inputs |= VERT_BIT_COLOR0;
 346
 347          if (ctx->_TriangleCaps & DD_SEPARATE_SPECULAR) {
 348             inputs |= VERT_BIT_COLOR1;
 349          }
 350       }
 351
 352       for (unit = 0 ; unit < ctx->Const.MaxTextureUnits; unit++) {
 353          if (ctx->Texture.Unit[unit]._ReallyEnabled) {
 354             if (rmesa->TexGenNeedNormals[unit]) {
 355                inputs |= VERT_BIT_NORMAL;
 356             }
 357             inputs |= VERT_BIT_TEX(unit);
 358          }
 359       }
 360
 361       stage->inputs = inputs;
 362       stage->active = 1;
 363    }
 364    else
 365       stage->active = 0;
 366 }
 367
 368 static void r200_init_tcl_render( GLcontext *ctx,
 369                                     struct tnl_pipeline_stage *stage )
 370 {
 371    stage->check = r200_check_tcl_render;
 372    stage->check( ctx, stage );
 373 }
 374
 375 static void dtr( struct tnl_pipeline_stage *stage )
 376 {
 377    (void)stage;
 378 }
 379
 380
 381 /* Initial state for tcl stage.
 382  */
 383 const struct tnl_pipeline_stage _r200_tcl_stage =
 384 {
 385    "r200 render",
 386    (_DD_NEW_SEPARATE_SPECULAR |
 387     _NEW_LIGHT|
 388     _NEW_TEXTURE|
 389     _NEW_FOG|
 390     _NEW_RENDERMODE),           /* re-check (new inputs) */
 391    0,                           /* re-run (always runs) */
 392    GL_TRUE,                     /* active */
 393    0, 0,                        /* inputs (set in check_render), outputs */
 394    0, 0,                        /* changed_inputs, private */
 395    dtr,                         /* destructor */
 396    r200_init_tcl_render,        /* check - initially set to alloc data */
 397    r200_run_tcl_render  /* run */
 398 };
 399
 400
 401
 402 /**********************************************************************/
 403 /*                 Validate state at pipeline start                   */
 404 /**********************************************************************/
 405
 406
 407 /*-----------------------------------------------------------------------
 408  * Manage TCL fallbacks
 409  */
 410
 411
 412 static void transition_to_swtnl( GLcontext *ctx )
 413 {
 414    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 415    TNLcontext *tnl = TNL_CONTEXT(ctx);
 416
 417    R200_NEWPRIM( rmesa );
 418
 419    r200ChooseVertexState( ctx );
 420    r200ChooseRenderState( ctx );
 421
 422    _mesa_validate_all_lighting_tables( ctx );
 423
 424    tnl->Driver.NotifyMaterialChange =
 425       _mesa_validate_all_lighting_tables;
 426
 427    r200ReleaseArrays( ctx, ~0 );
 428
 429    /* Still using the D3D based hardware-rasterizer from the radeon;
 430     * need to put the card into D3D mode to make it work:
 431     */
 432    R200_STATECHANGE( rmesa, vap );
 433    rmesa->hw.vap.cmd[VAP_SE_VAP_CNTL] &= ~R200_VAP_TCL_ENABLE;
 434 }
 435
 436 static void transition_to_hwtnl( GLcontext *ctx )
 437 {
 438    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 439    TNLcontext *tnl = TNL_CONTEXT(ctx);
 440
 441    _tnl_need_projected_coords( ctx, GL_FALSE );
 442
 443    r200UpdateMaterial( ctx );
 444
 445    tnl->Driver.NotifyMaterialChange = r200UpdateMaterial;
 446
 447    if ( rmesa->dma.flush )
 448       rmesa->dma.flush( rmesa );
 449
 450    rmesa->dma.flush = 0;
 451
 452    if (rmesa->swtcl.indexed_verts.buf)
 453       r200ReleaseDmaRegion( rmesa, &rmesa->swtcl.indexed_verts,
 454                               __FUNCTION__ );
 455
 456    R200_STATECHANGE( rmesa, vap );
 457    rmesa->hw.vap.cmd[VAP_SE_VAP_CNTL] |= R200_VAP_TCL_ENABLE;
 458    rmesa->hw.vap.cmd[VAP_SE_VAP_CNTL] &= ~R200_VAP_FORCE_W_TO_ONE;
 459
 460    R200_STATECHANGE( rmesa, vte );
 461    rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL] &= ~(R200_VTX_XY_FMT|R200_VTX_Z_FMT);
 462
 463    if (R200_DEBUG & DEBUG_FALLBACKS)
 464       fprintf(stderr, "R200 end tcl fallback\n");
 465 }
 466
 467
 468 static char *fallbackStrings[] = {
 469    "Rasterization fallback",
 470    "Unfilled triangles",
 471    "Twosided lighting, differing materials",
 472    "Materials in VB (maybe between begin/end)",
 473    "Texgen unit 0",
 474    "Texgen unit 1",
 475    "Texgen unit 2",
 476    "Texgen unit 3",
 477    "Texgen unit 4",
 478    "Texgen unit 5",
 479    "User disable",
 480    "Bitmap as points"
 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 }