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