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

   1 /* $XFree86$ */
   2 /**************************************************************************
   3
   4 Copyright (C) The Weather Channel, Inc.  2002.  All Rights Reserved.
   5
   6 The Weather Channel (TM) funded Tungsten Graphics to develop the
   7 initial release of the Radeon 8500 driver under the XFree86 license.
   8 This notice must be preserved.
   9
  10 Permission is hereby granted, free of charge, to any person obtaining
  11 a copy of this software and associated documentation files (the
  12 "Software"), to deal in the Software without restriction, including
  13 without limitation the rights to use, copy, modify, merge, publish,
  14 distribute, sublicense, and/or sell copies of the Software, and to
  15 permit persons to whom the Software is furnished to do so, subject to
  16 the following conditions:
  17
  18 The above copyright notice and this permission notice (including the
  19 next paragraph) shall be included in all copies or substantial
  20 portions of the Software.
  21
  22 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  25 IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
  26 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  27 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  28 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29
  30 **************************************************************************/
  31
  32 /*
  33  * Authors:
  34  *   Keith Whitwell <keith@tungstengraphics.com>
  35  */
  36
  37 #include "glheader.h"
  38 #include "imports.h"
  39 #include "api_arrayelt.h"
  40 #include "enums.h"
  41 #include "colormac.h"
  42 #include "light.h"
  43
  44 #include "swrast/swrast.h"
  45 #include "array_cache/acache.h"
  46 #include "tnl/tnl.h"
  47 #include "tnl/t_pipeline.h"
  48 #include "swrast_setup/swrast_setup.h"
  49
  50
  51 #include "r200_context.h"
  52 #include "r200_ioctl.h"
  53 #include "r200_state.h"
  54 #include "r200_tcl.h"
  55 #include "r200_tex.h"
  56 #include "r200_swtcl.h"
  57 #include "r200_vtxfmt.h"
  58
  59
  60 /* =============================================================
  61  * Alpha blending
  62  */
  63
  64 static void r200AlphaFunc( GLcontext *ctx, GLenum func, GLfloat ref )
  65 {
  66    r200ContextPtr rmesa = R200_CONTEXT(ctx);
  67    int pp_misc = rmesa->hw.ctx.cmd[CTX_PP_MISC];
  68    GLubyte refByte;
  69
  70    CLAMPED_FLOAT_TO_UBYTE(refByte, ref);
  71
  72    R200_STATECHANGE( rmesa, ctx );
  73
  74    pp_misc &= ~(R200_ALPHA_TEST_OP_MASK | R200_REF_ALPHA_MASK);
  75    pp_misc |= (refByte & R200_REF_ALPHA_MASK);
  76
  77    switch ( func ) {
  78    case GL_NEVER:
  79       pp_misc |= R200_ALPHA_TEST_FAIL;
  80       break;
  81    case GL_LESS:
  82       pp_misc |= R200_ALPHA_TEST_LESS;
  83       break;
  84    case GL_EQUAL:
  85       pp_misc |= R200_ALPHA_TEST_EQUAL;
  86       break;
  87    case GL_LEQUAL:
  88       pp_misc |= R200_ALPHA_TEST_LEQUAL;
  89       break;
  90    case GL_GREATER:
  91       pp_misc |= R200_ALPHA_TEST_GREATER;
  92       break;
  93    case GL_NOTEQUAL:
  94       pp_misc |= R200_ALPHA_TEST_NEQUAL;
  95       break;
  96    case GL_GEQUAL:
  97       pp_misc |= R200_ALPHA_TEST_GEQUAL;
  98       break;
  99    case GL_ALWAYS:
 100       pp_misc |= R200_ALPHA_TEST_PASS;
 101       break;
 102    }
 103
 104    rmesa->hw.ctx.cmd[CTX_PP_MISC] = pp_misc;
 105 }
 106
 107 static void r200BlendEquation( GLcontext *ctx, GLenum mode )
 108 {
 109    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 110    GLuint b = rmesa->hw.ctx.cmd[CTX_RB3D_BLENDCNTL] & ~R200_COMB_FCN_MASK;
 111
 112    switch ( mode ) {
 113    case GL_FUNC_ADD:
 114    case GL_LOGIC_OP:
 115       b |= R200_COMB_FCN_ADD_CLAMP;
 116       break;
 117
 118    case GL_FUNC_SUBTRACT:
 119       b |= R200_COMB_FCN_SUB_CLAMP;
 120       break;
 121
 122    case GL_FUNC_REVERSE_SUBTRACT:
 123       b |= R200_COMB_FCN_RSUB_CLAMP;
 124       break;
 125
 126    case GL_MIN:
 127       b |= R200_COMB_FCN_MIN;
 128       break;
 129
 130    case GL_MAX:
 131       b |= R200_COMB_FCN_MAX;
 132       break;
 133
 134    default:
 135       break;
 136    }
 137
 138    R200_STATECHANGE( rmesa, ctx );
 139    rmesa->hw.ctx.cmd[CTX_RB3D_BLENDCNTL] = b;
 140    if ( ctx->Color.ColorLogicOpEnabled ) {
 141       rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] |=  R200_ROP_ENABLE;
 142    } else {
 143       rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] &= ~R200_ROP_ENABLE;
 144    }
 145 }
 146
 147 static void r200BlendFuncSeparate( GLcontext *ctx,
 148                                      GLenum sfactorRGB, GLenum dfactorRGB,
 149                                      GLenum sfactorA, GLenum dfactorA )
 150 {
 151    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 152    GLuint b = rmesa->hw.ctx.cmd[CTX_RB3D_BLENDCNTL] &
 153       ~(R200_SRC_BLEND_MASK | R200_DST_BLEND_MASK);
 154
 155    switch ( ctx->Color.BlendSrcRGB ) {
 156    case GL_ZERO:
 157       b |= R200_SRC_BLEND_GL_ZERO;
 158       break;
 159    case GL_ONE:
 160       b |= R200_SRC_BLEND_GL_ONE;
 161       break;
 162    case GL_DST_COLOR:
 163       b |= R200_SRC_BLEND_GL_DST_COLOR;
 164       break;
 165    case GL_ONE_MINUS_DST_COLOR:
 166       b |= R200_SRC_BLEND_GL_ONE_MINUS_DST_COLOR;
 167       break;
 168    case GL_SRC_COLOR:
 169       b |= R200_SRC_BLEND_GL_SRC_COLOR;
 170       break;
 171    case GL_ONE_MINUS_SRC_COLOR:
 172       b |= R200_SRC_BLEND_GL_ONE_MINUS_SRC_COLOR;
 173       break;
 174    case GL_SRC_ALPHA:
 175       b |= R200_SRC_BLEND_GL_SRC_ALPHA;
 176       break;
 177    case GL_ONE_MINUS_SRC_ALPHA:
 178       b |= R200_SRC_BLEND_GL_ONE_MINUS_SRC_ALPHA;
 179       break;
 180    case GL_DST_ALPHA:
 181       b |= R200_SRC_BLEND_GL_DST_ALPHA;
 182       break;
 183    case GL_ONE_MINUS_DST_ALPHA:
 184       b |= R200_SRC_BLEND_GL_ONE_MINUS_DST_ALPHA;
 185       break;
 186    case GL_SRC_ALPHA_SATURATE:
 187       b |= R200_SRC_BLEND_GL_SRC_ALPHA_SATURATE;
 188       break;
 189    case GL_CONSTANT_COLOR:
 190       b |= R200_SRC_BLEND_GL_CONST_COLOR;
 191       break;
 192    case GL_ONE_MINUS_CONSTANT_COLOR:
 193       b |= R200_SRC_BLEND_GL_ONE_MINUS_CONST_COLOR;
 194       break;
 195    case GL_CONSTANT_ALPHA:
 196       b |= R200_SRC_BLEND_GL_CONST_ALPHA;
 197       break;
 198    case GL_ONE_MINUS_CONSTANT_ALPHA:
 199       b |= R200_SRC_BLEND_GL_ONE_MINUS_CONST_ALPHA;
 200       break;
 201    default:
 202       break;
 203    }
 204
 205    switch ( ctx->Color.BlendDstRGB ) {
 206    case GL_ZERO:
 207       b |= R200_DST_BLEND_GL_ZERO;
 208       break;
 209    case GL_ONE:
 210       b |= R200_DST_BLEND_GL_ONE;
 211       break;
 212    case GL_SRC_COLOR:
 213       b |= R200_DST_BLEND_GL_SRC_COLOR;
 214       break;
 215    case GL_ONE_MINUS_SRC_COLOR:
 216       b |= R200_DST_BLEND_GL_ONE_MINUS_SRC_COLOR;
 217       break;
 218    case GL_SRC_ALPHA:
 219       b |= R200_DST_BLEND_GL_SRC_ALPHA;
 220       break;
 221    case GL_ONE_MINUS_SRC_ALPHA:
 222       b |= R200_DST_BLEND_GL_ONE_MINUS_SRC_ALPHA;
 223       break;
 224    case GL_DST_COLOR:
 225       b |= R200_DST_BLEND_GL_DST_COLOR;
 226       break;
 227    case GL_ONE_MINUS_DST_COLOR:
 228       b |= R200_DST_BLEND_GL_ONE_MINUS_DST_COLOR;
 229       break;
 230    case GL_DST_ALPHA:
 231       b |= R200_DST_BLEND_GL_DST_ALPHA;
 232       break;
 233    case GL_ONE_MINUS_DST_ALPHA:
 234       b |= R200_DST_BLEND_GL_ONE_MINUS_DST_ALPHA;
 235       break;
 236    case GL_CONSTANT_COLOR:
 237       b |= R200_DST_BLEND_GL_CONST_COLOR;
 238       break;
 239    case GL_ONE_MINUS_CONSTANT_COLOR:
 240       b |= R200_DST_BLEND_GL_ONE_MINUS_CONST_COLOR;
 241       break;
 242    case GL_CONSTANT_ALPHA:
 243       b |= R200_DST_BLEND_GL_CONST_ALPHA;
 244       break;
 245    case GL_ONE_MINUS_CONSTANT_ALPHA:
 246       b |= R200_DST_BLEND_GL_ONE_MINUS_CONST_ALPHA;
 247       break;
 248    default:
 249       break;
 250    }
 251
 252    R200_STATECHANGE( rmesa, ctx );
 253    rmesa->hw.ctx.cmd[CTX_RB3D_BLENDCNTL] = b;
 254 }
 255
 256
 257 /* =============================================================
 258  * Depth testing
 259  */
 260
 261 static void r200DepthFunc( GLcontext *ctx, GLenum func )
 262 {
 263    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 264
 265    R200_STATECHANGE( rmesa, ctx );
 266    rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] &= ~R200_Z_TEST_MASK;
 267
 268    switch ( ctx->Depth.Func ) {
 269    case GL_NEVER:
 270       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_Z_TEST_NEVER;
 271       break;
 272    case GL_LESS:
 273       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_Z_TEST_LESS;
 274       break;
 275    case GL_EQUAL:
 276       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_Z_TEST_EQUAL;
 277       break;
 278    case GL_LEQUAL:
 279       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_Z_TEST_LEQUAL;
 280       break;
 281    case GL_GREATER:
 282       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_Z_TEST_GREATER;
 283       break;
 284    case GL_NOTEQUAL:
 285       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_Z_TEST_NEQUAL;
 286       break;
 287    case GL_GEQUAL:
 288       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_Z_TEST_GEQUAL;
 289       break;
 290    case GL_ALWAYS:
 291       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_Z_TEST_ALWAYS;
 292       break;
 293    }
 294 }
 295
 296
 297 static void r200DepthMask( GLcontext *ctx, GLboolean flag )
 298 {
 299    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 300    R200_STATECHANGE( rmesa, ctx );
 301
 302    if ( ctx->Depth.Mask ) {
 303       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |=  R200_Z_WRITE_ENABLE;
 304    } else {
 305       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] &= ~R200_Z_WRITE_ENABLE;
 306    }
 307 }
 308
 309
 310 /* =============================================================
 311  * Fog
 312  */
 313
 314
 315 static void r200Fogfv( GLcontext *ctx, GLenum pname, const GLfloat *param )
 316 {
 317    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 318    union { int i; float f; } c, d;
 319    GLchan col[4];
 320    GLuint i;
 321
 322    c.i = rmesa->hw.fog.cmd[FOG_C];
 323    d.i = rmesa->hw.fog.cmd[FOG_D];
 324
 325    switch (pname) {
 326    case GL_FOG_MODE:
 327       if (!ctx->Fog.Enabled)
 328          return;
 329       R200_STATECHANGE(rmesa, tcl);
 330       rmesa->hw.tcl.cmd[TCL_UCP_VERT_BLEND_CTL] &= ~R200_TCL_FOG_MASK;
 331       switch (ctx->Fog.Mode) {
 332       case GL_LINEAR:
 333          rmesa->hw.tcl.cmd[TCL_UCP_VERT_BLEND_CTL] |= R200_TCL_FOG_LINEAR;
 334          if (ctx->Fog.Start == ctx->Fog.End) {
 335             c.f = 1.0F;
 336             d.f = 1.0F;
 337          }
 338          else {
 339             c.f = ctx->Fog.End/(ctx->Fog.End-ctx->Fog.Start);
 340             d.f = -1.0/(ctx->Fog.End-ctx->Fog.Start);
 341          }
 342          break;
 343       case GL_EXP:
 344          rmesa->hw.tcl.cmd[TCL_UCP_VERT_BLEND_CTL] |= R200_TCL_FOG_EXP;
 345          c.f = 0.0;
 346          d.f = -ctx->Fog.Density;
 347          break;
 348       case GL_EXP2:
 349          rmesa->hw.tcl.cmd[TCL_UCP_VERT_BLEND_CTL] |= R200_TCL_FOG_EXP2;
 350          c.f = 0.0;
 351          d.f = -(ctx->Fog.Density * ctx->Fog.Density);
 352          break;
 353       default:
 354          return;
 355       }
 356       break;
 357    case GL_FOG_DENSITY:
 358       switch (ctx->Fog.Mode) {
 359       case GL_EXP:
 360          c.f = 0.0;
 361          d.f = -ctx->Fog.Density;
 362          break;
 363       case GL_EXP2:
 364          c.f = 0.0;
 365          d.f = -(ctx->Fog.Density * ctx->Fog.Density);
 366          break;
 367       default:
 368          break;
 369       }
 370       break;
 371    case GL_FOG_START:
 372    case GL_FOG_END:
 373       if (ctx->Fog.Mode == GL_LINEAR) {
 374          if (ctx->Fog.Start == ctx->Fog.End) {
 375             c.f = 1.0F;
 376             d.f = 1.0F;
 377          } else {
 378             c.f = ctx->Fog.End/(ctx->Fog.End-ctx->Fog.Start);
 379             d.f = -1.0/(ctx->Fog.End-ctx->Fog.Start);
 380          }
 381       }
 382       break;
 383    case GL_FOG_COLOR:
 384       R200_STATECHANGE( rmesa, ctx );
 385       UNCLAMPED_FLOAT_TO_RGB_CHAN( col, ctx->Fog.Color );
 386       i = r200PackColor( 4, col[0], col[1], col[2], 0 );
 387       rmesa->hw.ctx.cmd[CTX_PP_FOG_COLOR] &= ~R200_FOG_COLOR_MASK;
 388       rmesa->hw.ctx.cmd[CTX_PP_FOG_COLOR] |= i;
 389       break;
 390    case GL_FOG_COORDINATE_SOURCE_EXT:
 391       /* What to do?
 392        */
 393       break;
 394    default:
 395       return;
 396    }
 397
 398    if (c.i != rmesa->hw.fog.cmd[FOG_C] || d.i != rmesa->hw.fog.cmd[FOG_D]) {
 399       R200_STATECHANGE( rmesa, fog );
 400       rmesa->hw.fog.cmd[FOG_C] = c.i;
 401       rmesa->hw.fog.cmd[FOG_D] = d.i;
 402    }
 403 }
 404
 405
 406 /* =============================================================
 407  * Scissoring
 408  */
 409
 410
 411 static GLboolean intersect_rect( XF86DRIClipRectPtr out,
 412                                  XF86DRIClipRectPtr a,
 413                                  XF86DRIClipRectPtr b )
 414 {
 415    *out = *a;
 416    if ( b->x1 > out->x1 ) out->x1 = b->x1;
 417    if ( b->y1 > out->y1 ) out->y1 = b->y1;
 418    if ( b->x2 < out->x2 ) out->x2 = b->x2;
 419    if ( b->y2 < out->y2 ) out->y2 = b->y2;
 420    if ( out->x1 >= out->x2 ) return GL_FALSE;
 421    if ( out->y1 >= out->y2 ) return GL_FALSE;
 422    return GL_TRUE;
 423 }
 424
 425
 426 void r200RecalcScissorRects( r200ContextPtr rmesa )
 427 {
 428    XF86DRIClipRectPtr out;
 429    int i;
 430
 431    /* Grow cliprect store?
 432     */
 433    if (rmesa->state.scissor.numAllocedClipRects < rmesa->numClipRects) {
 434       while (rmesa->state.scissor.numAllocedClipRects < rmesa->numClipRects) {
 435          rmesa->state.scissor.numAllocedClipRects += 1; /* zero case */
 436          rmesa->state.scissor.numAllocedClipRects *= 2;
 437       }
 438
 439       if (rmesa->state.scissor.pClipRects)
 440          FREE(rmesa->state.scissor.pClipRects);
 441
 442       rmesa->state.scissor.pClipRects =
 443          MALLOC( rmesa->state.scissor.numAllocedClipRects *
 444                  sizeof(XF86DRIClipRectRec) );
 445
 446       if ( rmesa->state.scissor.pClipRects == NULL ) {
 447          rmesa->state.scissor.numAllocedClipRects = 0;
 448          return;
 449       }
 450    }
 451
 452    out = rmesa->state.scissor.pClipRects;
 453    rmesa->state.scissor.numClipRects = 0;
 454
 455    for ( i = 0 ; i < rmesa->numClipRects ;  i++ ) {
 456       if ( intersect_rect( out,
 457                            &rmesa->pClipRects[i],
 458                            &rmesa->state.scissor.rect ) ) {
 459          rmesa->state.scissor.numClipRects++;
 460          out++;
 461       }
 462    }
 463 }
 464
 465
 466 static void r200UpdateScissor( GLcontext *ctx )
 467 {
 468    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 469
 470    if ( rmesa->dri.drawable ) {
 471       __DRIdrawablePrivate *dPriv = rmesa->dri.drawable;
 472
 473       int x = ctx->Scissor.X;
 474       int y = dPriv->h - ctx->Scissor.Y - ctx->Scissor.Height;
 475       int w = ctx->Scissor.X + ctx->Scissor.Width - 1;
 476       int h = dPriv->h - ctx->Scissor.Y - 1;
 477
 478       rmesa->state.scissor.rect.x1 = x + dPriv->x;
 479       rmesa->state.scissor.rect.y1 = y + dPriv->y;
 480       rmesa->state.scissor.rect.x2 = w + dPriv->x + 1;
 481       rmesa->state.scissor.rect.y2 = h + dPriv->y + 1;
 482
 483       r200RecalcScissorRects( rmesa );
 484    }
 485 }
 486
 487
 488 static void r200Scissor( GLcontext *ctx,
 489                            GLint x, GLint y, GLsizei w, GLsizei h )
 490 {
 491    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 492
 493    if ( ctx->Scissor.Enabled ) {
 494       R200_FIREVERTICES( rmesa );       /* don't pipeline cliprect changes */
 495       r200UpdateScissor( ctx );
 496    }
 497
 498 }
 499
 500
 501 /* =============================================================
 502  * Culling
 503  */
 504
 505 static void r200CullFace( GLcontext *ctx, GLenum unused )
 506 {
 507    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 508    GLuint s = rmesa->hw.set.cmd[SET_SE_CNTL];
 509    GLuint t = rmesa->hw.tcl.cmd[TCL_UCP_VERT_BLEND_CTL];
 510
 511    s |= R200_FFACE_SOLID | R200_BFACE_SOLID;
 512    t &= ~(R200_CULL_FRONT | R200_CULL_BACK);
 513
 514    if ( ctx->Polygon.CullFlag ) {
 515       switch ( ctx->Polygon.CullFaceMode ) {
 516       case GL_FRONT:
 517          s &= ~R200_FFACE_SOLID;
 518          t |= R200_CULL_FRONT;
 519          break;
 520       case GL_BACK:
 521          s &= ~R200_BFACE_SOLID;
 522          t |= R200_CULL_BACK;
 523          break;
 524       case GL_FRONT_AND_BACK:
 525          s &= ~(R200_FFACE_SOLID | R200_BFACE_SOLID);
 526          t |= (R200_CULL_FRONT | R200_CULL_BACK);
 527          break;
 528       }
 529    }
 530
 531    if ( rmesa->hw.set.cmd[SET_SE_CNTL] != s ) {
 532       R200_STATECHANGE(rmesa, set );
 533       rmesa->hw.set.cmd[SET_SE_CNTL] = s;
 534    }
 535
 536    if ( rmesa->hw.tcl.cmd[TCL_UCP_VERT_BLEND_CTL] != t ) {
 537       R200_STATECHANGE(rmesa, tcl );
 538       rmesa->hw.tcl.cmd[TCL_UCP_VERT_BLEND_CTL] = t;
 539    }
 540 }
 541
 542 static void r200FrontFace( GLcontext *ctx, GLenum mode )
 543 {
 544    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 545
 546    R200_STATECHANGE( rmesa, set );
 547    rmesa->hw.set.cmd[SET_SE_CNTL] &= ~R200_FFACE_CULL_DIR_MASK;
 548
 549    R200_STATECHANGE( rmesa, tcl );
 550    rmesa->hw.tcl.cmd[TCL_UCP_VERT_BLEND_CTL] &= ~R200_CULL_FRONT_IS_CCW;
 551
 552    switch ( mode ) {
 553    case GL_CW:
 554       rmesa->hw.set.cmd[SET_SE_CNTL] |= R200_FFACE_CULL_CW;
 555       break;
 556    case GL_CCW:
 557       rmesa->hw.set.cmd[SET_SE_CNTL] |= R200_FFACE_CULL_CCW;
 558       rmesa->hw.tcl.cmd[TCL_UCP_VERT_BLEND_CTL] |= R200_CULL_FRONT_IS_CCW;
 559       break;
 560    }
 561 }
 562
 563 /* =============================================================
 564  * Point state
 565  */
 566 static void r200PointSize( GLcontext *ctx, GLfloat size )
 567 {
 568    if (0) fprintf(stderr, "%s: %f\n", __FUNCTION__, size );
 569 }
 570
 571 /* =============================================================
 572  * Line state
 573  */
 574 static void r200LineWidth( GLcontext *ctx, GLfloat widthf )
 575 {
 576    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 577
 578    R200_STATECHANGE( rmesa, lin );
 579    R200_STATECHANGE( rmesa, set );
 580
 581    /* Line width is stored in U6.4 format.
 582     */
 583    rmesa->hw.lin.cmd[LIN_SE_LINE_WIDTH] &= ~0xffff;
 584    rmesa->hw.lin.cmd[LIN_SE_LINE_WIDTH] |= (GLuint)(ctx->Line._Width * 16.0);
 585
 586    if ( widthf > 1.0 ) {
 587       rmesa->hw.set.cmd[SET_SE_CNTL] |=  R200_WIDELINE_ENABLE;
 588    } else {
 589       rmesa->hw.set.cmd[SET_SE_CNTL] &= ~R200_WIDELINE_ENABLE;
 590    }
 591 }
 592
 593 static void r200LineStipple( GLcontext *ctx, GLint factor, GLushort pattern )
 594 {
 595    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 596
 597    R200_STATECHANGE( rmesa, lin );
 598    rmesa->hw.lin.cmd[LIN_RE_LINE_PATTERN] =
 599       ((((GLuint)factor & 0xff) << 16) | ((GLuint)pattern));
 600 }
 601
 602
 603 /* =============================================================
 604  * Masks
 605  */
 606 static void r200ColorMask( GLcontext *ctx,
 607                            GLboolean r, GLboolean g,
 608                            GLboolean b, GLboolean a )
 609 {
 610    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 611    GLuint mask = r200PackColor( rmesa->r200Screen->cpp,
 612                                 ctx->Color.ColorMask[RCOMP],
 613                                 ctx->Color.ColorMask[GCOMP],
 614                                 ctx->Color.ColorMask[BCOMP],
 615                                 ctx->Color.ColorMask[ACOMP] );
 616
 617    GLuint flag = rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] & ~R200_PLANE_MASK_ENABLE;
 618
 619    if (!(r && g && b && a))
 620       flag |= R200_PLANE_MASK_ENABLE;
 621
 622    if ( rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] != flag ) {
 623       R200_STATECHANGE( rmesa, ctx );
 624       rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] = flag;
 625    }
 626
 627    if ( rmesa->hw.msk.cmd[MSK_RB3D_PLANEMASK] != mask ) {
 628       R200_STATECHANGE( rmesa, msk );
 629       rmesa->hw.msk.cmd[MSK_RB3D_PLANEMASK] = mask;
 630    }
 631 }
 632
 633
 634 /* =============================================================
 635  * Polygon state
 636  */
 637
 638 static void r200PolygonOffset( GLcontext *ctx,
 639                                GLfloat factor, GLfloat units )
 640 {
 641    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 642    GLfloat constant = units * rmesa->state.depth.scale;
 643
 644 /*    factor *= 2; */
 645 /*    constant *= 2; */
 646
 647 /*    fprintf(stderr, "%s f:%f u:%f\n", __FUNCTION__, factor, constant); */
 648
 649    R200_STATECHANGE( rmesa, zbs );
 650    rmesa->hw.zbs.cmd[ZBS_SE_ZBIAS_FACTOR]   = *(GLuint *)&factor;
 651    rmesa->hw.zbs.cmd[ZBS_SE_ZBIAS_CONSTANT] = *(GLuint *)&constant;
 652 }
 653
 654 static void r200PolygonStipple( GLcontext *ctx, const GLubyte *mask )
 655 {
 656    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 657    GLuint i;
 658    drmRadeonStipple stipple;
 659
 660    /* Must flip pattern upside down.
 661     */
 662    for ( i = 0 ; i < 32 ; i++ ) {
 663       rmesa->state.stipple.mask[31 - i] = ((GLuint *) mask)[i];
 664    }
 665
 666    /* TODO: push this into cmd mechanism
 667     */
 668    R200_FIREVERTICES( rmesa );
 669    LOCK_HARDWARE( rmesa );
 670
 671    /* FIXME: Use window x,y offsets into stipple RAM.
 672     */
 673    stipple.mask = rmesa->state.stipple.mask;
 674    drmCommandWrite( rmesa->dri.fd, DRM_RADEON_STIPPLE,
 675                     &stipple, sizeof(drmRadeonStipple) );
 676    UNLOCK_HARDWARE( rmesa );
 677 }
 678
 679 static void r200PolygonMode( GLcontext *ctx, GLenum face, GLenum mode )
 680 {
 681    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 682    GLboolean flag = (ctx->_TriangleCaps & DD_TRI_UNFILLED) != 0;
 683
 684    /* Can't generally do unfilled via tcl, but some good special
 685     * cases work.
 686     */
 687    TCL_FALLBACK( ctx, R200_TCL_FALLBACK_UNFILLED, flag);
 688    if (rmesa->TclFallback) {
 689       r200ChooseRenderState( ctx );
 690       r200ChooseVertexState( ctx );
 691    }
 692 }
 693
 694
 695 /* =============================================================
 696  * Rendering attributes
 697  *
 698  * We really don't want to recalculate all this every time we bind a
 699  * texture.  These things shouldn't change all that often, so it makes
 700  * sense to break them out of the core texture state update routines.
 701  */
 702
 703 /* Examine lighting and texture state to determine if separate specular
 704  * should be enabled.
 705  */
 706 static void r200UpdateSpecular( GLcontext *ctx )
 707 {
 708    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 709    CARD32 p = rmesa->hw.ctx.cmd[CTX_PP_CNTL];
 710
 711    R200_STATECHANGE( rmesa, tcl );
 712    R200_STATECHANGE( rmesa, vtx );
 713
 714    rmesa->hw.vtx.cmd[VTX_TCL_OUTPUT_VTXFMT_0] &= ~(3<<R200_VTX_COLOR_0_SHIFT);
 715    rmesa->hw.vtx.cmd[VTX_TCL_OUTPUT_VTXFMT_0] &= ~(3<<R200_VTX_COLOR_1_SHIFT);
 716    rmesa->hw.vtx.cmd[VTX_TCL_OUTPUT_COMPSEL] &= ~R200_OUTPUT_COLOR_0;
 717    rmesa->hw.vtx.cmd[VTX_TCL_OUTPUT_COMPSEL] &= ~R200_OUTPUT_COLOR_1;
 718    rmesa->hw.tcl.cmd[TCL_LIGHT_MODEL_CTL_0] &= ~R200_LIGHTING_ENABLE;
 719
 720    p &= ~R200_SPECULAR_ENABLE;
 721
 722    rmesa->hw.tcl.cmd[TCL_LIGHT_MODEL_CTL_0] |= R200_DIFFUSE_SPECULAR_COMBINE;
 723
 724
 725    if (ctx->Light.Enabled &&
 726        ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR) {
 727       rmesa->hw.vtx.cmd[VTX_TCL_OUTPUT_VTXFMT_0] |=
 728          ((R200_VTX_FP_RGBA << R200_VTX_COLOR_0_SHIFT) |
 729           (R200_VTX_FP_RGBA << R200_VTX_COLOR_1_SHIFT));
 730       rmesa->hw.vtx.cmd[VTX_TCL_OUTPUT_COMPSEL] |= R200_OUTPUT_COLOR_0;
 731       rmesa->hw.vtx.cmd[VTX_TCL_OUTPUT_COMPSEL] |= R200_OUTPUT_COLOR_1;
 732       rmesa->hw.tcl.cmd[TCL_LIGHT_MODEL_CTL_0] |= R200_LIGHTING_ENABLE;
 733       p |=  R200_SPECULAR_ENABLE;
 734       rmesa->hw.tcl.cmd[TCL_LIGHT_MODEL_CTL_0] &=
 735          ~R200_DIFFUSE_SPECULAR_COMBINE;
 736    }
 737    else if (ctx->Light.Enabled) {
 738       rmesa->hw.vtx.cmd[VTX_TCL_OUTPUT_VTXFMT_0] |=
 739          ((R200_VTX_FP_RGBA << R200_VTX_COLOR_0_SHIFT));
 740       rmesa->hw.vtx.cmd[VTX_TCL_OUTPUT_COMPSEL] |= R200_OUTPUT_COLOR_0;
 741       rmesa->hw.tcl.cmd[TCL_LIGHT_MODEL_CTL_0] |= R200_LIGHTING_ENABLE;
 742    } else if (ctx->Fog.ColorSumEnabled ) {
 743       rmesa->hw.vtx.cmd[VTX_TCL_OUTPUT_VTXFMT_0] |=
 744          ((R200_VTX_FP_RGBA << R200_VTX_COLOR_0_SHIFT) |
 745           (R200_VTX_FP_RGBA << R200_VTX_COLOR_1_SHIFT));
 746       p |=  R200_SPECULAR_ENABLE;
 747    } else {
 748       rmesa->hw.vtx.cmd[VTX_TCL_OUTPUT_VTXFMT_0] |=
 749          ((R200_VTX_FP_RGBA << R200_VTX_COLOR_0_SHIFT));
 750    }
 751
 752    if (ctx->Fog.Enabled) {
 753       rmesa->hw.vtx.cmd[VTX_TCL_OUTPUT_VTXFMT_0] |=
 754          ((R200_VTX_FP_RGBA << R200_VTX_COLOR_1_SHIFT));
 755       rmesa->hw.vtx.cmd[VTX_TCL_OUTPUT_COMPSEL] |= R200_OUTPUT_COLOR_1;
 756    }
 757
 758    if ( rmesa->hw.ctx.cmd[CTX_PP_CNTL] != p ) {
 759       R200_STATECHANGE( rmesa, ctx );
 760       rmesa->hw.ctx.cmd[CTX_PP_CNTL] = p;
 761    }
 762
 763    /* Update vertex/render formats
 764     */
 765    if (rmesa->TclFallback) {
 766       r200ChooseRenderState( ctx );
 767       r200ChooseVertexState( ctx );
 768    }
 769 }
 770
 771
 772 /* =============================================================
 773  * Materials
 774  */
 775
 776
 777 /* Update on colormaterial, material emmissive/ambient,
 778  * lightmodel.globalambient
 779  */
 780 static void update_global_ambient( GLcontext *ctx )
 781 {
 782    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 783    float *fcmd = (float *)R200_DB_STATE( glt );
 784
 785    /* Need to do more if both emmissive & ambient are PREMULT:
 786     */
 787    if ((rmesa->hw.tcl.cmd[TCL_LIGHT_MODEL_CTL_1] &
 788        ((3 << R200_FRONT_EMISSIVE_SOURCE_SHIFT) |
 789         (3 << R200_FRONT_AMBIENT_SOURCE_SHIFT))) == 0)
 790    {
 791       COPY_3V( &fcmd[GLT_RED],
 792                ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_EMISSION]);
 793       ACC_SCALE_3V( &fcmd[GLT_RED],
 794                    ctx->Light.Model.Ambient,
 795                    ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_AMBIENT]);
 796    }
 797    else
 798    {
 799       COPY_3V( &fcmd[GLT_RED], ctx->Light.Model.Ambient );
 800    }
 801
 802    R200_DB_STATECHANGE(rmesa, &rmesa->hw.glt);
 803 }
 804
 805 /* Update on change to
 806  *    - light[p].colors
 807  *    - light[p].enabled
 808  *    - material,
 809  *    - colormaterial enabled
 810  *    - colormaterial bitmask
 811  */
 812 static void update_light_colors( GLcontext *ctx, GLuint p )
 813 {
 814    struct gl_light *l = &ctx->Light.Light[p];
 815
 816 /*     fprintf(stderr, "%s\n", __FUNCTION__); */
 817
 818    if (l->Enabled) {
 819       r200ContextPtr rmesa = R200_CONTEXT(ctx);
 820       float *fcmd = (float *)R200_DB_STATE( lit[p] );
 821       GLuint bitmask = ctx->Light.ColorMaterialBitmask;
 822       GLfloat (*mat)[4] = ctx->Light.Material.Attrib;
 823
 824       COPY_4V( &fcmd[LIT_AMBIENT_RED], l->Ambient );
 825       COPY_4V( &fcmd[LIT_DIFFUSE_RED], l->Diffuse );
 826       COPY_4V( &fcmd[LIT_SPECULAR_RED], l->Specular );
 827
 828       if (!ctx->Light.ColorMaterialEnabled)
 829          bitmask = 0;
 830
 831       if ((bitmask & MAT_BIT_FRONT_AMBIENT) == 0)
 832          SELF_SCALE_3V( &fcmd[LIT_AMBIENT_RED], mat[MAT_ATTRIB_FRONT_AMBIENT] );
 833
 834       if ((bitmask & MAT_BIT_FRONT_DIFFUSE) == 0)
 835          SELF_SCALE_3V( &fcmd[LIT_DIFFUSE_RED], mat[MAT_ATTRIB_FRONT_DIFFUSE] );
 836
 837       if ((bitmask & MAT_BIT_FRONT_SPECULAR) == 0)
 838          SELF_SCALE_3V( &fcmd[LIT_SPECULAR_RED], mat[MAT_ATTRIB_FRONT_SPECULAR] );
 839
 840       R200_DB_STATECHANGE( rmesa, &rmesa->hw.lit[p] );
 841    }
 842 }
 843
 844 /* Also fallback for asym colormaterial mode in twoside lighting...
 845  */
 846 static void check_twoside_fallback( GLcontext *ctx )
 847 {
 848    GLboolean fallback = GL_FALSE;
 849    GLint i;
 850
 851    if (ctx->Light.Enabled && ctx->Light.Model.TwoSide) {
 852       if (ctx->Light.ColorMaterialEnabled &&
 853           (ctx->Light.ColorMaterialBitmask & BACK_MATERIAL_BITS) !=
 854           ((ctx->Light.ColorMaterialBitmask & FRONT_MATERIAL_BITS)<<1))
 855          fallback = GL_TRUE;
 856       else {
 857          for (i = MAT_ATTRIB_FRONT_AMBIENT; i < MAT_ATTRIB_FRONT_INDEXES; i+=2)
 858             if (memcmp( ctx->Light.Material.Attrib[i],
 859                         ctx->Light.Material.Attrib[i+1],
 860                         sizeof(GLfloat)*4) != 0) {
 861                fallback = GL_TRUE;
 862                break;
 863             }
 864       }
 865    }
 866
 867    TCL_FALLBACK( ctx, R200_TCL_FALLBACK_LIGHT_TWOSIDE, fallback );
 868 }
 869
 870 static void r200ColorMaterial( GLcontext *ctx, GLenum face, GLenum mode )
 871 {
 872    if (ctx->Light.ColorMaterialEnabled) {
 873       r200ContextPtr rmesa = R200_CONTEXT(ctx);
 874       GLuint light_model_ctl1 = rmesa->hw.tcl.cmd[TCL_LIGHT_MODEL_CTL_1];
 875       GLuint mask = ctx->Light.ColorMaterialBitmask;
 876
 877       /* Default to PREMULT:
 878        */
 879       light_model_ctl1 &= ~((0xf << R200_FRONT_EMISSIVE_SOURCE_SHIFT) |
 880                            (0xf << R200_FRONT_AMBIENT_SOURCE_SHIFT) |
 881                            (0xf << R200_FRONT_DIFFUSE_SOURCE_SHIFT) |
 882                            (0xf << R200_FRONT_SPECULAR_SOURCE_SHIFT));
 883
 884       if (mask & MAT_BIT_FRONT_EMISSION) {
 885          light_model_ctl1 |= (R200_LM1_SOURCE_VERTEX_COLOR_0 <<
 886                              R200_FRONT_EMISSIVE_SOURCE_SHIFT);
 887       }
 888
 889       if (mask & MAT_BIT_FRONT_AMBIENT) {
 890          light_model_ctl1 |= (R200_LM1_SOURCE_VERTEX_COLOR_0 <<
 891                              R200_FRONT_AMBIENT_SOURCE_SHIFT);
 892       }
 893
 894       if (mask & MAT_BIT_FRONT_DIFFUSE) {
 895          light_model_ctl1 |= (R200_LM1_SOURCE_VERTEX_COLOR_0 <<
 896                              R200_FRONT_DIFFUSE_SOURCE_SHIFT);
 897       }
 898
 899       if (mask & MAT_BIT_FRONT_SPECULAR) {
 900          light_model_ctl1 |= (R200_LM1_SOURCE_VERTEX_COLOR_0 <<
 901                              R200_FRONT_SPECULAR_SOURCE_SHIFT);
 902       }
 903
 904       if (light_model_ctl1 != rmesa->hw.tcl.cmd[TCL_LIGHT_MODEL_CTL_1]) {
 905          GLuint p;
 906
 907          R200_STATECHANGE( rmesa, tcl );
 908          rmesa->hw.tcl.cmd[TCL_LIGHT_MODEL_CTL_1] = light_model_ctl1;
 909
 910          for (p = 0 ; p < MAX_LIGHTS; p++)
 911             update_light_colors( ctx, p );
 912          update_global_ambient( ctx );
 913       }
 914    }
 915
 916    check_twoside_fallback( ctx );
 917 }
 918
 919 void r200UpdateMaterial( GLcontext *ctx )
 920 {
 921    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 922    GLfloat (*mat)[4] = ctx->Light.Material.Attrib;
 923    GLfloat *fcmd = (GLfloat *)R200_DB_STATE( mtl[0] );
 924    GLuint p;
 925    GLuint mask = ~0;
 926
 927    if (ctx->Light.ColorMaterialEnabled)
 928       mask &= ~ctx->Light.ColorMaterialBitmask;
 929
 930    if (R200_DEBUG & DEBUG_STATE)
 931       fprintf(stderr, "%s\n", __FUNCTION__);
 932
 933
 934    if (mask & MAT_BIT_FRONT_EMISSION) {
 935       fcmd[MTL_EMMISSIVE_RED]   = mat[MAT_ATTRIB_FRONT_EMISSION][0];
 936       fcmd[MTL_EMMISSIVE_GREEN] = mat[MAT_ATTRIB_FRONT_EMISSION][1];
 937       fcmd[MTL_EMMISSIVE_BLUE]  = mat[MAT_ATTRIB_FRONT_EMISSION][2];
 938       fcmd[MTL_EMMISSIVE_ALPHA] = mat[MAT_ATTRIB_FRONT_EMISSION][3];
 939    }
 940    if (mask & MAT_BIT_FRONT_AMBIENT) {
 941       fcmd[MTL_AMBIENT_RED]     = mat[MAT_ATTRIB_FRONT_AMBIENT][0];
 942       fcmd[MTL_AMBIENT_GREEN]   = mat[MAT_ATTRIB_FRONT_AMBIENT][1];
 943       fcmd[MTL_AMBIENT_BLUE]    = mat[MAT_ATTRIB_FRONT_AMBIENT][2];
 944       fcmd[MTL_AMBIENT_ALPHA]   = mat[MAT_ATTRIB_FRONT_AMBIENT][3];
 945    }
 946    if (mask & MAT_BIT_FRONT_DIFFUSE) {
 947       fcmd[MTL_DIFFUSE_RED]     = mat[MAT_ATTRIB_FRONT_DIFFUSE][0];
 948       fcmd[MTL_DIFFUSE_GREEN]   = mat[MAT_ATTRIB_FRONT_DIFFUSE][1];
 949       fcmd[MTL_DIFFUSE_BLUE]    = mat[MAT_ATTRIB_FRONT_DIFFUSE][2];
 950       fcmd[MTL_DIFFUSE_ALPHA]   = mat[MAT_ATTRIB_FRONT_DIFFUSE][3];
 951    }
 952    if (mask & MAT_BIT_FRONT_SPECULAR) {
 953       fcmd[MTL_SPECULAR_RED]    = mat[MAT_ATTRIB_FRONT_SPECULAR][0];
 954       fcmd[MTL_SPECULAR_GREEN]  = mat[MAT_ATTRIB_FRONT_SPECULAR][1];
 955       fcmd[MTL_SPECULAR_BLUE]   = mat[MAT_ATTRIB_FRONT_SPECULAR][2];
 956       fcmd[MTL_SPECULAR_ALPHA]  = mat[MAT_ATTRIB_FRONT_SPECULAR][3];
 957    }
 958    if (mask & MAT_BIT_FRONT_SHININESS) {
 959       fcmd[MTL_SHININESS]       = mat[MAT_ATTRIB_FRONT_SHININESS][0];
 960    }
 961
 962    if (R200_DB_STATECHANGE( rmesa, &rmesa->hw.mtl[0] )) {
 963       for (p = 0 ; p < MAX_LIGHTS; p++)
 964          update_light_colors( ctx, p );
 965
 966       check_twoside_fallback( ctx );
 967       update_global_ambient( ctx );
 968    }
 969    else if (R200_DEBUG & (DEBUG_PRIMS|DEBUG_STATE))
 970       fprintf(stderr, "%s: Elided noop material call\n", __FUNCTION__);
 971 }
 972
 973 /* _NEW_LIGHT
 974  * _NEW_MODELVIEW
 975  * _MESA_NEW_NEED_EYE_COORDS
 976  *
 977  * Uses derived state from mesa:
 978  *       _VP_inf_norm
 979  *       _h_inf_norm
 980  *       _Position
 981  *       _NormDirection
 982  *       _ModelViewInvScale
 983  *       _NeedEyeCoords
 984  *       _EyeZDir
 985  *
 986  * which are calculated in light.c and are correct for the current
 987  * lighting space (model or eye), hence dependencies on _NEW_MODELVIEW
 988  * and _MESA_NEW_NEED_EYE_COORDS.
 989  */
 990 static void update_light( GLcontext *ctx )
 991 {
 992    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 993
 994    /* Have to check these, or have an automatic shortcircuit mechanism
 995     * to remove noop statechanges. (Or just do a better job on the
 996     * front end).
 997     */
 998    {
 999       GLuint tmp = rmesa->hw.tcl.cmd[TCL_LIGHT_MODEL_CTL_0];
1000
1001       if (ctx->_NeedEyeCoords)
1002          tmp &= ~R200_LIGHT_IN_MODELSPACE;
1003       else
1004          tmp |= R200_LIGHT_IN_MODELSPACE;
1005
1006       if (tmp != rmesa->hw.tcl.cmd[TCL_LIGHT_MODEL_CTL_0])
1007       {
1008          R200_STATECHANGE( rmesa, tcl );
1009          rmesa->hw.tcl.cmd[TCL_LIGHT_MODEL_CTL_0] = tmp;
1010       }
1011    }
1012
1013    {
1014       GLfloat *fcmd = (GLfloat *)R200_DB_STATE( eye );
1015       fcmd[EYE_X] = ctx->_EyeZDir[0];
1016       fcmd[EYE_Y] = ctx->_EyeZDir[1];
1017       fcmd[EYE_Z] = - ctx->_EyeZDir[2];
1018       fcmd[EYE_RESCALE_FACTOR] = ctx->_ModelViewInvScale;
1019       R200_DB_STATECHANGE( rmesa, &rmesa->hw.eye );
1020    }
1021
1022
1023
1024    if (ctx->Light.Enabled) {
1025       GLint p;
1026       for (p = 0 ; p < MAX_LIGHTS; p++) {
1027          if (ctx->Light.Light[p].Enabled) {
1028             struct gl_light *l = &ctx->Light.Light[p];
1029             GLfloat *fcmd = (GLfloat *)R200_DB_STATE( lit[p] );
1030
1031             if (l->EyePosition[3] == 0.0) {
1032                COPY_3FV( &fcmd[LIT_POSITION_X], l->_VP_inf_norm );
1033                COPY_3FV( &fcmd[LIT_DIRECTION_X], l->_h_inf_norm );
1034                fcmd[LIT_POSITION_W] = 0;
1035                fcmd[LIT_DIRECTION_W] = 0;
1036             } else {
1037                COPY_4V( &fcmd[LIT_POSITION_X], l->_Position );
1038                fcmd[LIT_DIRECTION_X] = -l->_NormDirection[0];
1039                fcmd[LIT_DIRECTION_Y] = -l->_NormDirection[1];
1040                fcmd[LIT_DIRECTION_Z] = -l->_NormDirection[2];
1041                fcmd[LIT_DIRECTION_W] = 0;
1042             }
1043
1044             R200_DB_STATECHANGE( rmesa, &rmesa->hw.lit[p] );
1045          }
1046       }
1047    }
1048 }
1049
1050 static void r200Lightfv( GLcontext *ctx, GLenum light,
1051                            GLenum pname, const GLfloat *params )
1052 {
1053    r200ContextPtr rmesa = R200_CONTEXT(ctx);
1054    GLint p = light - GL_LIGHT0;
1055    struct gl_light *l = &ctx->Light.Light[p];
1056    GLfloat *fcmd = (GLfloat *)rmesa->hw.lit[p].cmd;
1057
1058
1059    switch (pname) {
1060    case GL_AMBIENT:
1061    case GL_DIFFUSE:
1062    case GL_SPECULAR:
1063       update_light_colors( ctx, p );
1064       break;
1065
1066    case GL_SPOT_DIRECTION:
1067       /* picked up in update_light */
1068       break;
1069
1070    case GL_POSITION: {
1071       /* positions picked up in update_light, but can do flag here */
1072       GLuint flag = (p&1)? R200_LIGHT_1_IS_LOCAL : R200_LIGHT_0_IS_LOCAL;
1073       GLuint idx = TCL_PER_LIGHT_CTL_0 + p/2;
1074
1075       R200_STATECHANGE(rmesa, tcl);
1076       if (l->EyePosition[3] != 0.0F)
1077          rmesa->hw.tcl.cmd[idx] |= flag;
1078       else
1079          rmesa->hw.tcl.cmd[idx] &= ~flag;
1080       break;
1081    }
1082
1083    case GL_SPOT_EXPONENT:
1084       R200_STATECHANGE(rmesa, lit[p]);
1085       fcmd[LIT_SPOT_EXPONENT] = params[0];
1086       break;
1087
1088    case GL_SPOT_CUTOFF: {
1089       GLuint flag = (p&1) ? R200_LIGHT_1_IS_SPOT : R200_LIGHT_0_IS_SPOT;
1090       GLuint idx = TCL_PER_LIGHT_CTL_0 + p/2;
1091
1092       R200_STATECHANGE(rmesa, lit[p]);
1093       fcmd[LIT_SPOT_CUTOFF] = l->_CosCutoff;
1094
1095       R200_STATECHANGE(rmesa, tcl);
1096       if (l->SpotCutoff != 180.0F)
1097          rmesa->hw.tcl.cmd[idx] |= flag;
1098       else
1099          rmesa->hw.tcl.cmd[idx] &= ~flag;
1100
1101       break;
1102    }
1103
1104    case GL_CONSTANT_ATTENUATION:
1105       R200_STATECHANGE(rmesa, lit[p]);
1106       fcmd[LIT_ATTEN_CONST] = params[0];
1107       break;
1108    case GL_LINEAR_ATTENUATION:
1109       R200_STATECHANGE(rmesa, lit[p]);
1110       fcmd[LIT_ATTEN_LINEAR] = params[0];
1111       break;
1112    case GL_QUADRATIC_ATTENUATION:
1113       R200_STATECHANGE(rmesa, lit[p]);
1114       fcmd[LIT_ATTEN_QUADRATIC] = params[0];
1115       break;
1116    default:
1117       return;
1118    }
1119
1120 }
1121
1122
1123
1124
1125 static void r200LightModelfv( GLcontext *ctx, GLenum pname,
1126                                 const GLfloat *param )
1127 {
1128    r200ContextPtr rmesa = R200_CONTEXT(ctx);
1129
1130    switch (pname) {
1131       case GL_LIGHT_MODEL_AMBIENT:
1132          update_global_ambient( ctx );
1133          break;
1134
1135       case GL_LIGHT_MODEL_LOCAL_VIEWER:
1136          R200_STATECHANGE( rmesa, tcl );
1137          if (ctx->Light.Model.LocalViewer)
1138             rmesa->hw.tcl.cmd[TCL_LIGHT_MODEL_CTL_0] |= R200_LOCAL_VIEWER;
1139          else
1140             rmesa->hw.tcl.cmd[TCL_LIGHT_MODEL_CTL_0] &= ~R200_LOCAL_VIEWER;
1141          break;
1142
1143       case GL_LIGHT_MODEL_TWO_SIDE:
1144          R200_STATECHANGE( rmesa, tcl );
1145          if (ctx->Light.Model.TwoSide)
1146             rmesa->hw.tcl.cmd[TCL_LIGHT_MODEL_CTL_0] |= R200_LIGHT_TWOSIDE;
1147          else
1148             rmesa->hw.tcl.cmd[TCL_LIGHT_MODEL_CTL_0] &= ~R200_LIGHT_TWOSIDE;
1149
1150          check_twoside_fallback( ctx );
1151
1152          if (rmesa->TclFallback) {
1153             r200ChooseRenderState( ctx );
1154             r200ChooseVertexState( ctx );
1155          }
1156          break;
1157
1158       case GL_LIGHT_MODEL_COLOR_CONTROL:
1159          r200UpdateSpecular(ctx);
1160          break;
1161
1162       default:
1163          break;
1164    }
1165 }
1166
1167 static void r200ShadeModel( GLcontext *ctx, GLenum mode )
1168 {
1169    r200ContextPtr rmesa = R200_CONTEXT(ctx);
1170    GLuint s = rmesa->hw.set.cmd[SET_SE_CNTL];
1171
1172    s &= ~(R200_DIFFUSE_SHADE_MASK |
1173           R200_ALPHA_SHADE_MASK |
1174           R200_SPECULAR_SHADE_MASK |
1175           R200_FOG_SHADE_MASK);
1176
1177    switch ( mode ) {
1178    case GL_FLAT:
1179       s |= (R200_DIFFUSE_SHADE_FLAT |
1180             R200_ALPHA_SHADE_FLAT |
1181             R200_SPECULAR_SHADE_FLAT |
1182             R200_FOG_SHADE_FLAT);
1183       break;
1184    case GL_SMOOTH:
1185       s |= (R200_DIFFUSE_SHADE_GOURAUD |
1186             R200_ALPHA_SHADE_GOURAUD |
1187             R200_SPECULAR_SHADE_GOURAUD |
1188             R200_FOG_SHADE_GOURAUD);
1189       break;
1190    default:
1191       return;
1192    }
1193
1194    if ( rmesa->hw.set.cmd[SET_SE_CNTL] != s ) {
1195       R200_STATECHANGE( rmesa, set );
1196       rmesa->hw.set.cmd[SET_SE_CNTL] = s;
1197    }
1198 }
1199
1200
1201 /* =============================================================
1202  * User clip planes
1203  */
1204
1205 static void r200ClipPlane( GLcontext *ctx, GLenum plane, const GLfloat *eq )
1206 {
1207    GLint p = (GLint) plane - (GLint) GL_CLIP_PLANE0;
1208    r200ContextPtr rmesa = R200_CONTEXT(ctx);
1209    GLint *ip = (GLint *)ctx->Transform._ClipUserPlane[p];
1210
1211    R200_STATECHANGE( rmesa, ucp[p] );
1212    rmesa->hw.ucp[p].cmd[UCP_X] = ip[0];
1213    rmesa->hw.ucp[p].cmd[UCP_Y] = ip[1];
1214    rmesa->hw.ucp[p].cmd[UCP_Z] = ip[2];
1215    rmesa->hw.ucp[p].cmd[UCP_W] = ip[3];
1216 }
1217
1218 static void r200UpdateClipPlanes( GLcontext *ctx )
1219 {
1220    r200ContextPtr rmesa = R200_CONTEXT(ctx);
1221    GLuint p;
1222
1223    for (p = 0; p < ctx->Const.MaxClipPlanes; p++) {
1224       if (ctx->Transform.ClipPlanesEnabled & (1 << p)) {
1225          GLint *ip = (GLint *)ctx->Transform._ClipUserPlane[p];
1226
1227          R200_STATECHANGE( rmesa, ucp[p] );
1228          rmesa->hw.ucp[p].cmd[UCP_X] = ip[0];
1229          rmesa->hw.ucp[p].cmd[UCP_Y] = ip[1];
1230          rmesa->hw.ucp[p].cmd[UCP_Z] = ip[2];
1231          rmesa->hw.ucp[p].cmd[UCP_W] = ip[3];
1232       }
1233    }
1234 }
1235
1236
1237 /* =============================================================
1238  * Stencil
1239  */
1240
1241 static void r200StencilFunc( GLcontext *ctx, GLenum func,
1242                                GLint ref, GLuint mask )
1243 {
1244    r200ContextPtr rmesa = R200_CONTEXT(ctx);
1245    GLuint refmask = ((ctx->Stencil.Ref[0] << R200_STENCIL_REF_SHIFT) |
1246                      (ctx->Stencil.ValueMask[0] << R200_STENCIL_MASK_SHIFT));
1247
1248    R200_STATECHANGE( rmesa, ctx );
1249    R200_STATECHANGE( rmesa, msk );
1250
1251    rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] &= ~R200_STENCIL_TEST_MASK;
1252    rmesa->hw.msk.cmd[MSK_RB3D_STENCILREFMASK] &= ~(R200_STENCIL_REF_MASK|
1253                                                    R200_STENCIL_VALUE_MASK);
1254
1255    switch ( ctx->Stencil.Function[0] ) {
1256    case GL_NEVER:
1257       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_STENCIL_TEST_NEVER;
1258       break;
1259    case GL_LESS:
1260       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_STENCIL_TEST_LESS;
1261       break;
1262    case GL_EQUAL:
1263       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_STENCIL_TEST_EQUAL;
1264       break;
1265    case GL_LEQUAL:
1266       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_STENCIL_TEST_LEQUAL;
1267       break;
1268    case GL_GREATER:
1269       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_STENCIL_TEST_GREATER;
1270       break;
1271    case GL_NOTEQUAL:
1272       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_STENCIL_TEST_NEQUAL;
1273       break;
1274    case GL_GEQUAL:
1275       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_STENCIL_TEST_GEQUAL;
1276       break;
1277    case GL_ALWAYS:
1278       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_STENCIL_TEST_ALWAYS;
1279       break;
1280    }
1281
1282    rmesa->hw.msk.cmd[MSK_RB3D_STENCILREFMASK] |= refmask;
1283 }
1284
1285 static void r200StencilMask( GLcontext *ctx, GLuint mask )
1286 {
1287    r200ContextPtr rmesa = R200_CONTEXT(ctx);
1288
1289    R200_STATECHANGE( rmesa, msk );
1290    rmesa->hw.msk.cmd[MSK_RB3D_STENCILREFMASK] &= ~R200_STENCIL_WRITE_MASK;
1291    rmesa->hw.msk.cmd[MSK_RB3D_STENCILREFMASK] |=
1292       (ctx->Stencil.WriteMask[0] << R200_STENCIL_WRITEMASK_SHIFT);
1293 }
1294
1295 static void r200StencilOp( GLcontext *ctx, GLenum fail,
1296                              GLenum zfail, GLenum zpass )
1297 {
1298    r200ContextPtr rmesa = R200_CONTEXT(ctx);
1299
1300    R200_STATECHANGE( rmesa, ctx );
1301    rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] &= ~(R200_STENCIL_FAIL_MASK |
1302                                                R200_STENCIL_ZFAIL_MASK |
1303                                                R200_STENCIL_ZPASS_MASK);
1304
1305    switch ( ctx->Stencil.FailFunc[0] ) {
1306    case GL_KEEP:
1307       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_STENCIL_FAIL_KEEP;
1308       break;
1309    case GL_ZERO:
1310       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_STENCIL_FAIL_ZERO;
1311       break;
1312    case GL_REPLACE:
1313       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_STENCIL_FAIL_REPLACE;
1314       break;
1315    case GL_INCR:
1316       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_STENCIL_FAIL_INC;
1317       break;
1318    case GL_DECR:
1319       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_STENCIL_FAIL_DEC;
1320       break;
1321    case GL_INCR_WRAP_EXT:
1322       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_STENCIL_FAIL_INC_WRAP;
1323       break;
1324    case GL_DECR_WRAP_EXT:
1325       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_STENCIL_FAIL_DEC_WRAP;
1326       break;
1327    case GL_INVERT:
1328       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_STENCIL_FAIL_INVERT;
1329       break;
1330    }
1331
1332    switch ( ctx->Stencil.ZFailFunc[0] ) {
1333    case GL_KEEP:
1334       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_STENCIL_ZFAIL_KEEP;
1335       break;
1336    case GL_ZERO:
1337       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_STENCIL_ZFAIL_ZERO;
1338       break;
1339    case GL_REPLACE:
1340       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_STENCIL_ZFAIL_REPLACE;
1341       break;
1342    case GL_INCR:
1343       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_STENCIL_ZFAIL_INC;
1344       break;
1345    case GL_DECR:
1346       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_STENCIL_ZFAIL_DEC;
1347       break;
1348    case GL_INCR_WRAP_EXT:
1349       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_STENCIL_ZFAIL_INC_WRAP;
1350       break;
1351    case GL_DECR_WRAP_EXT:
1352       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_STENCIL_ZFAIL_DEC_WRAP;
1353       break;
1354    case GL_INVERT:
1355       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_STENCIL_ZFAIL_INVERT;
1356       break;
1357    }
1358
1359    switch ( ctx->Stencil.ZPassFunc[0] ) {
1360    case GL_KEEP:
1361       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_STENCIL_ZPASS_KEEP;
1362       break;
1363    case GL_ZERO:
1364       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_STENCIL_ZPASS_ZERO;
1365       break;
1366    case GL_REPLACE:
1367       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_STENCIL_ZPASS_REPLACE;
1368       break;
1369    case GL_INCR:
1370       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_STENCIL_ZPASS_INC;
1371       break;
1372    case GL_DECR:
1373       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_STENCIL_ZPASS_DEC;
1374       break;
1375    case GL_INCR_WRAP_EXT:
1376       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_STENCIL_ZPASS_INC_WRAP;
1377       break;
1378    case GL_DECR_WRAP_EXT:
1379       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_STENCIL_ZPASS_DEC_WRAP;
1380       break;
1381    case GL_INVERT:
1382       rmesa->hw.ctx.cmd[CTX_RB3D_ZSTENCILCNTL] |= R200_STENCIL_ZPASS_INVERT;
1383       break;
1384    }
1385 }
1386
1387 static void r200ClearStencil( GLcontext *ctx, GLint s )
1388 {
1389    r200ContextPtr rmesa = R200_CONTEXT(ctx);
1390
1391    rmesa->state.stencil.clear =
1392       ((GLuint) ctx->Stencil.Clear |
1393        (0xff << R200_STENCIL_MASK_SHIFT) |
1394        (ctx->Stencil.WriteMask[0] << R200_STENCIL_WRITEMASK_SHIFT));
1395 }
1396
1397
1398 /* =============================================================
1399  * Window position and viewport transformation
1400  */
1401
1402 /*
1403  * To correctly position primitives:
1404  */
1405 #define SUBPIXEL_X 0.125
1406 #define SUBPIXEL_Y 0.125
1407
1408 void r200UpdateWindow( GLcontext *ctx )
1409 {
1410    r200ContextPtr rmesa = R200_CONTEXT(ctx);
1411    __DRIdrawablePrivate *dPriv = rmesa->dri.drawable;
1412    GLfloat xoffset = (GLfloat)dPriv->x;
1413    GLfloat yoffset = (GLfloat)dPriv->y + dPriv->h;
1414    const GLfloat *v = ctx->Viewport._WindowMap.m;
1415
1416    GLfloat sx = v[MAT_SX];
1417    GLfloat tx = v[MAT_TX] + xoffset + SUBPIXEL_X;
1418    GLfloat sy = - v[MAT_SY];
1419    GLfloat ty = (- v[MAT_TY]) + yoffset + SUBPIXEL_Y;
1420    GLfloat sz = v[MAT_SZ] * rmesa->state.depth.scale;
1421    GLfloat tz = v[MAT_TZ] * rmesa->state.depth.scale;
1422
1423    R200_FIREVERTICES( rmesa );
1424    R200_STATECHANGE( rmesa, vpt );
1425
1426    rmesa->hw.vpt.cmd[VPT_SE_VPORT_XSCALE]  = *(GLuint *)&sx;
1427    rmesa->hw.vpt.cmd[VPT_SE_VPORT_XOFFSET] = *(GLuint *)&tx;
1428    rmesa->hw.vpt.cmd[VPT_SE_VPORT_YSCALE]  = *(GLuint *)&sy;
1429    rmesa->hw.vpt.cmd[VPT_SE_VPORT_YOFFSET] = *(GLuint *)&ty;
1430    rmesa->hw.vpt.cmd[VPT_SE_VPORT_ZSCALE]  = *(GLuint *)&sz;
1431    rmesa->hw.vpt.cmd[VPT_SE_VPORT_ZOFFSET] = *(GLuint *)&tz;
1432 }
1433
1434
1435
1436 static void r200Viewport( GLcontext *ctx, GLint x, GLint y,
1437                             GLsizei width, GLsizei height )
1438 {
1439    /* Don't pipeline viewport changes, conflict with window offset
1440     * setting below.  Could apply deltas to rescue pipelined viewport
1441     * values, or keep the originals hanging around.
1442     */
1443    R200_FIREVERTICES( R200_CONTEXT(ctx) );
1444    r200UpdateWindow( ctx );
1445 }
1446
1447 static void r200DepthRange( GLcontext *ctx, GLclampd nearval,
1448                               GLclampd farval )
1449 {
1450    r200UpdateWindow( ctx );
1451 }
1452
1453 void r200UpdateViewportOffset( GLcontext *ctx )
1454 {
1455    r200ContextPtr rmesa = R200_CONTEXT(ctx);
1456    __DRIdrawablePrivate *dPriv = rmesa->dri.drawable;
1457    GLfloat xoffset = (GLfloat)dPriv->x;
1458    GLfloat yoffset = (GLfloat)dPriv->y + dPriv->h;
1459    const GLfloat *v = ctx->Viewport._WindowMap.m;
1460
1461    GLfloat tx = v[MAT_TX] + xoffset;
1462    GLfloat ty = (- v[MAT_TY]) + yoffset;
1463
1464    if ( rmesa->hw.vpt.cmd[VPT_SE_VPORT_XOFFSET] != *(GLuint *)&tx ||
1465         rmesa->hw.vpt.cmd[VPT_SE_VPORT_YOFFSET] != *(GLuint *)&ty )
1466    {
1467       /* Note: this should also modify whatever data the context reset
1468        * code uses...
1469        */
1470       rmesa->hw.vpt.cmd[VPT_SE_VPORT_XOFFSET] = *(GLuint *)&tx;
1471       rmesa->hw.vpt.cmd[VPT_SE_VPORT_YOFFSET] = *(GLuint *)&ty;
1472
1473       /* update polygon stipple x/y screen offset */
1474       {
1475          GLuint stx, sty;
1476          GLuint m = rmesa->hw.msc.cmd[MSC_RE_MISC];
1477
1478          m &= ~(R200_STIPPLE_X_OFFSET_MASK |
1479                 R200_STIPPLE_Y_OFFSET_MASK);
1480
1481          /* add magic offsets, then invert */
1482          stx = 31 - ((rmesa->dri.drawable->x - 1) & R200_STIPPLE_COORD_MASK);
1483          sty = 31 - ((rmesa->dri.drawable->y + rmesa->dri.drawable->h - 1)
1484                      & R200_STIPPLE_COORD_MASK);
1485
1486          m |= ((stx << R200_STIPPLE_X_OFFSET_SHIFT) |
1487                (sty << R200_STIPPLE_Y_OFFSET_SHIFT));
1488
1489          if ( rmesa->hw.msc.cmd[MSC_RE_MISC] != m ) {
1490             R200_STATECHANGE( rmesa, msc );
1491             rmesa->hw.msc.cmd[MSC_RE_MISC] = m;
1492          }
1493       }
1494    }
1495
1496    r200UpdateScissor( ctx );
1497 }
1498
1499
1500
1501 /* =============================================================
1502  * Miscellaneous
1503  */
1504
1505 static void r200ClearColor( GLcontext *ctx, const GLfloat c[4] )
1506 {
1507    r200ContextPtr rmesa = R200_CONTEXT(ctx);
1508    GLubyte color[4];
1509    CLAMPED_FLOAT_TO_UBYTE(color[0], c[0]);
1510    CLAMPED_FLOAT_TO_UBYTE(color[1], c[1]);
1511    CLAMPED_FLOAT_TO_UBYTE(color[2], c[2]);
1512    CLAMPED_FLOAT_TO_UBYTE(color[3], c[3]);
1513    rmesa->state.color.clear = r200PackColor( rmesa->r200Screen->cpp,
1514                                              color[0], color[1],
1515                                              color[2], color[3] );
1516 }
1517
1518
1519 static void r200RenderMode( GLcontext *ctx, GLenum mode )
1520 {
1521    r200ContextPtr rmesa = R200_CONTEXT(ctx);
1522    FALLBACK( rmesa, R200_FALLBACK_RENDER_MODE, (mode != GL_RENDER) );
1523 }
1524
1525
1526 static GLuint r200_rop_tab[] = {
1527    R200_ROP_CLEAR,
1528    R200_ROP_AND,
1529    R200_ROP_AND_REVERSE,
1530    R200_ROP_COPY,
1531    R200_ROP_AND_INVERTED,
1532    R200_ROP_NOOP,
1533    R200_ROP_XOR,
1534    R200_ROP_OR,
1535    R200_ROP_NOR,
1536    R200_ROP_EQUIV,
1537    R200_ROP_INVERT,
1538    R200_ROP_OR_REVERSE,
1539    R200_ROP_COPY_INVERTED,
1540    R200_ROP_OR_INVERTED,
1541    R200_ROP_NAND,
1542    R200_ROP_SET,
1543 };
1544
1545 static void r200LogicOpCode( GLcontext *ctx, GLenum opcode )
1546 {
1547    r200ContextPtr rmesa = R200_CONTEXT(ctx);
1548    GLuint rop = (GLuint)opcode - GL_CLEAR;
1549
1550    ASSERT( rop < 16 );
1551
1552    R200_STATECHANGE( rmesa, msk );
1553    rmesa->hw.msk.cmd[MSK_RB3D_ROPCNTL] = r200_rop_tab[rop];
1554 }
1555
1556
1557 void r200SetCliprects( r200ContextPtr rmesa, GLenum mode )
1558 {
1559    __DRIdrawablePrivate *dPriv = rmesa->dri.drawable;
1560
1561    switch ( mode ) {
1562    case GL_FRONT_LEFT:
1563       rmesa->numClipRects = dPriv->numClipRects;
1564       rmesa->pClipRects = (XF86DRIClipRectPtr)dPriv->pClipRects;
1565       break;
1566    case GL_BACK_LEFT:
1567       /* Can't ignore 2d windows if we are page flipping.
1568        */
1569       if ( dPriv->numBackClipRects == 0 || rmesa->doPageFlip ) {
1570          rmesa->numClipRects = dPriv->numClipRects;
1571          rmesa->pClipRects = (XF86DRIClipRectPtr)dPriv->pClipRects;
1572       }
1573       else {
1574          rmesa->numClipRects = dPriv->numBackClipRects;
1575          rmesa->pClipRects = (XF86DRIClipRectPtr)dPriv->pBackClipRects;
1576       }
1577       break;
1578    default:
1579       fprintf(stderr, "bad mode in r200SetCliprects\n");
1580       return;
1581    }
1582
1583    if (rmesa->state.scissor.enabled)
1584       r200RecalcScissorRects( rmesa );
1585 }
1586
1587
1588 static void r200DrawBuffer( GLcontext *ctx, GLenum mode )
1589 {
1590    r200ContextPtr rmesa = R200_CONTEXT(ctx);
1591
1592    if (R200_DEBUG & DEBUG_DRI)
1593       fprintf(stderr, "%s %s\n", __FUNCTION__,
1594               _mesa_lookup_enum_by_nr( mode ));
1595
1596    R200_FIREVERTICES(rmesa);    /* don't pipeline cliprect changes */
1597
1598    /*
1599     * _DrawDestMask is easier to cope with than <mode>.
1600     */
1601    switch ( ctx->Color._DrawDestMask ) {
1602    case FRONT_LEFT_BIT:
1603       FALLBACK( rmesa, R200_FALLBACK_DRAW_BUFFER, GL_FALSE );
1604       r200SetCliprects( rmesa, GL_FRONT_LEFT );
1605       break;
1606    case BACK_LEFT_BIT:
1607       FALLBACK( rmesa, R200_FALLBACK_DRAW_BUFFER, GL_FALSE );
1608       r200SetCliprects( rmesa, GL_BACK_LEFT );
1609       break;
1610    default:
1611       /* GL_NONE or GL_FRONT_AND_BACK or stereo left&right, etc */
1612       FALLBACK( rmesa, R200_FALLBACK_DRAW_BUFFER, GL_TRUE );
1613       return;
1614    }
1615
1616    /* We want to update the s/w rast state too so that r200SetBuffer()
1617     * gets called.
1618     */
1619    _swrast_DrawBuffer(ctx, mode);
1620
1621    R200_STATECHANGE( rmesa, ctx );
1622    rmesa->hw.ctx.cmd[CTX_RB3D_COLOROFFSET] = ((rmesa->state.color.drawOffset +
1623                                                rmesa->r200Screen->fbLocation)
1624                                               & R200_COLOROFFSET_MASK);
1625    rmesa->hw.ctx.cmd[CTX_RB3D_COLORPITCH] = rmesa->state.color.drawPitch;
1626 }
1627
1628
1629 static void r200ReadBuffer( GLcontext *ctx, GLenum mode )
1630 {
1631    /* nothing, until we implement h/w glRead/CopyPixels or CopyTexImage */
1632 }
1633
1634 /* =============================================================
1635  * State enable/disable
1636  */
1637
1638 static void r200Enable( GLcontext *ctx, GLenum cap, GLboolean state )
1639 {
1640    r200ContextPtr rmesa = R200_CONTEXT(ctx);
1641    GLuint p, flag;
1642
1643    if ( R200_DEBUG & DEBUG_STATE )
1644       fprintf( stderr, "%s( %s = %s )\n", __FUNCTION__,
1645                _mesa_lookup_enum_by_nr( cap ),
1646                state ? "GL_TRUE" : "GL_FALSE" );
1647
1648    switch ( cap ) {
1649       /* Fast track this one...
1650        */
1651    case GL_TEXTURE_1D:
1652    case GL_TEXTURE_2D:
1653    case GL_TEXTURE_3D:
1654       break;
1655
1656    case GL_ALPHA_TEST:
1657       R200_STATECHANGE( rmesa, ctx );
1658       if (state) {
1659          rmesa->hw.ctx.cmd[CTX_PP_CNTL] |= R200_ALPHA_TEST_ENABLE;
1660       } else {
1661          rmesa->hw.ctx.cmd[CTX_PP_CNTL] &= ~R200_ALPHA_TEST_ENABLE;
1662       }
1663       break;
1664
1665    case GL_BLEND:
1666       R200_STATECHANGE( rmesa, ctx );
1667       if (state) {
1668          rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] |=  R200_ALPHA_BLEND_ENABLE;
1669       } else {
1670          rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] &= ~R200_ALPHA_BLEND_ENABLE;
1671       }
1672       if ( ctx->Color.ColorLogicOpEnabled ) {
1673          rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] |=  R200_ROP_ENABLE;
1674       } else {
1675          rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] &= ~R200_ROP_ENABLE;
1676       }
1677       break;
1678
1679    case GL_CLIP_PLANE0:
1680    case GL_CLIP_PLANE1:
1681    case GL_CLIP_PLANE2:
1682    case GL_CLIP_PLANE3:
1683    case GL_CLIP_PLANE4:
1684    case GL_CLIP_PLANE5:
1685       p = cap-GL_CLIP_PLANE0;
1686       R200_STATECHANGE( rmesa, tcl );
1687       if (state) {
1688          rmesa->hw.tcl.cmd[TCL_UCP_VERT_BLEND_CTL] |= (R200_UCP_ENABLE_0<<p);
1689          r200ClipPlane( ctx, cap, NULL );
1690       }
1691       else {
1692          rmesa->hw.tcl.cmd[TCL_UCP_VERT_BLEND_CTL] &= ~(R200_UCP_ENABLE_0<<p);
1693       }
1694       break;
1695
1696    case GL_COLOR_MATERIAL:
1697       r200ColorMaterial( ctx, 0, 0 );
1698       if (!state)
1699          r200UpdateMaterial( ctx );
1700       break;
1701
1702    case GL_CULL_FACE:
1703       r200CullFace( ctx, 0 );
1704       break;
1705
1706    case GL_DEPTH_TEST:
1707       R200_STATECHANGE(rmesa, ctx );
1708       if ( state ) {
1709          rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] |=  R200_Z_ENABLE;
1710       } else {
1711          rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] &= ~R200_Z_ENABLE;
1712       }
1713       break;
1714
1715    case GL_DITHER:
1716       R200_STATECHANGE(rmesa, ctx );
1717       if ( state ) {
1718          rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] |=  R200_DITHER_ENABLE;
1719          rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] &= ~rmesa->state.color.roundEnable;
1720       } else {
1721          rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] &= ~R200_DITHER_ENABLE;
1722          rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] |=  rmesa->state.color.roundEnable;
1723       }
1724       break;
1725
1726    case GL_FOG:
1727       R200_STATECHANGE(rmesa, ctx );
1728       if ( state ) {
1729          rmesa->hw.ctx.cmd[CTX_PP_CNTL] |= R200_FOG_ENABLE;
1730          r200Fogfv( ctx, GL_FOG_MODE, 0 );
1731       } else {
1732          rmesa->hw.ctx.cmd[CTX_PP_CNTL] &= ~R200_FOG_ENABLE;
1733          R200_STATECHANGE(rmesa, tcl);
1734          rmesa->hw.tcl.cmd[TCL_UCP_VERT_BLEND_CTL] &= ~R200_TCL_FOG_MASK;
1735       }
1736       r200UpdateSpecular( ctx ); /* for PK_SPEC */
1737       if (rmesa->TclFallback)
1738          r200ChooseVertexState( ctx );
1739       _mesa_allow_light_in_model( ctx, !state );
1740       break;
1741
1742    case GL_LIGHT0:
1743    case GL_LIGHT1:
1744    case GL_LIGHT2:
1745    case GL_LIGHT3:
1746    case GL_LIGHT4:
1747    case GL_LIGHT5:
1748    case GL_LIGHT6:
1749    case GL_LIGHT7:
1750       R200_STATECHANGE(rmesa, tcl);
1751       p = cap - GL_LIGHT0;
1752       if (p&1)
1753          flag = (R200_LIGHT_1_ENABLE |
1754                  R200_LIGHT_1_ENABLE_AMBIENT |
1755                  R200_LIGHT_1_ENABLE_SPECULAR);
1756       else
1757          flag = (R200_LIGHT_0_ENABLE |
1758                  R200_LIGHT_0_ENABLE_AMBIENT |
1759                  R200_LIGHT_0_ENABLE_SPECULAR);
1760
1761       if (state)
1762          rmesa->hw.tcl.cmd[p/2 + TCL_PER_LIGHT_CTL_0] |= flag;
1763       else
1764          rmesa->hw.tcl.cmd[p/2 + TCL_PER_LIGHT_CTL_0] &= ~flag;
1765
1766       /*
1767        */
1768       update_light_colors( ctx, p );
1769       break;
1770
1771    case GL_LIGHTING:
1772       r200UpdateSpecular(ctx);
1773       check_twoside_fallback( ctx );
1774       break;
1775
1776    case GL_LINE_SMOOTH:
1777       R200_STATECHANGE( rmesa, ctx );
1778       if ( state ) {
1779          rmesa->hw.ctx.cmd[CTX_PP_CNTL] |=  R200_ANTI_ALIAS_LINE;
1780       } else {
1781          rmesa->hw.ctx.cmd[CTX_PP_CNTL] &= ~R200_ANTI_ALIAS_LINE;
1782       }
1783       break;
1784
1785    case GL_LINE_STIPPLE:
1786       R200_STATECHANGE( rmesa, set );
1787       if ( state ) {
1788          rmesa->hw.set.cmd[SET_RE_CNTL] |=  R200_PATTERN_ENABLE;
1789       } else {
1790          rmesa->hw.set.cmd[SET_RE_CNTL] &= ~R200_PATTERN_ENABLE;
1791       }
1792       break;
1793
1794    case GL_COLOR_LOGIC_OP:
1795       R200_STATECHANGE( rmesa, ctx );
1796       if ( state ) {
1797          rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] |=  R200_ROP_ENABLE;
1798       } else {
1799          rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] &= ~R200_ROP_ENABLE;
1800       }
1801       break;
1802
1803    case GL_NORMALIZE:
1804       R200_STATECHANGE( rmesa, tcl );
1805       if ( state ) {
1806          rmesa->hw.tcl.cmd[TCL_LIGHT_MODEL_CTL_0] |=  R200_NORMALIZE_NORMALS;
1807       } else {
1808          rmesa->hw.tcl.cmd[TCL_LIGHT_MODEL_CTL_0] &= ~R200_NORMALIZE_NORMALS;
1809       }
1810       break;
1811
1812       /* Pointsize registers on r200 don't seem to do anything.  Maybe
1813        * have to pass pointsizes as vertex parameters?  In any case,
1814        * setting pointmin == pointsizemax == 1.0, and doing nothing
1815        * for aa is enough to satisfy conform.
1816        */
1817    case GL_POINT_SMOOTH:
1818       break;
1819
1820       /* These don't really do anything, as we don't use the 3vtx
1821        * primitives yet.
1822        */
1823 #if 0
1824    case GL_POLYGON_OFFSET_POINT:
1825       R200_STATECHANGE( rmesa, set );
1826       if ( state ) {
1827          rmesa->hw.set.cmd[SET_SE_CNTL] |=  R200_ZBIAS_ENABLE_POINT;
1828       } else {
1829          rmesa->hw.set.cmd[SET_SE_CNTL] &= ~R200_ZBIAS_ENABLE_POINT;
1830       }
1831       break;
1832
1833    case GL_POLYGON_OFFSET_LINE:
1834       R200_STATECHANGE( rmesa, set );
1835       if ( state ) {
1836          rmesa->hw.set.cmd[SET_SE_CNTL] |=  R200_ZBIAS_ENABLE_LINE;
1837       } else {
1838          rmesa->hw.set.cmd[SET_SE_CNTL] &= ~R200_ZBIAS_ENABLE_LINE;
1839       }
1840       break;
1841 #endif
1842
1843    case GL_POLYGON_OFFSET_FILL:
1844       R200_STATECHANGE( rmesa, set );
1845       if ( state ) {
1846          rmesa->hw.set.cmd[SET_SE_CNTL] |=  R200_ZBIAS_ENABLE_TRI;
1847       } else {
1848          rmesa->hw.set.cmd[SET_SE_CNTL] &= ~R200_ZBIAS_ENABLE_TRI;
1849       }
1850       break;
1851
1852    case GL_POLYGON_SMOOTH:
1853       R200_STATECHANGE( rmesa, ctx );
1854       if ( state ) {
1855          rmesa->hw.ctx.cmd[CTX_PP_CNTL] |=  R200_ANTI_ALIAS_POLY;
1856       } else {
1857          rmesa->hw.ctx.cmd[CTX_PP_CNTL] &= ~R200_ANTI_ALIAS_POLY;
1858       }
1859       break;
1860
1861    case GL_POLYGON_STIPPLE:
1862       R200_STATECHANGE(rmesa, set );
1863       if ( state ) {
1864          rmesa->hw.set.cmd[SET_RE_CNTL] |=  R200_STIPPLE_ENABLE;
1865       } else {
1866          rmesa->hw.set.cmd[SET_RE_CNTL] &= ~R200_STIPPLE_ENABLE;
1867       }
1868       break;
1869
1870    case GL_RESCALE_NORMAL_EXT: {
1871       GLboolean tmp = ctx->_NeedEyeCoords ? state : !state;
1872       R200_STATECHANGE( rmesa, tcl );
1873       if ( tmp ) {
1874          rmesa->hw.tcl.cmd[TCL_LIGHT_MODEL_CTL_0] |=  R200_RESCALE_NORMALS;
1875       } else {
1876          rmesa->hw.tcl.cmd[TCL_LIGHT_MODEL_CTL_0] &= ~R200_RESCALE_NORMALS;
1877       }
1878       break;
1879    }
1880
1881    case GL_SCISSOR_TEST:
1882       R200_FIREVERTICES( rmesa );
1883       rmesa->state.scissor.enabled = state;
1884       r200UpdateScissor( ctx );
1885       break;
1886
1887    case GL_STENCIL_TEST:
1888       if ( rmesa->state.stencil.hwBuffer ) {
1889          R200_STATECHANGE( rmesa, ctx );
1890          if ( state ) {
1891             rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] |=  R200_STENCIL_ENABLE;
1892          } else {
1893             rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] &= ~R200_STENCIL_ENABLE;
1894          }
1895       } else {
1896          FALLBACK( rmesa, R200_FALLBACK_STENCIL, state );
1897       }
1898       break;
1899
1900    case GL_TEXTURE_GEN_Q:
1901    case GL_TEXTURE_GEN_R:
1902    case GL_TEXTURE_GEN_S:
1903    case GL_TEXTURE_GEN_T:
1904       /* Picked up in r200UpdateTextureState.
1905        */
1906       rmesa->recheck_texgen[ctx->Texture.CurrentUnit] = GL_TRUE;
1907       break;
1908
1909    case GL_COLOR_SUM_EXT:
1910       r200UpdateSpecular ( ctx );
1911       break;
1912
1913    default:
1914       return;
1915    }
1916 }
1917
1918
1919 void r200LightingSpaceChange( GLcontext *ctx )
1920 {
1921    r200ContextPtr rmesa = R200_CONTEXT(ctx);
1922    GLboolean tmp;
1923
1924    if (R200_DEBUG & DEBUG_STATE)
1925       fprintf(stderr, "%s %d BEFORE %x\n", __FUNCTION__, ctx->_NeedEyeCoords,
1926               rmesa->hw.tcl.cmd[TCL_LIGHT_MODEL_CTL_0]);
1927
1928    if (ctx->_NeedEyeCoords)
1929       tmp = ctx->Transform.RescaleNormals;
1930    else
1931       tmp = !ctx->Transform.RescaleNormals;
1932
1933    R200_STATECHANGE( rmesa, tcl );
1934    if ( tmp ) {
1935       rmesa->hw.tcl.cmd[TCL_LIGHT_MODEL_CTL_0] |=  R200_RESCALE_NORMALS;
1936    } else {
1937       rmesa->hw.tcl.cmd[TCL_LIGHT_MODEL_CTL_0] &= ~R200_RESCALE_NORMALS;
1938    }
1939
1940    if (R200_DEBUG & DEBUG_STATE)
1941       fprintf(stderr, "%s %d AFTER %x\n", __FUNCTION__, ctx->_NeedEyeCoords,
1942               rmesa->hw.tcl.cmd[TCL_LIGHT_MODEL_CTL_0]);
1943 }
1944
1945 /* =============================================================
1946  * Deferred state management - matrices, textures, other?
1947  */
1948
1949
1950
1951
1952 static void upload_matrix( r200ContextPtr rmesa, GLfloat *src, int idx )
1953 {
1954    float *dest = ((float *)R200_DB_STATE( mat[idx] ))+MAT_ELT_0;
1955    int i;
1956
1957
1958    for (i = 0 ; i < 4 ; i++) {
1959       *dest++ = src[i];
1960       *dest++ = src[i+4];
1961       *dest++ = src[i+8];
1962       *dest++ = src[i+12];
1963    }
1964
1965    R200_DB_STATECHANGE( rmesa, &rmesa->hw.mat[idx] );
1966 }
1967
1968 static void upload_matrix_t( r200ContextPtr rmesa, const GLfloat *src, int idx )
1969 {
1970    float *dest = ((float *)R200_DB_STATE( mat[idx] ))+MAT_ELT_0;
1971    memcpy(dest, src, 16*sizeof(float));
1972    R200_DB_STATECHANGE( rmesa, &rmesa->hw.mat[idx] );
1973 }
1974
1975
1976 static void update_texturematrix( GLcontext *ctx )
1977 {
1978    r200ContextPtr rmesa = R200_CONTEXT( ctx );
1979    GLuint tpc = rmesa->hw.tcg.cmd[TCG_TEX_PROC_CTL_0];
1980    GLuint compsel = rmesa->hw.vtx.cmd[VTX_TCL_OUTPUT_COMPSEL];
1981    int unit;
1982
1983    if (R200_DEBUG & DEBUG_STATE)
1984       fprintf(stderr, "%s before COMPSEL: %x\n", __FUNCTION__,
1985               rmesa->hw.vtx.cmd[VTX_TCL_OUTPUT_COMPSEL]);
1986
1987    rmesa->TexMatEnabled = 0;
1988    rmesa->TexMatCompSel = 0;
1989
1990    for (unit = 0 ; unit < 2; unit++) {
1991       if (!ctx->Texture.Unit[unit]._ReallyEnabled)
1992          continue;
1993
1994       if (ctx->TextureMatrixStack[unit].Top->type != MATRIX_IDENTITY) {
1995          rmesa->TexMatEnabled |= (R200_TEXGEN_TEXMAT_0_ENABLE|
1996                                   R200_TEXMAT_0_ENABLE) << unit;
1997
1998          rmesa->TexMatCompSel |= R200_OUTPUT_TEX_0 << unit;
1999
2000          if (rmesa->TexGenEnabled & (R200_TEXMAT_0_ENABLE << unit)) {
2001             /* Need to preconcatenate any active texgen
2002              * obj/eyeplane matrices:
2003              */
2004             _math_matrix_mul_matrix( &rmesa->tmpmat,
2005                                      &rmesa->TexGenMatrix[unit],
2006                                      ctx->TextureMatrixStack[unit].Top );
2007             upload_matrix( rmesa, rmesa->tmpmat.m, R200_MTX_TEX0+unit );
2008          }
2009          else {
2010             upload_matrix( rmesa, ctx->TextureMatrixStack[unit].Top->m,
2011                            R200_MTX_TEX0+unit );
2012          }
2013       }
2014       else if (rmesa->TexGenEnabled & (R200_TEXMAT_0_ENABLE << unit)) {
2015          upload_matrix( rmesa, rmesa->TexGenMatrix[unit].m,
2016                         R200_MTX_TEX0+unit );
2017       }
2018    }
2019
2020    tpc = (rmesa->TexMatEnabled | rmesa->TexGenEnabled);
2021    if (tpc != rmesa->hw.tcg.cmd[TCG_TEX_PROC_CTL_0] ||
2022        rmesa->TexGenInputs != rmesa->hw.tcg.cmd[TCG_TEX_PROC_CTL_1]) {
2023       R200_STATECHANGE(rmesa, tcg);
2024       rmesa->hw.tcg.cmd[TCG_TEX_PROC_CTL_0] = tpc;
2025       rmesa->hw.tcg.cmd[TCG_TEX_PROC_CTL_1] = rmesa->TexGenInputs;
2026    }
2027
2028    compsel &= ~R200_OUTPUT_TEX_MASK;
2029    compsel |= rmesa->TexMatCompSel | rmesa->TexGenCompSel;
2030    if (compsel != rmesa->hw.vtx.cmd[VTX_TCL_OUTPUT_COMPSEL]) {
2031       R200_STATECHANGE(rmesa, vtx);
2032       rmesa->hw.vtx.cmd[VTX_TCL_OUTPUT_COMPSEL] = compsel;
2033    }
2034 }
2035
2036
2037
2038 void r200ValidateState( GLcontext *ctx )
2039 {
2040    r200ContextPtr rmesa = R200_CONTEXT(ctx);
2041    GLuint new_state = rmesa->NewGLState;
2042
2043    if (new_state & _NEW_TEXTURE) {
2044       r200UpdateTextureState( ctx );
2045       new_state |= rmesa->NewGLState; /* may add TEXTURE_MATRIX */
2046    }
2047
2048    /* Need an event driven matrix update?
2049     */
2050    if (new_state & (_NEW_MODELVIEW|_NEW_PROJECTION))
2051       upload_matrix( rmesa, ctx->_ModelProjectMatrix.m, R200_MTX_MVP );
2052
2053    /* Need these for lighting (shouldn't upload otherwise)
2054     */
2055    if (new_state & (_NEW_MODELVIEW)) {
2056       upload_matrix( rmesa, ctx->ModelviewMatrixStack.Top->m, R200_MTX_MV );
2057       upload_matrix_t( rmesa, ctx->ModelviewMatrixStack.Top->inv, R200_MTX_IMV );
2058    }
2059
2060    /* Does this need to be triggered on eg. modelview for
2061     * texgen-derived objplane/eyeplane matrices?
2062     */
2063    if (new_state & (_NEW_TEXTURE|_NEW_TEXTURE_MATRIX)) {
2064       update_texturematrix( ctx );
2065    }
2066
2067    if (new_state & (_NEW_LIGHT|_NEW_MODELVIEW|_MESA_NEW_NEED_EYE_COORDS)) {
2068       update_light( ctx );
2069    }
2070
2071    /* emit all active clip planes if projection matrix changes.
2072     */
2073    if (new_state & (_NEW_PROJECTION)) {
2074       if (ctx->Transform.ClipPlanesEnabled)
2075          r200UpdateClipPlanes( ctx );
2076    }
2077
2078
2079    rmesa->NewGLState = 0;
2080 }
2081
2082
2083 static void r200InvalidateState( GLcontext *ctx, GLuint new_state )
2084 {
2085    _swrast_InvalidateState( ctx, new_state );
2086    _swsetup_InvalidateState( ctx, new_state );
2087    _ac_InvalidateState( ctx, new_state );
2088    _tnl_InvalidateState( ctx, new_state );
2089    _ae_invalidate_state( ctx, new_state );
2090    R200_CONTEXT(ctx)->NewGLState |= new_state;
2091    r200VtxfmtInvalidate( ctx );
2092 }
2093
2094 /* A hack.  The r200 can actually cope just fine with materials
2095  * between begin/ends, so fix this.
2096  */
2097 static GLboolean check_material( GLcontext *ctx )
2098 {
2099    TNLcontext *tnl = TNL_CONTEXT(ctx);
2100    GLint i;
2101
2102    for (i = _TNL_ATTRIB_MAT_FRONT_AMBIENT;
2103         i < _TNL_ATTRIB_MAT_BACK_INDEXES;
2104         i++)
2105       if (tnl->vb.AttribPtr[i] &&
2106           tnl->vb.AttribPtr[i]->stride)
2107          return GL_TRUE;
2108
2109    return GL_FALSE;
2110 }
2111
2112
2113 static void r200WrapRunPipeline( GLcontext *ctx )
2114 {
2115    r200ContextPtr rmesa = R200_CONTEXT(ctx);
2116    GLboolean has_material;
2117
2118    if (0)
2119       fprintf(stderr, "%s, newstate: %x\n", __FUNCTION__, rmesa->NewGLState);
2120
2121    /* Validate state:
2122     */
2123    if (rmesa->NewGLState)
2124       r200ValidateState( ctx );
2125
2126    has_material = (ctx->Light.Enabled && check_material( ctx ));
2127
2128    if (has_material) {
2129       TCL_FALLBACK( ctx, R200_TCL_FALLBACK_MATERIAL, GL_TRUE );
2130    }
2131
2132    /* Run the pipeline.
2133     */
2134    _tnl_run_pipeline( ctx );
2135
2136    if (has_material) {
2137       TCL_FALLBACK( ctx, R200_TCL_FALLBACK_MATERIAL, GL_FALSE );
2138    }
2139 }
2140
2141
2142 /* Initialize the driver's state functions.
2143  */
2144 void r200InitStateFuncs( struct dd_function_table *functions )
2145 {
2146    functions->UpdateState               = r200InvalidateState;
2147    functions->LightingSpaceChange       = r200LightingSpaceChange;
2148
2149    functions->DrawBuffer                = r200DrawBuffer;
2150    functions->ReadBuffer                = r200ReadBuffer;
2151
2152    functions->AlphaFunc                 = r200AlphaFunc;
2153    functions->BlendEquation             = r200BlendEquation;
2154    functions->BlendFuncSeparate         = r200BlendFuncSeparate;
2155    functions->ClearColor                = r200ClearColor;
2156    functions->ClearDepth                = NULL;
2157    functions->ClearIndex                = NULL;
2158    functions->ClearStencil              = r200ClearStencil;
2159    functions->ClipPlane                 = r200ClipPlane;
2160    functions->ColorMask                 = r200ColorMask;
2161    functions->CullFace                  = r200CullFace;
2162    functions->DepthFunc                 = r200DepthFunc;
2163    functions->DepthMask                 = r200DepthMask;
2164    functions->DepthRange                = r200DepthRange;
2165    functions->Enable                    = r200Enable;
2166    functions->Fogfv                     = r200Fogfv;
2167    functions->FrontFace                 = r200FrontFace;
2168    functions->Hint                      = NULL;
2169    functions->IndexMask                 = NULL;
2170    functions->LightModelfv              = r200LightModelfv;
2171    functions->Lightfv                   = r200Lightfv;
2172    functions->LineStipple               = r200LineStipple;
2173    functions->LineWidth                 = r200LineWidth;
2174    functions->LogicOpcode               = r200LogicOpCode;
2175    functions->PolygonMode               = r200PolygonMode;
2176    functions->PolygonOffset             = r200PolygonOffset;
2177    functions->PolygonStipple            = r200PolygonStipple;
2178    functions->PointSize                 = r200PointSize;
2179    functions->RenderMode                = r200RenderMode;
2180    functions->Scissor                   = r200Scissor;
2181    functions->ShadeModel                = r200ShadeModel;
2182    functions->StencilFunc               = r200StencilFunc;
2183    functions->StencilMask               = r200StencilMask;
2184    functions->StencilOp                 = r200StencilOp;
2185    functions->Viewport                  = r200Viewport;
2186
2187    /* Swrast hooks for imaging extensions:
2188     */
2189    functions->CopyColorTable            = _swrast_CopyColorTable;
2190    functions->CopyColorSubTable         = _swrast_CopyColorSubTable;
2191    functions->CopyConvolutionFilter1D   = _swrast_CopyConvolutionFilter1D;
2192    functions->CopyConvolutionFilter2D   = _swrast_CopyConvolutionFilter2D;
2193 }
2194
2195
2196 void r200InitTnlFuncs( GLcontext *ctx )
2197 {
2198    TNL_CONTEXT(ctx)->Driver.NotifyMaterialChange = r200UpdateMaterial;
2199    TNL_CONTEXT(ctx)->Driver.RunPipeline = r200WrapRunPipeline;
2200 }