src/mesa/drivers/dri/gamma/gamma_state.c

   1 /* $XFree86: xc/lib/GL/mesa/src/drv/gamma/gamma_state.c,v 1.5 2002/11/05 17:46:07 tsi Exp $ */
   2 /*
   3  * Copyright 2001 by Alan Hourihane.
   4  *
   5  * Permission to use, copy, modify, distribute, and sell this software and its
   6  * documentation for any purpose is hereby granted without fee, provided that
   7  * the above copyright notice appear in all copies and that both that
   8  * copyright notice and this permission notice appear in supporting
   9  * documentation, and that the name of Alan Hourihane not be used in
  10  * advertising or publicity pertaining to distribution of the software without
  11  * specific, written prior permission.  Alan Hourihane makes no representations
  12  * about the suitability of this software for any purpose.  It is provided
  13  * "as is" without express or implied warranty.
  14  *
  15  * ALAN HOURIHANE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  16  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  17  * EVENT SHALL ALAN HOURIHANE BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  18  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  19  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  20  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  21  * PERFORMANCE OF THIS SOFTWARE.
  22  *
  23  * Authors:  Alan Hourihane, <alanh@tungstengraphics.com>
  24  *
  25  * 3DLabs Gamma driver
  26  */
  27
  28 #include "gamma_context.h"
  29 #include "gamma_macros.h"
  30 #include "macros.h"
  31 #include "glint_dri.h"
  32 #include "colormac.h"
  33 #include "swrast/swrast.h"
  34 #include "swrast_setup/swrast_setup.h"
  35 #include "array_cache/acache.h"
  36 #include "tnl/tnl.h"
  37
  38 #define ENABLELIGHTING 0
  39
  40 /* =============================================================
  41  * Alpha blending
  42  */
  43
  44 static void gammaUpdateAlphaMode( GLcontext *ctx )
  45 {
  46    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
  47    uint32_t a = gmesa->AlphaTestMode;
  48    uint32_t b = gmesa->AlphaBlendMode;
  49    uint32_t f = gmesa->AB_FBReadMode_Save = 0;
  50    GLubyte refByte = (GLint) (ctx->Color.AlphaRef * 255.0);
  51
  52    a &= ~(AT_CompareMask | AT_RefValueMask);
  53    b &= ~(AB_SrcBlendMask | AB_DstBlendMask);
  54
  55    a |= refByte << 4;
  56
  57    switch ( ctx->Color.AlphaFunc ) {
  58       case GL_NEVER:
  59          a |= AT_Never;
  60          break;
  61       case GL_LESS:
  62          a |= AT_Less;
  63          break;
  64       case GL_EQUAL:
  65          a |= AT_Equal;
  66          break;
  67       case GL_LEQUAL:
  68          a |= AT_LessEqual;
  69          break;
  70       case GL_GEQUAL:
  71          a |= AT_GreaterEqual;
  72          break;
  73       case GL_GREATER:
  74          a |= AT_Greater;
  75          break;
  76       case GL_NOTEQUAL:
  77          a |= AT_NotEqual;
  78          break;
  79       case GL_ALWAYS:
  80          a |= AT_Always;
  81          break;
  82    }
  83
  84    if ( ctx->Color.AlphaEnabled ) {
  85       f |= FBReadDstEnable;
  86       a |= AlphaTestModeEnable;
  87    } else {
  88       a &= ~AlphaTestModeEnable;
  89    }
  90
  91    switch ( ctx->Color.BlendSrcRGB ) {
  92       case GL_ZERO:
  93          b |= AB_Src_Zero;
  94          break;
  95       case GL_ONE:
  96          b |= AB_Src_One;
  97          break;
  98       case GL_DST_COLOR:
  99          b |= AB_Src_DstColor;
 100          break;
 101       case GL_ONE_MINUS_DST_COLOR:
 102          b |= AB_Src_OneMinusDstColor;
 103          break;
 104       case GL_SRC_ALPHA:
 105          b |= AB_Src_SrcAlpha;
 106          break;
 107       case GL_ONE_MINUS_SRC_ALPHA:
 108          b |= AB_Src_OneMinusSrcAlpha;
 109          break;
 110       case GL_DST_ALPHA:
 111          b |= AB_Src_DstAlpha;
 112          f |= FBReadSrcEnable;
 113          break;
 114       case GL_ONE_MINUS_DST_ALPHA:
 115          b |= AB_Src_OneMinusDstAlpha;
 116          f |= FBReadSrcEnable;
 117          break;
 118       case GL_SRC_ALPHA_SATURATE:
 119          b |= AB_Src_SrcAlphaSaturate;
 120          break;
 121    }
 122
 123    switch ( ctx->Color.BlendDstRGB ) {
 124       case GL_ZERO:
 125          b |= AB_Dst_Zero;
 126          break;
 127       case GL_ONE:
 128          b |= AB_Dst_One;
 129          break;
 130       case GL_SRC_COLOR:
 131          b |= AB_Dst_SrcColor;
 132          break;
 133       case GL_ONE_MINUS_SRC_COLOR:
 134          b |= AB_Dst_OneMinusSrcColor;
 135          break;
 136       case GL_SRC_ALPHA:
 137          b |= AB_Dst_SrcAlpha;
 138          break;
 139       case GL_ONE_MINUS_SRC_ALPHA:
 140          b |= AB_Dst_OneMinusSrcAlpha;
 141          break;
 142       case GL_DST_ALPHA:
 143          b |= AB_Dst_DstAlpha;
 144          f |= FBReadSrcEnable;
 145          break;
 146       case GL_ONE_MINUS_DST_ALPHA:
 147          b |= AB_Dst_OneMinusDstAlpha;
 148          f |= FBReadSrcEnable;
 149          break;
 150    }
 151
 152    if ( ctx->Color.BlendEnabled ) {
 153       f |= FBReadDstEnable;
 154       b |= AlphaBlendModeEnable;
 155    } else {
 156       b &= ~AlphaBlendModeEnable;
 157    }
 158
 159    if ( gmesa->AlphaTestMode != a ) {
 160       gmesa->AlphaTestMode = a;
 161       gmesa->dirty |= GAMMA_UPLOAD_ALPHA;
 162    }
 163    if ( gmesa->AlphaBlendMode != b) {
 164       gmesa->AlphaBlendMode = b;
 165       gmesa->dirty |= GAMMA_UPLOAD_BLEND;
 166    }
 167    gmesa->AB_FBReadMode_Save = f;
 168 }
 169
 170 static void gammaDDAlphaFunc( GLcontext *ctx, GLenum func, GLfloat ref )
 171 {
 172    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
 173    (void) ref;
 174
 175    FLUSH_BATCH( gmesa );
 176
 177    gmesa->new_state |= GAMMA_NEW_ALPHA;
 178 }
 179
 180 static void gammaDDBlendEquationSeparate( GLcontext *ctx,
 181                                           GLenum modeRGB, GLenum modeA )
 182 {
 183    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
 184
 185    assert( modeRGB == modeA );
 186    FLUSH_BATCH( gmesa );
 187
 188    gmesa->new_state |= GAMMA_NEW_ALPHA;
 189 }
 190
 191 static void gammaDDBlendFuncSeparate( GLcontext *ctx,
 192                                      GLenum sfactorRGB, GLenum dfactorRGB,
 193                                      GLenum sfactorA, GLenum dfactorA )
 194 {
 195    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
 196
 197    FLUSH_BATCH( gmesa );
 198
 199    gmesa->new_state |= GAMMA_NEW_ALPHA;
 200 }
 201
 202
 203 /* ================================================================
 204  * Buffer clear
 205  */
 206
 207 static void gammaDDClear( GLcontext *ctx, GLbitfield mask, GLboolean all,
 208                                GLint cx, GLint cy, GLint cw, GLint ch )
 209 {
 210    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
 211    GLINTDRIPtr gDRIPriv = (GLINTDRIPtr)gmesa->driScreen->pDevPriv;
 212    GLuint temp = 0;
 213
 214    FLUSH_BATCH( gmesa );
 215
 216    /* Update and emit any new state.  We need to do this here to catch
 217     * changes to the masks.
 218     * FIXME: Just update the masks?
 219     */
 220    if ( gmesa->new_state )
 221       gammaDDUpdateHWState( ctx );
 222
 223 #ifdef DO_VALIDATE
 224     /* Flush any partially filled buffers */
 225     FLUSH_DMA_BUFFER(gmesa);
 226
 227     DRM_SPINLOCK(&gmesa->driScreen->pSAREA->drawable_lock,
 228                  gmesa->driScreen->drawLockID);
 229     VALIDATE_DRAWABLE_INFO_NO_LOCK(gmesa);
 230 #endif
 231
 232     if (mask & DD_DEPTH_BIT) {
 233          /* Turn off writes the FB */
 234          CHECK_DMA_BUFFER(gmesa, 1);
 235          WRITE(gmesa->buf, FBWriteMode, FBWriteModeDisable);
 236
 237          mask &= ~DD_DEPTH_BIT;
 238
 239          /*
 240           * Turn Rectangle2DControl off when the window is not clipped
 241           * (i.e., the GID tests are not necessary).  This dramatically
 242           * increases the performance of the depth clears.
 243           */
 244          if (!gmesa->NotClipped) {
 245             CHECK_DMA_BUFFER(gmesa, 1);
 246             WRITE(gmesa->buf, Rectangle2DControl, 1);
 247          }
 248
 249          temp = (gmesa->LBReadMode & LBPartialProdMask) | LBWindowOriginBot;
 250          if (gDRIPriv->numMultiDevices == 2) temp |= LBScanLineInt2;
 251
 252          CHECK_DMA_BUFFER(gmesa, 5);
 253          WRITE(gmesa->buf, LBReadMode, temp);
 254          WRITE(gmesa->buf, DeltaMode, DM_DepthEnable);
 255          WRITE(gmesa->buf, DepthMode, (DepthModeEnable |
 256                                         DM_Always |
 257                                         DM_SourceDepthRegister |
 258                                         DM_WriteMask));
 259          WRITE(gmesa->buf, GLINTDepth, gmesa->ClearDepth);
 260
 261          /* Increment the frame count */
 262          gmesa->FrameCount++;
 263 #ifdef FAST_CLEAR_4
 264          gmesa->FrameCount &= 0x0f;
 265 #else
 266          gmesa->FrameCount &= 0xff;
 267 #endif
 268
 269          /* Force FCP to be written */
 270          WRITE(gmesa->buf, GLINTWindow, (WindowEnable |
 271                                           W_PassIfEqual |
 272                                           (gmesa->Window & W_GIDMask) |
 273                                           W_DepthFCP |
 274                                           W_LBUpdateFromRegisters |
 275                                           W_OverrideWriteFiltering |
 276                                           (gmesa->FrameCount << 9)));
 277
 278         /* Clear part of the depth and FCP buffers */
 279         {
 280             int y = gmesa->driScreen->fbHeight - gmesa->driDrawable->y - gmesa->driDrawable->h;
 281             int x = gmesa->driDrawable->x;
 282             int w = gmesa->driDrawable->w;
 283             int h = gmesa->driDrawable->h;
 284 #ifndef TURN_OFF_FCP
 285             float hsub = h;
 286
 287             if (gmesa->WindowChanged) {
 288                 gmesa->WindowChanged = GL_FALSE;
 289             } else {
 290 #ifdef FAST_CLEAR_4
 291                 hsub /= 16;
 292 #else
 293                 hsub /= 256;
 294 #endif
 295
 296                 /* Handle the case where the height < # of FCPs */
 297                 if (hsub < 1.0) {
 298                     if (gmesa->FrameCount > h)
 299                         gmesa->FrameCount = 0;
 300                     h = 1;
 301                     y += gmesa->FrameCount;
 302                 } else {
 303                     h = (gmesa->FrameCount+1)*hsub;
 304                     h -= (int)(gmesa->FrameCount*hsub);
 305                     y += gmesa->FrameCount*hsub;
 306                 }
 307             }
 308 #endif
 309             if (h && w) {
 310 #if 0
 311                 CHECK_DMA_BUFFER(gmesa, 2);
 312                 WRITE(gmesa->buf, Rectangle2DMode, ((h & 0xfff)<<12) |
 313                                                    (w & 0xfff) );
 314                 WRITE(gmesa->buf, DrawRectangle2D, ((y & 0xffff)<<16) |
 315                                                    (x & 0xffff) );
 316 #else
 317                 CHECK_DMA_BUFFER(gmesa, 8);
 318                 WRITE(gmesa->buf, StartXDom,   x<<16);
 319                 WRITE(gmesa->buf, StartY,      y<<16);
 320                 WRITE(gmesa->buf, StartXSub,   (x+w)<<16);
 321                 WRITE(gmesa->buf, GLINTCount,  h);
 322                 WRITE(gmesa->buf, dY,          1<<16);
 323                 WRITE(gmesa->buf, dXDom,       0<<16);
 324                 WRITE(gmesa->buf, dXSub,       0<<16);
 325                 WRITE(gmesa->buf, Render,      0x00000040); /* NOT_DONE */
 326 #endif
 327             }
 328         }
 329
 330         CHECK_DMA_BUFFER(gmesa, 6);
 331         WRITE(gmesa->buf, DepthMode, gmesa->DepthMode);
 332         WRITE(gmesa->buf, DeltaMode, gmesa->DeltaMode);
 333         WRITE(gmesa->buf, LBReadMode, gmesa->LBReadMode);
 334         WRITE(gmesa->buf, GLINTWindow, gmesa->Window);
 335         WRITE(gmesa->buf, FastClearDepth, gmesa->ClearDepth);
 336         WRITE(gmesa->buf, FBWriteMode, FBWriteModeEnable);
 337
 338         /* Turn on Depth FCP */
 339         if (gmesa->Window & W_DepthFCP) {
 340             CHECK_DMA_BUFFER(gmesa, 1);
 341             WRITE(gmesa->buf, WindowOr, (gmesa->FrameCount << 9));
 342         }
 343
 344         /* Turn off GID clipping if window is not clipped */
 345         if (gmesa->NotClipped) {
 346             CHECK_DMA_BUFFER(gmesa, 1);
 347             WRITE(gmesa->buf, Rectangle2DControl, 0);
 348         }
 349     }
 350
 351     if (mask & (DD_FRONT_LEFT_BIT | DD_BACK_LEFT_BIT)) {
 352         int y = gmesa->driScreen->fbHeight - gmesa->driDrawable->y - gmesa->driDrawable->h;
 353         int x = gmesa->driDrawable->x;
 354         int w = gmesa->driDrawable->w;
 355         int h = gmesa->driDrawable->h;
 356
 357         mask &= ~(DD_FRONT_LEFT_BIT | DD_BACK_LEFT_BIT);
 358
 359         if (x < 0) { w -= -x; x = 0; }
 360
 361         /* Turn on GID clipping if window is clipped */
 362         if (!gmesa->NotClipped) {
 363             CHECK_DMA_BUFFER(gmesa, 1);
 364             WRITE(gmesa->buf, Rectangle2DControl, 1);
 365         }
 366
 367         CHECK_DMA_BUFFER(gmesa, 18);
 368         WRITE(gmesa->buf, FBBlockColor, gmesa->ClearColor);
 369         WRITE(gmesa->buf, ColorDDAMode, ColorDDADisable);
 370         WRITE(gmesa->buf, FBWriteMode, FBWriteModeEnable);
 371         WRITE(gmesa->buf, DepthMode, 0);
 372         WRITE(gmesa->buf, DeltaMode, 0);
 373         WRITE(gmesa->buf, AlphaBlendMode, 0);
 374 #if 1
 375         WRITE(gmesa->buf, dY,          1<<16);
 376         WRITE(gmesa->buf, dXDom,       0<<16);
 377         WRITE(gmesa->buf, dXSub,       0<<16);
 378         WRITE(gmesa->buf, StartXSub,   (x+w)<<16);
 379         WRITE(gmesa->buf, GLINTCount,  h);
 380         WRITE(gmesa->buf, StartXDom,   x<<16);
 381         WRITE(gmesa->buf, StartY,      y<<16);
 382         WRITE(gmesa->buf, Render,      0x00000048); /* NOT_DONE */
 383 #else
 384         WRITE(gmesa->buf, Rectangle2DMode, (((h & 0xfff)<<12) |
 385                                               (w & 0xfff)));
 386         WRITE(gmesa->buf, DrawRectangle2D, (((y & 0xffff)<<16) |
 387                                               (x & 0xffff)));
 388 #endif
 389         WRITE(gmesa->buf, DepthMode, gmesa->DepthMode);
 390         WRITE(gmesa->buf, DeltaMode, gmesa->DeltaMode);
 391         WRITE(gmesa->buf, AlphaBlendMode, gmesa->AlphaBlendMode);
 392         WRITE(gmesa->buf, ColorDDAMode, gmesa->ColorDDAMode);
 393
 394         /* Turn off GID clipping if window is clipped */
 395         if (gmesa->NotClipped) {
 396             CHECK_DMA_BUFFER(gmesa, 1);
 397             WRITE(gmesa->buf, Rectangle2DControl, 0);
 398         }
 399     }
 400
 401 #ifdef DO_VALIDATE
 402     PROCESS_DMA_BUFFER_TOP_HALF(gmesa);
 403
 404     DRM_SPINUNLOCK(&gmesa->driScreen->pSAREA->drawable_lock,
 405                    gmesa->driScreen->drawLockID);
 406     VALIDATE_DRAWABLE_INFO_NO_LOCK_POST(gmesa);
 407
 408     PROCESS_DMA_BUFFER_BOTTOM_HALF(gmesa);
 409 #endif
 410
 411    if ( mask )
 412       _swrast_Clear( ctx, mask, all, cx, cy, cw, ch );
 413 }
 414
 415 /* =============================================================
 416  * Depth testing
 417  */
 418
 419 static void gammaUpdateZMode( GLcontext *ctx )
 420 {
 421    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
 422    uint32_t z = gmesa->DepthMode;
 423    uint32_t delta = gmesa->DeltaMode;
 424    uint32_t window = gmesa->Window;
 425    uint32_t lbread = gmesa->LBReadMode;
 426
 427    z &= ~DM_CompareMask;
 428
 429    switch ( ctx->Depth.Func ) {
 430       case GL_NEVER:
 431          z |= DM_Never;
 432          break;
 433       case GL_ALWAYS:
 434          z |= DM_Always;
 435          break;
 436       case GL_LESS:
 437          z |= DM_Less;
 438          break;
 439       case GL_LEQUAL:
 440          z |= DM_LessEqual;
 441          break;
 442       case GL_EQUAL:
 443          z |= DM_Equal;
 444          break;
 445       case GL_GEQUAL:
 446          z |= DM_GreaterEqual;
 447          break;
 448       case GL_GREATER:
 449          z |= DM_Greater;
 450          break;
 451       case GL_NOTEQUAL:
 452          z |= DM_NotEqual;
 453          break;
 454    }
 455
 456    if ( ctx->Depth.Test ) {
 457       z      |= DepthModeEnable;
 458       delta  |= DM_DepthEnable;
 459       window |= W_DepthFCP;
 460       lbread |= LBReadDstEnable;
 461    } else {
 462       z      &= ~DepthModeEnable;
 463       delta  &= ~DM_DepthEnable;
 464       window &= ~W_DepthFCP;
 465       lbread &= ~LBReadDstEnable;
 466    }
 467
 468    if ( ctx->Depth.Mask ) {
 469       z |= DM_WriteMask;
 470    } else {
 471       z &= ~DM_WriteMask;
 472    }
 473
 474 #if 0
 475    if ( gmesa->DepthMode != z ){
 476 #endif
 477       gmesa->DepthMode = z;
 478       gmesa->DeltaMode = delta;
 479       gmesa->Window = window;
 480       gmesa->LBReadMode = lbread;
 481       gmesa->dirty |= GAMMA_UPLOAD_DEPTH;
 482 #if 0
 483    }
 484 #endif
 485 }
 486
 487 static void gammaDDDepthFunc( GLcontext *ctx, GLenum func )
 488 {
 489    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
 490
 491    FLUSH_BATCH( gmesa );
 492    gmesa->new_state |= GAMMA_NEW_DEPTH;
 493 }
 494
 495 static void gammaDDDepthMask( GLcontext *ctx, GLboolean flag )
 496 {
 497    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
 498
 499    FLUSH_BATCH( gmesa );
 500    gmesa->new_state |= GAMMA_NEW_DEPTH;
 501 }
 502
 503 static void gammaDDClearDepth( GLcontext *ctx, GLclampd d )
 504 {
 505    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
 506
 507    switch ( gmesa->DepthSize ) {
 508    case 16:
 509       gmesa->ClearDepth = d * 0x0000ffff;
 510       break;
 511    case 24:
 512       gmesa->ClearDepth = d * 0x00ffffff;
 513       break;
 514    case 32:
 515       gmesa->ClearDepth = d * 0xffffffff;
 516       break;
 517    }
 518 }
 519
 520 static void gammaDDFinish( GLcontext *ctx )
 521 {
 522    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
 523
 524    FLUSH_DMA_BUFFER(gmesa);
 525 }
 526
 527 static void gammaDDFlush( GLcontext *ctx )
 528 {
 529    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
 530
 531    FLUSH_DMA_BUFFER(gmesa);
 532 }
 533
 534 /* =============================================================
 535  * Fog
 536  */
 537
 538 static void gammaUpdateFogAttrib( GLcontext *ctx )
 539 {
 540    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
 541    uint32_t f = gmesa->FogMode;
 542    uint32_t g = gmesa->GeometryMode;
 543    uint32_t d = gmesa->DeltaMode;
 544
 545    if (ctx->Fog.Enabled) {
 546       f |= FogModeEnable;
 547       g |= GM_FogEnable;
 548       d |= DM_FogEnable;
 549    } else {
 550       f &= ~FogModeEnable;
 551       g &= ~GM_FogEnable;
 552       d &= ~DM_FogEnable;
 553    }
 554
 555    g &= ~GM_FogMask;
 556
 557    switch (ctx->Fog.Mode) {
 558       case GL_LINEAR:
 559          g |= GM_FogLinear;
 560          break;
 561       case GL_EXP:
 562          g |= GM_FogExp;
 563          break;
 564       case GL_EXP2:
 565          g |= GM_FogExpSquared;
 566          break;
 567    }
 568
 569    if ( gmesa->FogMode != f ) {
 570       gmesa->FogMode = f;
 571       gmesa->dirty |= GAMMA_UPLOAD_FOG;
 572    }
 573
 574    if ( gmesa->GeometryMode != g ) {
 575       gmesa->GeometryMode = g;
 576       gmesa->dirty |= GAMMA_UPLOAD_GEOMETRY;
 577    }
 578
 579    if ( gmesa->DeltaMode != d ) {
 580       gmesa->DeltaMode = d;
 581       gmesa->dirty |= GAMMA_UPLOAD_DEPTH;
 582    }
 583 }
 584
 585 #if 0
 586 static void gammaDDFogfv( GLcontext *ctx, GLenum pname, const GLfloat *param )
 587 {
 588    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
 589
 590    FLUSH_BATCH( gmesa );
 591    gmesa->new_state |= GAMMA_NEW_FOG;
 592 }
 593 #endif
 594
 595 /* =============================================================
 596  * Lines
 597  */
 598 static void gammaDDLineWidth( GLcontext *ctx, GLfloat width )
 599 {
 600    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
 601
 602    CHECK_DMA_BUFFER(gmesa, 3);
 603    WRITE(gmesa->buf, LineWidth, (GLuint)width);
 604    WRITEF(gmesa->buf, AAlineWidth, width);
 605    WRITE(gmesa->buf, LineWidthOffset, (GLuint)(width-1)/2);
 606 }
 607
 608 static void gammaDDLineStipple( GLcontext *ctx, GLint factor, GLushort pattern )
 609 {
 610    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
 611
 612    gmesa->LineMode &= ~(LM_StippleMask | LM_RepeatFactorMask);
 613    gmesa->LineMode |= ((GLuint)(factor - 1) << 1) | ((GLuint)pattern << 10);
 614
 615    gmesa->dirty |= GAMMA_UPLOAD_LINEMODE;
 616 }
 617
 618
 619
 620 /* =============================================================
 621  * Points
 622  */
 623 static void gammaDDPointSize( GLcontext *ctx, GLfloat size )
 624 {
 625    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
 626
 627    CHECK_DMA_BUFFER(gmesa, 2);
 628    WRITE(gmesa->buf, PointSize, (GLuint)size);
 629    WRITEF(gmesa->buf, AApointSize, size);
 630 }
 631
 632 /* =============================================================
 633  * Polygon
 634  */
 635
 636 static void gammaUpdatePolygon( GLcontext *ctx )
 637 {
 638    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
 639    uint32_t g = gmesa->GeometryMode;
 640
 641    g &= ~(GM_PolyOffsetFillEnable | GM_PolyOffsetPointEnable |
 642           GM_PolyOffsetLineEnable);
 643
 644    if (ctx->Polygon.OffsetFill) g |= GM_PolyOffsetFillEnable;
 645    if (ctx->Polygon.OffsetPoint) g |= GM_PolyOffsetPointEnable;
 646    if (ctx->Polygon.OffsetLine) g |= GM_PolyOffsetLineEnable;
 647
 648    g &= ~GM_FB_PolyMask;
 649
 650    switch (ctx->Polygon.FrontMode) {
 651       case GL_FILL:
 652          g |= GM_FrontPolyFill;
 653          break;
 654       case GL_LINE:
 655          g |= GM_FrontPolyLine;
 656          break;
 657       case GL_POINT:
 658          g |= GM_FrontPolyPoint;
 659          break;
 660    }
 661
 662    switch (ctx->Polygon.BackMode) {
 663       case GL_FILL:
 664          g |= GM_BackPolyFill;
 665          break;
 666       case GL_LINE:
 667          g |= GM_BackPolyLine;
 668          break;
 669       case GL_POINT:
 670          g |= GM_BackPolyPoint;
 671          break;
 672    }
 673
 674    if ( gmesa->GeometryMode != g ) {
 675       gmesa->GeometryMode = g;
 676       gmesa->dirty |= GAMMA_UPLOAD_GEOMETRY;
 677    }
 678
 679    gmesa->dirty |= GAMMA_UPLOAD_POLYGON;
 680 }
 681
 682 static void gammaDDPolygonMode( GLcontext *ctx, GLenum face, GLenum mode)
 683 {
 684    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
 685
 686    FLUSH_BATCH( gmesa );
 687
 688    gmesa->new_state |= GAMMA_NEW_POLYGON;
 689 }
 690
 691 static void gammaUpdateStipple( GLcontext *ctx )
 692 {
 693    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
 694
 695    FLUSH_BATCH( gmesa );
 696
 697    if (ctx->Polygon.StippleFlag) {
 698       gmesa->AreaStippleMode |= AreaStippleModeEnable/* | ASM_X32 | ASM_Y32*/;
 699    } else {
 700       gmesa->AreaStippleMode &= ~AreaStippleModeEnable;
 701    }
 702
 703    gmesa->dirty |= GAMMA_UPLOAD_STIPPLE;
 704 }
 705
 706 static void gammaDDPolygonStipple( GLcontext *ctx, const GLubyte *mask)
 707 {
 708    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
 709    FLUSH_BATCH( gmesa );
 710    gmesa->new_state |= GAMMA_NEW_STIPPLE;
 711 }
 712
 713 /* =============================================================
 714  * Clipping
 715  */
 716
 717 static void gammaUpdateClipping( GLcontext *ctx )
 718 {
 719    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
 720    GLint x1, y1, x2, y2;
 721
 722    if ( gmesa->driDrawable ) {
 723       x1 = gmesa->driDrawable->x + ctx->Scissor.X;
 724       y1 = gmesa->driScreen->fbHeight -
 725         (gmesa->driDrawable->y +
 726          gmesa->driDrawable->h) + ctx->Scissor.Y;
 727       x2 = x1 + ctx->Scissor.Width;
 728       y2 = y1 + ctx->Scissor.Height;
 729
 730       gmesa->ScissorMinXY = x1 | (y1 << 16);
 731       gmesa->ScissorMaxXY = x2 | (y2 << 16);
 732       if (ctx->Scissor.Enabled)
 733          gmesa->ScissorMode |= UserScissorEnable;
 734       else
 735          gmesa->ScissorMode &= ~UserScissorEnable;
 736
 737       gmesa->dirty |= GAMMA_UPLOAD_CLIP;
 738    }
 739 }
 740
 741 static void gammaDDScissor( GLcontext *ctx,
 742                            GLint x, GLint y, GLsizei w, GLsizei h )
 743 {
 744    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
 745
 746    FLUSH_BATCH( gmesa );
 747    gmesa->new_state |= GAMMA_NEW_CLIP;
 748 }
 749
 750 /* =============================================================
 751  * Culling
 752  */
 753
 754 static void gammaUpdateCull( GLcontext *ctx )
 755 {
 756    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
 757    uint32_t g = gmesa->GeometryMode;
 758
 759    g &= ~(GM_PolyCullMask | GM_FFMask);
 760
 761    if (ctx->Polygon.FrontFace == GL_CCW) {
 762       g |= GM_FrontFaceCCW;
 763    } else {
 764       g |= GM_FrontFaceCW;
 765    }
 766
 767    switch ( ctx->Polygon.CullFaceMode ) {
 768       case GL_FRONT:
 769          g |= GM_PolyCullFront;
 770          break;
 771       case GL_BACK:
 772          g |= GM_PolyCullBack;
 773          break;
 774       case GL_FRONT_AND_BACK:
 775          g |= GM_PolyCullBoth;
 776          break;
 777    }
 778
 779    if ( ctx->Polygon.CullFlag ) {
 780       g |= GM_PolyCullEnable;
 781    } else {
 782       g &= ~GM_PolyCullEnable;
 783    }
 784
 785    if ( gmesa->GeometryMode != g ) {
 786       gmesa->GeometryMode = g;
 787       gmesa->dirty |= GAMMA_UPLOAD_GEOMETRY;
 788    }
 789 }
 790
 791 static void gammaDDCullFace( GLcontext *ctx, GLenum mode )
 792 {
 793    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
 794
 795    FLUSH_BATCH( gmesa );
 796    gmesa->new_state |= GAMMA_NEW_CULL;
 797 }
 798
 799 static void gammaDDFrontFace( GLcontext *ctx, GLenum mode )
 800 {
 801    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
 802
 803    FLUSH_BATCH( gmesa );
 804    gmesa->new_state |= GAMMA_NEW_CULL;
 805 }
 806
 807 /* =============================================================
 808  * Masks
 809  */
 810
 811 static void gammaUpdateMasks( GLcontext *ctx )
 812 {
 813    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
 814
 815
 816    GLuint mask = gammaPackColor( gmesa->gammaScreen->cpp,
 817                                 ctx->Color.ColorMask[RCOMP],
 818                                 ctx->Color.ColorMask[GCOMP],
 819                                 ctx->Color.ColorMask[BCOMP],
 820                                 ctx->Color.ColorMask[ACOMP] );
 821
 822    if (gmesa->gammaScreen->cpp == 2) mask |= mask << 16;
 823
 824    if ( gmesa->FBHardwareWriteMask != mask ) {
 825       gmesa->FBHardwareWriteMask = mask;
 826       gmesa->dirty |= GAMMA_UPLOAD_MASKS;
 827    }
 828 }
 829
 830 static void gammaDDColorMask( GLcontext *ctx, GLboolean r, GLboolean g,
 831                               GLboolean b, GLboolean a)
 832 {
 833    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
 834
 835    FLUSH_BATCH( gmesa );
 836    gmesa->new_state |= GAMMA_NEW_MASKS;
 837 }
 838
 839 /* =============================================================
 840  * Rendering attributes
 841  *
 842  * We really don't want to recalculate all this every time we bind a
 843  * texture.  These things shouldn't change all that often, so it makes
 844  * sense to break them out of the core texture state update routines.
 845  */
 846
 847 #if ENABLELIGHTING
 848 static void gammaDDLightfv(GLcontext *ctx, GLenum light, GLenum pname,
 849                                 const GLfloat *params, GLint nParams)
 850 {
 851     gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
 852     GLfloat l,x,y,z,w;
 853
 854     switch(light) {
 855     case GL_LIGHT0:
 856         switch (pname) {
 857         case GL_AMBIENT:
 858             CHECK_DMA_BUFFER(gmesa, 3);
 859             /* We don't do alpha */
 860             WRITEF(gmesa->buf, Light0AmbientIntensityBlue, params[2]);
 861             WRITEF(gmesa->buf, Light0AmbientIntensityGreen, params[1]);
 862             WRITEF(gmesa->buf, Light0AmbientIntensityRed, params[0]);
 863             break;
 864         case GL_DIFFUSE:
 865             CHECK_DMA_BUFFER(gmesa, 3);
 866             /* We don't do alpha */
 867             WRITEF(gmesa->buf, Light0DiffuseIntensityBlue, params[2]);
 868             WRITEF(gmesa->buf, Light0DiffuseIntensityGreen, params[1]);
 869             WRITEF(gmesa->buf, Light0DiffuseIntensityRed, params[0]);
 870             break;
 871         case GL_SPECULAR:
 872             CHECK_DMA_BUFFER(gmesa, 3);
 873             /* We don't do alpha */
 874             WRITEF(gmesa->buf, Light0SpecularIntensityBlue, params[2]);
 875             WRITEF(gmesa->buf, Light0SpecularIntensityGreen, params[1]);
 876             WRITEF(gmesa->buf, Light0SpecularIntensityRed, params[0]);
 877             break;
 878         case GL_POSITION:
 879             /* Normalize <x,y,z> */
 880             x = params[0]; y = params[1]; z = params[2]; w = params[3];
 881             l = sqrt(x*x + y*y + z*z + w*w);
 882             w /= l;
 883             x /= l;
 884             y /= l;
 885             z /= l;
 886             if (params[3] != 0.0) {
 887                 gmesa->Light0Mode |= Light0ModeAttenuation;
 888                 gmesa->Light0Mode |= Light0ModeLocal;
 889             } else {
 890                 gmesa->Light0Mode &= ~Light0ModeAttenuation;
 891                 gmesa->Light0Mode &= ~Light0ModeLocal;
 892             }
 893             CHECK_DMA_BUFFER(gmesa, 5);
 894             WRITE(gmesa->buf, Light0Mode, gmesa->Light0Mode);
 895             WRITEF(gmesa->buf, Light0PositionW, w);
 896             WRITEF(gmesa->buf, Light0PositionZ, z);
 897             WRITEF(gmesa->buf, Light0PositionY, y);
 898             WRITEF(gmesa->buf, Light0PositionX, x);
 899             break;
 900         case GL_SPOT_DIRECTION:
 901             CHECK_DMA_BUFFER(gmesa, 3);
 902             /* WRITEF(gmesa->buf, Light0SpotlightDirectionW, params[3]); */
 903             WRITEF(gmesa->buf, Light0SpotlightDirectionZ, params[2]);
 904             WRITEF(gmesa->buf, Light0SpotlightDirectionY, params[1]);
 905             WRITEF(gmesa->buf, Light0SpotlightDirectionX, params[0]);
 906             break;
 907         case GL_SPOT_EXPONENT:
 908             CHECK_DMA_BUFFER(gmesa, 1);
 909             WRITEF(gmesa->buf, Light0SpotlightExponent, params[0]);
 910             break;
 911         case GL_SPOT_CUTOFF:
 912             if (params[0] != 180.0)
 913                 gmesa->Light0Mode |= Light0ModeSpotLight;
 914             else
 915                 gmesa->Light0Mode &= ~Light0ModeSpotLight;
 916             CHECK_DMA_BUFFER(gmesa, 2);
 917             WRITE(gmesa->buf, Light0Mode, gmesa->Light0Mode);
 918             WRITEF(gmesa->buf, Light0CosSpotlightCutoffAngle, cos(params[0]*DEG2RAD));
 919             break;
 920         case GL_CONSTANT_ATTENUATION:
 921             CHECK_DMA_BUFFER(gmesa, 1);
 922             WRITEF(gmesa->buf, Light0ConstantAttenuation, params[0]);
 923             break;
 924         case GL_LINEAR_ATTENUATION:
 925             CHECK_DMA_BUFFER(gmesa, 1);
 926             WRITEF(gmesa->buf, Light0LinearAttenuation, params[0]);
 927             break;
 928         case GL_QUADRATIC_ATTENUATION:
 929             CHECK_DMA_BUFFER(gmesa, 1);
 930             WRITEF(gmesa->buf, Light0QuadraticAttenuation, params[0]);
 931             break;
 932         }
 933         break;
 934     }
 935 }
 936
 937 static void gammaDDLightModelfv( GLcontext *ctx, GLenum pname,
 938                                 const GLfloat *params )
 939 {
 940    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
 941
 942    switch (pname) {
 943    case GL_LIGHT_MODEL_AMBIENT:
 944         CHECK_DMA_BUFFER(gmesa, 3);
 945         /* We don't do alpha */
 946         WRITEF(gmesa->buf, SceneAmbientColorBlue, params[2]);
 947         WRITEF(gmesa->buf, SceneAmbientColorGreen, params[1]);
 948         WRITEF(gmesa->buf, SceneAmbientColorRed, params[0]);
 949         break;
 950     case GL_LIGHT_MODEL_LOCAL_VIEWER:
 951         if (params[0] != 0.0)
 952             gmesa->LightingMode |= LightingModeLocalViewer;
 953         else
 954             gmesa->LightingMode &= ~LightingModeLocalViewer;
 955         CHECK_DMA_BUFFER(gmesa, 1);
 956         WRITE(gmesa->buf, LightingMode, gmesa->LightingMode);
 957         break;
 958     case GL_LIGHT_MODEL_TWO_SIDE:
 959         if (params[0] == 1.0f) {
 960             gmesa->LightingMode |= LightingModeTwoSides;
 961             gmesa->MaterialMode |= MaterialModeTwoSides;
 962         } else {
 963             gmesa->LightingMode &= ~LightingModeTwoSides;
 964             gmesa->MaterialMode &= ~MaterialModeTwoSides;
 965         }
 966         CHECK_DMA_BUFFER(gmesa, 2);
 967         WRITE(gmesa->buf, LightingMode, gmesa->LightingMode);
 968         WRITE(gmesa->buf, MaterialMode, gmesa->MaterialMode);
 969         break;
 970     }
 971 }
 972 #endif
 973
 974 static void gammaDDShadeModel( GLcontext *ctx, GLenum mode )
 975 {
 976    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
 977    uint32_t g = gmesa->GeometryMode;
 978    uint32_t c = gmesa->ColorDDAMode;
 979
 980    g &= ~GM_ShadingMask;
 981    c &= ~ColorDDAShadingMask;
 982
 983    switch ( mode ) {
 984    case GL_FLAT:
 985       g |= GM_FlatShading;
 986       c |= ColorDDAFlat;
 987       break;
 988    case GL_SMOOTH:
 989       g |= GM_GouraudShading;
 990       c |= ColorDDAGouraud;
 991       break;
 992    default:
 993       return;
 994    }
 995
 996    if ( gmesa->ColorDDAMode != c ) {
 997       FLUSH_BATCH( gmesa );
 998       gmesa->ColorDDAMode = c;
 999
1000       gmesa->dirty |= GAMMA_UPLOAD_SHADE;
1001    }
1002
1003    if ( gmesa->GeometryMode != g ) {
1004       FLUSH_BATCH( gmesa );
1005       gmesa->GeometryMode = g;
1006
1007       gmesa->dirty |= GAMMA_UPLOAD_GEOMETRY;
1008    }
1009 }
1010
1011 /* =============================================================
1012  * Miscellaneous
1013  */
1014
1015 static void gammaDDClearColor( GLcontext *ctx, const GLfloat color[4])
1016 {
1017    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
1018    GLubyte c[4];
1019    UNCLAMPED_FLOAT_TO_UBYTE(c[0], color[0]);
1020    UNCLAMPED_FLOAT_TO_UBYTE(c[1], color[1]);
1021    UNCLAMPED_FLOAT_TO_UBYTE(c[2], color[2]);
1022    UNCLAMPED_FLOAT_TO_UBYTE(c[3], color[3]);
1023
1024    gmesa->ClearColor = gammaPackColor( gmesa->gammaScreen->cpp,
1025                                        c[0], c[1], c[2], c[3] );
1026
1027    if (gmesa->gammaScreen->cpp == 2) gmesa->ClearColor |= gmesa->ClearColor<<16;
1028 }
1029
1030
1031 static void gammaDDLogicalOpcode( GLcontext *ctx, GLenum opcode )
1032 {
1033    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
1034
1035    FLUSH_BATCH( gmesa );
1036
1037    if ( ctx->Color.ColorLogicOpEnabled ) {
1038       gmesa->LogicalOpMode = opcode << 1 | LogicalOpModeEnable;
1039    } else {
1040       gmesa->LogicalOpMode = LogicalOpModeDisable;
1041    }
1042
1043    gmesa->dirty |= GAMMA_UPLOAD_LOGICOP;
1044 }
1045
1046 static void gammaDDDrawBuffer( GLcontext *ctx, GLenum mode )
1047 {
1048    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
1049
1050    FLUSH_BATCH( gmesa );
1051
1052    switch ( mode ) {
1053    case GL_FRONT_LEFT:
1054       gmesa->drawOffset = gmesa->readOffset = 0;
1055       break;
1056    case GL_BACK_LEFT:
1057       gmesa->drawOffset = gmesa->readOffset = gmesa->driScreen->fbHeight * gmesa->driScreen->fbWidth * gmesa->gammaScreen->cpp;
1058       break;
1059    }
1060 }
1061
1062 static void gammaDDReadBuffer( GLcontext *ctx, GLenum mode )
1063 {
1064    /* XXX anything? */
1065 }
1066
1067 /* =============================================================
1068  * Window position and viewport transformation
1069  */
1070
1071 void gammaUpdateWindow( GLcontext *ctx )
1072 {
1073    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
1074    __DRIdrawablePrivate *dPriv = gmesa->driDrawable;
1075    GLfloat xoffset = (GLfloat)dPriv->x;
1076    GLfloat yoffset = gmesa->driScreen->fbHeight - (GLfloat)dPriv->y - dPriv->h;
1077    const GLfloat *v = ctx->Viewport._WindowMap.m;
1078
1079    GLfloat sx = v[MAT_SX];
1080    GLfloat tx = v[MAT_TX] + xoffset;
1081    GLfloat sy = v[MAT_SY];
1082    GLfloat ty = v[MAT_TY] + yoffset;
1083    GLfloat sz = v[MAT_SZ] * gmesa->depth_scale;
1084    GLfloat tz = v[MAT_TZ] * gmesa->depth_scale;
1085
1086    gmesa->dirty |= GAMMA_UPLOAD_VIEWPORT;
1087
1088    gmesa->ViewportScaleX = sx;
1089    gmesa->ViewportScaleY = sy;
1090    gmesa->ViewportScaleZ = sz;
1091    gmesa->ViewportOffsetX = tx;
1092    gmesa->ViewportOffsetY = ty;
1093    gmesa->ViewportOffsetZ = tz;
1094 }
1095
1096
1097
1098 static void gammaDDViewport( GLcontext *ctx, GLint x, GLint y,
1099                             GLsizei width, GLsizei height )
1100 {
1101    gammaUpdateWindow( ctx );
1102 }
1103
1104 static void gammaDDDepthRange( GLcontext *ctx, GLclampd nearval,
1105                               GLclampd farval )
1106 {
1107    gammaUpdateWindow( ctx );
1108 }
1109
1110 void gammaUpdateViewportOffset( GLcontext *ctx )
1111 {
1112    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
1113    __DRIdrawablePrivate *dPriv = gmesa->driDrawable;
1114    GLfloat xoffset = (GLfloat)dPriv->x;
1115    GLfloat yoffset = gmesa->driScreen->fbHeight - (GLfloat)dPriv->y - dPriv->h;
1116    const GLfloat *v = ctx->Viewport._WindowMap.m;
1117
1118    GLfloat tx = v[MAT_TX] + xoffset;
1119    GLfloat ty = v[MAT_TY] + yoffset;
1120
1121    if ( gmesa->ViewportOffsetX != tx ||
1122         gmesa->ViewportOffsetY != ty )
1123    {
1124       gmesa->ViewportOffsetX = tx;
1125       gmesa->ViewportOffsetY = ty;
1126
1127       gmesa->new_state |= GAMMA_NEW_WINDOW;
1128    }
1129
1130    gmesa->new_state |= GAMMA_NEW_CLIP;
1131 }
1132
1133 #if 0
1134 /*
1135  * Matrix
1136  */
1137
1138 static void gammaLoadHWMatrix(GLcontext *ctx)
1139 {
1140     gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
1141     const GLfloat *m;
1142
1143     gmesa->TransformMode &= ~XM_XformTexture;
1144
1145     switch (ctx->Transform.MatrixMode) {
1146     case GL_MODELVIEW:
1147         gmesa->TransformMode |= XM_UseModelViewMatrix;
1148         m = ctx->ModelviewMatrixStack.Top->m;
1149         CHECK_DMA_BUFFER(gmesa, 16);
1150         WRITEF(gmesa->buf, ModelViewMatrix0,  m[0]);
1151         WRITEF(gmesa->buf, ModelViewMatrix1,  m[1]);
1152         WRITEF(gmesa->buf, ModelViewMatrix2,  m[2]);
1153         WRITEF(gmesa->buf, ModelViewMatrix3,  m[3]);
1154         WRITEF(gmesa->buf, ModelViewMatrix4,  m[4]);
1155         WRITEF(gmesa->buf, ModelViewMatrix5,  m[5]);
1156         WRITEF(gmesa->buf, ModelViewMatrix6,  m[6]);
1157         WRITEF(gmesa->buf, ModelViewMatrix7,  m[7]);
1158         WRITEF(gmesa->buf, ModelViewMatrix8,  m[8]);
1159         WRITEF(gmesa->buf, ModelViewMatrix9,  m[9]);
1160         WRITEF(gmesa->buf, ModelViewMatrix10, m[10]);
1161         WRITEF(gmesa->buf, ModelViewMatrix11, m[11]);
1162         WRITEF(gmesa->buf, ModelViewMatrix12, m[12]);
1163         WRITEF(gmesa->buf, ModelViewMatrix13, m[13]);
1164         WRITEF(gmesa->buf, ModelViewMatrix14, m[14]);
1165         WRITEF(gmesa->buf, ModelViewMatrix15, m[15]);
1166         break;
1167     case GL_PROJECTION:
1168         m = ctx->ProjectionMatrixStack.Top->m;
1169         CHECK_DMA_BUFFER(gmesa, 16);
1170         WRITEF(gmesa->buf, ModelViewProjectionMatrix0, m[0]);
1171         WRITEF(gmesa->buf, ModelViewProjectionMatrix1, m[1]);
1172         WRITEF(gmesa->buf, ModelViewProjectionMatrix2, m[2]);
1173         WRITEF(gmesa->buf, ModelViewProjectionMatrix3, m[3]);
1174         WRITEF(gmesa->buf, ModelViewProjectionMatrix4, m[4]);
1175         WRITEF(gmesa->buf, ModelViewProjectionMatrix5, m[5]);
1176         WRITEF(gmesa->buf, ModelViewProjectionMatrix6, m[6]);
1177         WRITEF(gmesa->buf, ModelViewProjectionMatrix7, m[7]);
1178         WRITEF(gmesa->buf, ModelViewProjectionMatrix8, m[8]);
1179         WRITEF(gmesa->buf, ModelViewProjectionMatrix9, m[9]);
1180         WRITEF(gmesa->buf, ModelViewProjectionMatrix10, m[10]);
1181         WRITEF(gmesa->buf, ModelViewProjectionMatrix11, m[11]);
1182         WRITEF(gmesa->buf, ModelViewProjectionMatrix12, m[12]);
1183         WRITEF(gmesa->buf, ModelViewProjectionMatrix13, m[13]);
1184         WRITEF(gmesa->buf, ModelViewProjectionMatrix14, m[14]);
1185         WRITEF(gmesa->buf, ModelViewProjectionMatrix15, m[15]);
1186         break;
1187     case GL_TEXTURE:
1188         m = ctx->TextureMatrixStack[0].Top->m;
1189         CHECK_DMA_BUFFER(gmesa, 16);
1190         gmesa->TransformMode |= XM_XformTexture;
1191         WRITEF(gmesa->buf, TextureMatrix0,  m[0]);
1192         WRITEF(gmesa->buf, TextureMatrix1,  m[1]);
1193         WRITEF(gmesa->buf, TextureMatrix2,  m[2]);
1194         WRITEF(gmesa->buf, TextureMatrix3,  m[3]);
1195         WRITEF(gmesa->buf, TextureMatrix4,  m[4]);
1196         WRITEF(gmesa->buf, TextureMatrix5,  m[5]);
1197         WRITEF(gmesa->buf, TextureMatrix6,  m[6]);
1198         WRITEF(gmesa->buf, TextureMatrix7,  m[7]);
1199         WRITEF(gmesa->buf, TextureMatrix8,  m[8]);
1200         WRITEF(gmesa->buf, TextureMatrix9,  m[9]);
1201         WRITEF(gmesa->buf, TextureMatrix10,  m[10]);
1202         WRITEF(gmesa->buf, TextureMatrix11,  m[11]);
1203         WRITEF(gmesa->buf, TextureMatrix12,  m[12]);
1204         WRITEF(gmesa->buf, TextureMatrix13,  m[13]);
1205         WRITEF(gmesa->buf, TextureMatrix14,  m[14]);
1206         WRITEF(gmesa->buf, TextureMatrix15,  m[15]);
1207         break;
1208
1209     default:
1210         /* ERROR!!! -- how did this happen? */
1211         break;
1212     }
1213
1214     gmesa->dirty |= GAMMA_UPLOAD_TRANSFORM;
1215 }
1216 #endif
1217
1218 /* =============================================================
1219  * State enable/disable
1220  */
1221
1222 static void gammaDDEnable( GLcontext *ctx, GLenum cap, GLboolean state )
1223 {
1224    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
1225
1226    switch ( cap ) {
1227    case GL_ALPHA_TEST:
1228    case GL_BLEND:
1229       FLUSH_BATCH( gmesa );
1230       gmesa->new_state |= GAMMA_NEW_ALPHA;
1231       break;
1232
1233    case GL_CULL_FACE:
1234       FLUSH_BATCH( gmesa );
1235       gmesa->new_state |= GAMMA_NEW_CULL;
1236       break;
1237
1238    case GL_DEPTH_TEST:
1239       FLUSH_BATCH( gmesa );
1240       gmesa->new_state |= GAMMA_NEW_DEPTH;
1241       break;
1242
1243    case GL_DITHER:
1244       do {
1245          uint32_t d = gmesa->DitherMode;
1246          FLUSH_BATCH( gmesa );
1247
1248          if ( state ) {
1249             d |=  DM_DitherEnable;
1250          } else {
1251             d &= ~DM_DitherEnable;
1252          }
1253
1254          if ( gmesa->DitherMode != d ) {
1255             gmesa->DitherMode = d;
1256             gmesa->dirty |= GAMMA_UPLOAD_DITHER;
1257          }
1258       } while (0);
1259       break;
1260
1261 #if 0
1262    case GL_FOG:
1263       FLUSH_BATCH( gmesa );
1264       gmesa->new_state |= GAMMA_NEW_FOG;
1265       break;
1266 #endif
1267
1268    case GL_INDEX_LOGIC_OP:
1269    case GL_COLOR_LOGIC_OP:
1270       FLUSH_BATCH( gmesa );
1271       gmesa->new_state |= GAMMA_NEW_LOGICOP;
1272       break;
1273
1274 #if ENABLELIGHTING
1275    case GL_LIGHTING:
1276       do {
1277          uint32_t l = gmesa->LightingMode;
1278          FLUSH_BATCH( gmesa );
1279
1280          if ( state ) {
1281             l |=  LightingModeEnable;
1282          } else {
1283             l &= ~LightingModeEnable;
1284          }
1285
1286          if ( gmesa->LightingMode != l ) {
1287             gmesa->LightingMode = l;
1288             gmesa->dirty |= GAMMA_UPLOAD_LIGHT;
1289          }
1290       } while (0);
1291       break;
1292
1293    case GL_COLOR_MATERIAL:
1294       do {
1295          uint32_t m = gmesa->MaterialMode;
1296          FLUSH_BATCH( gmesa );
1297
1298          if ( state ) {
1299             m |=  MaterialModeEnable;
1300          } else {
1301             m &= ~MaterialModeEnable;
1302          }
1303
1304          if ( gmesa->MaterialMode != m ) {
1305             gmesa->MaterialMode = m;
1306             gmesa->dirty |= GAMMA_UPLOAD_LIGHT;
1307          }
1308       } while (0);
1309       break;
1310 #endif
1311
1312    case GL_LINE_SMOOTH:
1313       FLUSH_BATCH( gmesa );
1314       if ( state ) {
1315          gmesa->AntialiasMode |= AntialiasModeEnable;
1316          gmesa->LineMode |= LM_AntialiasEnable;
1317       } else {
1318          gmesa->AntialiasMode &= ~AntialiasModeEnable;
1319          gmesa->LineMode &= ~LM_AntialiasEnable;
1320       }
1321       gmesa->dirty |= GAMMA_UPLOAD_LINEMODE;
1322       break;
1323
1324    case GL_POINT_SMOOTH:
1325       FLUSH_BATCH( gmesa );
1326       if ( state ) {
1327          gmesa->AntialiasMode |= AntialiasModeEnable;
1328          gmesa->PointMode |= PM_AntialiasEnable;
1329       } else {
1330          gmesa->AntialiasMode &= ~AntialiasModeEnable;
1331          gmesa->PointMode &= ~PM_AntialiasEnable;
1332       }
1333       gmesa->dirty |= GAMMA_UPLOAD_POINTMODE;
1334       break;
1335
1336    case GL_POLYGON_SMOOTH:
1337       FLUSH_BATCH( gmesa );
1338       if ( state ) {
1339          gmesa->AntialiasMode |= AntialiasModeEnable;
1340          gmesa->TriangleMode |= TM_AntialiasEnable;
1341       } else {
1342          gmesa->AntialiasMode &= ~AntialiasModeEnable;
1343          gmesa->TriangleMode &= ~TM_AntialiasEnable;
1344       }
1345       gmesa->dirty |= GAMMA_UPLOAD_TRIMODE;
1346       break;
1347
1348    case GL_SCISSOR_TEST:
1349       FLUSH_BATCH( gmesa );
1350       gmesa->new_state |= GAMMA_NEW_CLIP;
1351       break;
1352
1353    case GL_POLYGON_OFFSET_FILL:
1354    case GL_POLYGON_OFFSET_POINT:
1355    case GL_POLYGON_OFFSET_LINE:
1356       FLUSH_BATCH( gmesa );
1357       gmesa->new_state |= GAMMA_NEW_POLYGON;
1358       break;
1359
1360    case GL_LINE_STIPPLE:
1361       FLUSH_BATCH( gmesa );
1362       if ( state )
1363          gmesa->LineMode |= LM_StippleEnable;
1364       else
1365          gmesa->LineMode &= ~LM_StippleEnable;
1366       gmesa->dirty |= GAMMA_UPLOAD_LINEMODE;
1367       break;
1368
1369    case GL_POLYGON_STIPPLE:
1370       FLUSH_BATCH( gmesa );
1371       gmesa->new_state |= GAMMA_NEW_STIPPLE;
1372       break;
1373
1374    default:
1375       return;
1376    }
1377 }
1378
1379 /* =============================================================
1380  * State initialization, management
1381  */
1382
1383
1384 /*
1385  * Load the current context's state into the hardware.
1386  *
1387  * NOTE: Be VERY careful about ensuring the context state is marked for
1388  * upload, the only place it shouldn't be uploaded is when the setup
1389  * state has changed in ReducedPrimitiveChange as this comes right after
1390  * a state update.
1391  *
1392  * Blits of any type should always upload the context and masks after
1393  * they are done.
1394  */
1395 void gammaEmitHwState( gammaContextPtr gmesa )
1396 {
1397     if (!gmesa->driDrawable) return;
1398
1399     if (!gmesa->dirty) return;
1400
1401 #ifdef DO_VALIDATE
1402     /* Flush any partially filled buffers */
1403     FLUSH_DMA_BUFFER(gmesa);
1404
1405     DRM_SPINLOCK(&gmesa->driScreen->pSAREA->drawable_lock,
1406                  gmesa->driScreen->drawLockID);
1407     VALIDATE_DRAWABLE_INFO_NO_LOCK(gmesa);
1408 #endif
1409
1410     if (gmesa->dirty & GAMMA_UPLOAD_VIEWPORT) {
1411         gmesa->dirty &= ~GAMMA_UPLOAD_VIEWPORT;
1412         CHECK_DMA_BUFFER(gmesa, 6);
1413         WRITEF(gmesa->buf, ViewPortOffsetX, gmesa->ViewportOffsetX);
1414         WRITEF(gmesa->buf, ViewPortOffsetY, gmesa->ViewportOffsetY);
1415         WRITEF(gmesa->buf, ViewPortOffsetZ, gmesa->ViewportOffsetZ);
1416         WRITEF(gmesa->buf, ViewPortScaleX, gmesa->ViewportScaleX);
1417         WRITEF(gmesa->buf, ViewPortScaleY, gmesa->ViewportScaleY);
1418         WRITEF(gmesa->buf, ViewPortScaleZ, gmesa->ViewportScaleZ);
1419     }
1420     if ( (gmesa->dirty & GAMMA_UPLOAD_POINTMODE) ||
1421          (gmesa->dirty & GAMMA_UPLOAD_LINEMODE) ||
1422          (gmesa->dirty & GAMMA_UPLOAD_TRIMODE) ) {
1423         CHECK_DMA_BUFFER(gmesa, 1);
1424         WRITE(gmesa->buf, AntialiasMode, gmesa->AntialiasMode);
1425     }
1426     if (gmesa->dirty & GAMMA_UPLOAD_POINTMODE) {
1427         gmesa->dirty &= ~GAMMA_UPLOAD_POINTMODE;
1428         CHECK_DMA_BUFFER(gmesa, 1);
1429         WRITE(gmesa->buf, PointMode, gmesa->PointMode);
1430     }
1431     if (gmesa->dirty & GAMMA_UPLOAD_LINEMODE) {
1432         gmesa->dirty &= ~GAMMA_UPLOAD_LINEMODE;
1433         CHECK_DMA_BUFFER(gmesa, 2);
1434         WRITE(gmesa->buf, LineMode, gmesa->LineMode);
1435         WRITE(gmesa->buf, LineStippleMode, gmesa->LineMode);
1436     }
1437     if (gmesa->dirty & GAMMA_UPLOAD_TRIMODE) {
1438         gmesa->dirty &= ~GAMMA_UPLOAD_TRIMODE;
1439         CHECK_DMA_BUFFER(gmesa, 1);
1440         WRITE(gmesa->buf, TriangleMode, gmesa->TriangleMode);
1441     }
1442     if (gmesa->dirty & GAMMA_UPLOAD_FOG) {
1443         GLchan c[3], col;
1444         UNCLAMPED_FLOAT_TO_RGB_CHAN( c, gmesa->glCtx->Fog.Color );
1445         col = gammaPackColor(4, c[0], c[1], c[2], 0);
1446         gmesa->dirty &= ~GAMMA_UPLOAD_FOG;
1447         CHECK_DMA_BUFFER(gmesa, 5);
1448 #if 0
1449         WRITE(gmesa->buf, FogMode, gmesa->FogMode);
1450         WRITE(gmesa->buf, FogColor, col);
1451         WRITEF(gmesa->buf, FStart, gmesa->glCtx->Fog.Start);
1452 #endif
1453         WRITEF(gmesa->buf, FogEnd, gmesa->glCtx->Fog.End);
1454         WRITEF(gmesa->buf, FogDensity, gmesa->glCtx->Fog.Density);
1455         WRITEF(gmesa->buf, FogScale,
1456                 1.0f/(gmesa->glCtx->Fog.End - gmesa->glCtx->Fog.Start));
1457     }
1458     if (gmesa->dirty & GAMMA_UPLOAD_DITHER) {
1459         gmesa->dirty &= ~GAMMA_UPLOAD_DITHER;
1460         CHECK_DMA_BUFFER(gmesa, 1);
1461         WRITE(gmesa->buf, DitherMode, gmesa->DitherMode);
1462     }
1463     if (gmesa->dirty & GAMMA_UPLOAD_LOGICOP) {
1464         gmesa->dirty &= ~GAMMA_UPLOAD_LOGICOP;
1465         CHECK_DMA_BUFFER(gmesa, 1);
1466         WRITE(gmesa->buf, LogicalOpMode, gmesa->LogicalOpMode);
1467     }
1468     if (gmesa->dirty & GAMMA_UPLOAD_CLIP) {
1469         gmesa->dirty &= ~GAMMA_UPLOAD_CLIP;
1470         CHECK_DMA_BUFFER(gmesa, 3);
1471         WRITE(gmesa->buf, ScissorMinXY, gmesa->ScissorMinXY);
1472         WRITE(gmesa->buf, ScissorMaxXY, gmesa->ScissorMaxXY);
1473         WRITE(gmesa->buf, ScissorMode, gmesa->ScissorMode);
1474     }
1475     if (gmesa->dirty & GAMMA_UPLOAD_MASKS) {
1476         gmesa->dirty &= ~GAMMA_UPLOAD_MASKS;
1477         CHECK_DMA_BUFFER(gmesa, 1);
1478         WRITE(gmesa->buf, FBHardwareWriteMask, gmesa->FBHardwareWriteMask);
1479     }
1480     if (gmesa->dirty & GAMMA_UPLOAD_ALPHA) {
1481         gmesa->dirty &= ~GAMMA_UPLOAD_ALPHA;
1482         CHECK_DMA_BUFFER(gmesa, 1);
1483         WRITE(gmesa->buf, AlphaTestMode, gmesa->AlphaTestMode);
1484     }
1485     if (gmesa->dirty & GAMMA_UPLOAD_BLEND) {
1486         gmesa->dirty &= ~GAMMA_UPLOAD_BLEND;
1487         CHECK_DMA_BUFFER(gmesa, 1);
1488         WRITE(gmesa->buf, AlphaBlendMode, gmesa->AlphaBlendMode);
1489     }
1490     CHECK_DMA_BUFFER(gmesa, 1);
1491     if (gmesa->glCtx->Color.BlendEnabled || gmesa->glCtx->Color.AlphaEnabled) {
1492         WRITE(gmesa->buf, FBReadMode, gmesa->FBReadMode | gmesa->AB_FBReadMode_Save);
1493     } else {
1494         WRITE(gmesa->buf, FBReadMode, gmesa->FBReadMode);
1495     }
1496     if (gmesa->dirty & GAMMA_UPLOAD_LIGHT) {
1497         gmesa->dirty &= ~GAMMA_UPLOAD_LIGHT;
1498         CHECK_DMA_BUFFER(gmesa, 2);
1499         WRITE(gmesa->buf, LightingMode, gmesa->LightingMode);
1500         WRITE(gmesa->buf, MaterialMode, gmesa->MaterialMode);
1501     }
1502     if (gmesa->dirty & GAMMA_UPLOAD_SHADE) {
1503         gmesa->dirty &= ~GAMMA_UPLOAD_SHADE;
1504         CHECK_DMA_BUFFER(gmesa, 1);
1505         WRITE(gmesa->buf, ColorDDAMode, gmesa->ColorDDAMode);
1506     }
1507     if (gmesa->dirty & GAMMA_UPLOAD_POLYGON) {
1508         gmesa->dirty &= ~GAMMA_UPLOAD_POLYGON;
1509         CHECK_DMA_BUFFER(gmesa, 2);
1510         WRITEF(gmesa->buf, PolygonOffsetBias, gmesa->glCtx->Polygon.OffsetUnits);
1511         WRITEF(gmesa->buf, PolygonOffsetFactor, gmesa->glCtx->Polygon.OffsetFactor);
1512     }
1513     if (gmesa->dirty & GAMMA_UPLOAD_STIPPLE) {
1514         gmesa->dirty &= ~GAMMA_UPLOAD_STIPPLE;
1515         CHECK_DMA_BUFFER(gmesa, 33);
1516         WRITE(gmesa->buf, AreaStippleMode, gmesa->AreaStippleMode);
1517         WRITE(gmesa->buf, AreaStipplePattern0, gmesa->glCtx->PolygonStipple[0]);
1518         WRITE(gmesa->buf, AreaStipplePattern1, gmesa->glCtx->PolygonStipple[1]);
1519         WRITE(gmesa->buf, AreaStipplePattern2, gmesa->glCtx->PolygonStipple[2]);
1520         WRITE(gmesa->buf, AreaStipplePattern3, gmesa->glCtx->PolygonStipple[3]);
1521         WRITE(gmesa->buf, AreaStipplePattern4, gmesa->glCtx->PolygonStipple[4]);
1522         WRITE(gmesa->buf, AreaStipplePattern5, gmesa->glCtx->PolygonStipple[5]);
1523         WRITE(gmesa->buf, AreaStipplePattern6, gmesa->glCtx->PolygonStipple[6]);
1524         WRITE(gmesa->buf, AreaStipplePattern7, gmesa->glCtx->PolygonStipple[7]);
1525         WRITE(gmesa->buf, AreaStipplePattern8, gmesa->glCtx->PolygonStipple[8]);
1526         WRITE(gmesa->buf, AreaStipplePattern9, gmesa->glCtx->PolygonStipple[9]);
1527         WRITE(gmesa->buf, AreaStipplePattern10, gmesa->glCtx->PolygonStipple[10]);
1528         WRITE(gmesa->buf, AreaStipplePattern11, gmesa->glCtx->PolygonStipple[11]);
1529         WRITE(gmesa->buf, AreaStipplePattern12, gmesa->glCtx->PolygonStipple[12]);
1530         WRITE(gmesa->buf, AreaStipplePattern13, gmesa->glCtx->PolygonStipple[13]);
1531         WRITE(gmesa->buf, AreaStipplePattern14, gmesa->glCtx->PolygonStipple[14]);
1532         WRITE(gmesa->buf, AreaStipplePattern15, gmesa->glCtx->PolygonStipple[15]);
1533         WRITE(gmesa->buf, AreaStipplePattern16, gmesa->glCtx->PolygonStipple[16]);
1534         WRITE(gmesa->buf, AreaStipplePattern17, gmesa->glCtx->PolygonStipple[17]);
1535         WRITE(gmesa->buf, AreaStipplePattern18, gmesa->glCtx->PolygonStipple[18]);
1536         WRITE(gmesa->buf, AreaStipplePattern19, gmesa->glCtx->PolygonStipple[19]);
1537         WRITE(gmesa->buf, AreaStipplePattern20, gmesa->glCtx->PolygonStipple[20]);
1538         WRITE(gmesa->buf, AreaStipplePattern21, gmesa->glCtx->PolygonStipple[21]);
1539         WRITE(gmesa->buf, AreaStipplePattern22, gmesa->glCtx->PolygonStipple[22]);
1540         WRITE(gmesa->buf, AreaStipplePattern23, gmesa->glCtx->PolygonStipple[23]);
1541         WRITE(gmesa->buf, AreaStipplePattern24, gmesa->glCtx->PolygonStipple[24]);
1542         WRITE(gmesa->buf, AreaStipplePattern25, gmesa->glCtx->PolygonStipple[25]);
1543         WRITE(gmesa->buf, AreaStipplePattern26, gmesa->glCtx->PolygonStipple[26]);
1544         WRITE(gmesa->buf, AreaStipplePattern27, gmesa->glCtx->PolygonStipple[27]);
1545         WRITE(gmesa->buf, AreaStipplePattern28, gmesa->glCtx->PolygonStipple[28]);
1546         WRITE(gmesa->buf, AreaStipplePattern29, gmesa->glCtx->PolygonStipple[29]);
1547         WRITE(gmesa->buf, AreaStipplePattern30, gmesa->glCtx->PolygonStipple[30]);
1548         WRITE(gmesa->buf, AreaStipplePattern31, gmesa->glCtx->PolygonStipple[31]);
1549     }
1550     if (gmesa->dirty & GAMMA_UPLOAD_DEPTH) {
1551         gmesa->dirty &= ~GAMMA_UPLOAD_DEPTH;
1552         CHECK_DMA_BUFFER(gmesa, 4);
1553         WRITE(gmesa->buf, DepthMode,  gmesa->DepthMode);
1554         WRITE(gmesa->buf, DeltaMode,  gmesa->DeltaMode);
1555         WRITE(gmesa->buf, GLINTWindow,gmesa->Window | (gmesa->FrameCount << 9));
1556         WRITE(gmesa->buf, LBReadMode, gmesa->LBReadMode);
1557     }
1558     if (gmesa->dirty & GAMMA_UPLOAD_GEOMETRY) {
1559         gmesa->dirty &= ~GAMMA_UPLOAD_GEOMETRY;
1560         CHECK_DMA_BUFFER(gmesa, 1);
1561         WRITE(gmesa->buf, GeometryMode, gmesa->GeometryMode);
1562     }
1563     if (gmesa->dirty & GAMMA_UPLOAD_TRANSFORM) {
1564         gmesa->dirty &= ~GAMMA_UPLOAD_TRANSFORM;
1565         CHECK_DMA_BUFFER(gmesa, 1);
1566         WRITE(gmesa->buf, TransformMode, gmesa->TransformMode);
1567     }
1568     if (gmesa->dirty & GAMMA_UPLOAD_TEX0) {
1569         gammaTextureObjectPtr curTex = gmesa->CurrentTexObj[0];
1570         gmesa->dirty &= ~GAMMA_UPLOAD_TEX0;
1571         if (curTex) {
1572         CHECK_DMA_BUFFER(gmesa, 21);
1573         WRITE(gmesa->buf, GeometryMode, gmesa->GeometryMode | GM_TextureEnable);
1574         WRITE(gmesa->buf, DeltaMode, gmesa->DeltaMode | DM_TextureEnable);
1575         WRITE(gmesa->buf, TextureAddressMode, curTex->TextureAddressMode);
1576         WRITE(gmesa->buf, TextureReadMode, curTex->TextureReadMode);
1577         WRITE(gmesa->buf, TextureColorMode, curTex->TextureColorMode);
1578         WRITE(gmesa->buf, TextureFilterMode, curTex->TextureFilterMode);
1579         WRITE(gmesa->buf, TextureFormat, curTex->TextureFormat);
1580         WRITE(gmesa->buf, GLINTBorderColor, curTex->TextureBorderColor);
1581         WRITE(gmesa->buf, TxBaseAddr0, curTex->TextureBaseAddr[0]);
1582         WRITE(gmesa->buf, TxBaseAddr1, curTex->TextureBaseAddr[1]);
1583         WRITE(gmesa->buf, TxBaseAddr2, curTex->TextureBaseAddr[2]);
1584         WRITE(gmesa->buf, TxBaseAddr3, curTex->TextureBaseAddr[3]);
1585         WRITE(gmesa->buf, TxBaseAddr4, curTex->TextureBaseAddr[4]);
1586         WRITE(gmesa->buf, TxBaseAddr5, curTex->TextureBaseAddr[5]);
1587         WRITE(gmesa->buf, TxBaseAddr6, curTex->TextureBaseAddr[6]);
1588         WRITE(gmesa->buf, TxBaseAddr7, curTex->TextureBaseAddr[7]);
1589         WRITE(gmesa->buf, TxBaseAddr8, curTex->TextureBaseAddr[8]);
1590         WRITE(gmesa->buf, TxBaseAddr9, curTex->TextureBaseAddr[9]);
1591         WRITE(gmesa->buf, TxBaseAddr10, curTex->TextureBaseAddr[10]);
1592         WRITE(gmesa->buf, TxBaseAddr11, curTex->TextureBaseAddr[11]);
1593         WRITE(gmesa->buf, TxBaseAddr12, curTex->TextureBaseAddr[12]);
1594         WRITE(gmesa->buf, TextureCacheControl, (TCC_Enable | TCC_Invalidate));
1595         } else {
1596         CHECK_DMA_BUFFER(gmesa, 6);
1597         WRITE(gmesa->buf, GeometryMode, gmesa->GeometryMode);
1598         WRITE(gmesa->buf, DeltaMode, gmesa->DeltaMode);
1599         WRITE(gmesa->buf, TextureAddressMode, TextureAddressModeDisable);
1600         WRITE(gmesa->buf, TextureReadMode, TextureReadModeDisable);
1601         WRITE(gmesa->buf, TextureFilterMode, TextureFilterModeDisable);
1602         WRITE(gmesa->buf, TextureColorMode, TextureColorModeDisable);
1603         }
1604     }
1605 #ifdef DO_VALIDATE
1606     PROCESS_DMA_BUFFER_TOP_HALF(gmesa);
1607
1608     DRM_SPINUNLOCK(&gmesa->driScreen->pSAREA->drawable_lock,
1609                    gmesa->driScreen->drawLockID);
1610     VALIDATE_DRAWABLE_INFO_NO_LOCK_POST(gmesa);
1611
1612     PROCESS_DMA_BUFFER_BOTTOM_HALF(gmesa);
1613 #endif
1614 }
1615
1616 void gammaDDUpdateHWState( GLcontext *ctx )
1617 {
1618    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
1619    int new_state = gmesa->new_state;
1620
1621    if ( new_state )
1622    {
1623       FLUSH_BATCH( gmesa );
1624
1625       gmesa->new_state = 0;
1626
1627       /* Update the various parts of the context's state.
1628        */
1629       if ( new_state & GAMMA_NEW_ALPHA )
1630          gammaUpdateAlphaMode( ctx );
1631
1632       if ( new_state & GAMMA_NEW_DEPTH )
1633          gammaUpdateZMode( ctx );
1634
1635       if ( new_state & GAMMA_NEW_FOG )
1636          gammaUpdateFogAttrib( ctx );
1637
1638       if ( new_state & GAMMA_NEW_CLIP )
1639          gammaUpdateClipping( ctx );
1640
1641       if ( new_state & GAMMA_NEW_POLYGON )
1642          gammaUpdatePolygon( ctx );
1643
1644       if ( new_state & GAMMA_NEW_CULL )
1645          gammaUpdateCull( ctx );
1646
1647       if ( new_state & GAMMA_NEW_MASKS )
1648          gammaUpdateMasks( ctx );
1649
1650       if ( new_state & GAMMA_NEW_WINDOW )
1651          gammaUpdateWindow( ctx );
1652
1653       if ( new_state & GAMMA_NEW_STIPPLE )
1654          gammaUpdateStipple( ctx );
1655    }
1656
1657    /* HACK ! */
1658
1659    gammaEmitHwState( gmesa );
1660 }
1661
1662
1663 static void gammaDDUpdateState( GLcontext *ctx, GLuint new_state )
1664 {
1665    _swrast_InvalidateState( ctx, new_state );
1666    _swsetup_InvalidateState( ctx, new_state );
1667    _ac_InvalidateState( ctx, new_state );
1668    _tnl_InvalidateState( ctx, new_state );
1669    GAMMA_CONTEXT(ctx)->new_gl_state |= new_state;
1670 }
1671
1672
1673 /* Initialize the context's hardware state.
1674  */
1675 void gammaDDInitState( gammaContextPtr gmesa )
1676 {
1677    gmesa->new_state = 0;
1678 }
1679
1680 /* Initialize the driver's state functions.
1681  */
1682 void gammaDDInitStateFuncs( GLcontext *ctx )
1683 {
1684    ctx->Driver.UpdateState              = gammaDDUpdateState;
1685
1686    ctx->Driver.Clear                    = gammaDDClear;
1687    ctx->Driver.ClearIndex               = NULL;
1688    ctx->Driver.ClearColor               = gammaDDClearColor;
1689    ctx->Driver.DrawBuffer               = gammaDDDrawBuffer;
1690    ctx->Driver.ReadBuffer               = gammaDDReadBuffer;
1691
1692    ctx->Driver.IndexMask                = NULL;
1693    ctx->Driver.ColorMask                = gammaDDColorMask;
1694
1695    ctx->Driver.AlphaFunc                = gammaDDAlphaFunc;
1696    ctx->Driver.BlendEquationSeparate    = gammaDDBlendEquationSeparate;
1697    ctx->Driver.BlendFuncSeparate        = gammaDDBlendFuncSeparate;
1698    ctx->Driver.ClearDepth               = gammaDDClearDepth;
1699    ctx->Driver.CullFace                 = gammaDDCullFace;
1700    ctx->Driver.FrontFace                = gammaDDFrontFace;
1701    ctx->Driver.DepthFunc                = gammaDDDepthFunc;
1702    ctx->Driver.DepthMask                = gammaDDDepthMask;
1703    ctx->Driver.DepthRange               = gammaDDDepthRange;
1704    ctx->Driver.Enable                   = gammaDDEnable;
1705    ctx->Driver.Finish                   = gammaDDFinish;
1706    ctx->Driver.Flush                    = gammaDDFlush;
1707 #if 0
1708    ctx->Driver.Fogfv                    = gammaDDFogfv;
1709 #endif
1710    ctx->Driver.Hint                     = NULL;
1711    ctx->Driver.LineWidth                = gammaDDLineWidth;
1712    ctx->Driver.LineStipple              = gammaDDLineStipple;
1713 #if ENABLELIGHTING
1714    ctx->Driver.Lightfv                  = gammaDDLightfv;
1715    ctx->Driver.LightModelfv             = gammaDDLightModelfv;
1716 #endif
1717    ctx->Driver.LogicOpcode              = gammaDDLogicalOpcode;
1718    ctx->Driver.PointSize                = gammaDDPointSize;
1719    ctx->Driver.PolygonMode              = gammaDDPolygonMode;
1720    ctx->Driver.PolygonStipple           = gammaDDPolygonStipple;
1721    ctx->Driver.Scissor                  = gammaDDScissor;
1722    ctx->Driver.ShadeModel               = gammaDDShadeModel;
1723    ctx->Driver.ClearStencil             = NULL;
1724    ctx->Driver.StencilFunc              = NULL;
1725    ctx->Driver.StencilMask              = NULL;
1726    ctx->Driver.StencilOp                = NULL;
1727    ctx->Driver.Viewport                 = gammaDDViewport;
1728 }