src/mesa/drivers/dri/sis/sis_state.c

   1 /**************************************************************************
   2
   3 Copyright 2000 Silicon Integrated Systems Corp, Inc., HsinChu, Taiwan.
   4 Copyright 2003 Eric Anholt
   5 All Rights Reserved.
   6
   7 Permission is hereby granted, free of charge, to any person obtaining a
   8 copy of this software and associated documentation files (the "Software"),
   9 to deal in the Software without restriction, including without limitation
  10 on the rights to use, copy, modify, merge, publish, distribute, sub
  11 license, and/or sell copies of the Software, and to permit persons to whom
  12 the Software is furnished to do so, subject to the following conditions:
  13
  14 The above copyright notice and this permission notice (including the next
  15 paragraph) shall be included in all copies or substantial portions of the
  16 Software.
  17
  18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20 FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  21 ERIC ANHOLT OR SILICON INTEGRATED SYSTEMS CORP BE LIABLE FOR ANY CLAIM,
  22 DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  23 OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  24 USE OR OTHER DEALINGS IN THE SOFTWARE.
  25
  26 **************************************************************************/
  27 /* $XFree86: xc/lib/GL/mesa/src/drv/sis/sis_ctx.c,v 1.3 2000/09/26 15:56:48 tsi Exp $ */
  28
  29 /*
  30  * Authors:
  31  *    Sung-Ching Lin <sclin@sis.com.tw>
  32  *    Eric Anholt <anholt@FreeBSD.org>
  33  */
  34
  35 #include "sis_context.h"
  36 #include "sis_state.h"
  37 #include "sis_tris.h"
  38 #include "sis_lock.h"
  39 #include "sis_tex.h"
  40
  41 #include "main/context.h"
  42 #include "main/enums.h"
  43 #include "main/colormac.h"
  44 #include "swrast/swrast.h"
  45 #include "vbo/vbo.h"
  46 #include "tnl/tnl.h"
  47 #include "swrast_setup/swrast_setup.h"
  48
  49 #include "tnl/t_pipeline.h"
  50
  51 /* =============================================================
  52  * Alpha blending
  53  */
  54
  55 static void
  56 sisDDAlphaFunc( GLcontext * ctx, GLenum func, GLfloat ref )
  57 {
  58    sisContextPtr smesa = SIS_CONTEXT(ctx);
  59    GLubyte refbyte;
  60
  61    __GLSiSHardware *prev = &smesa->prev;
  62    __GLSiSHardware *current = &smesa->current;
  63
  64    CLAMPED_FLOAT_TO_UBYTE(refbyte, ref);
  65    current->hwAlpha = refbyte << 16;
  66
  67    /* Alpha Test function */
  68    switch (func)
  69    {
  70    case GL_NEVER:
  71       current->hwAlpha |= SiS_ALPHA_NEVER;
  72       break;
  73    case GL_LESS:
  74       current->hwAlpha |= SiS_ALPHA_LESS;
  75       break;
  76    case GL_EQUAL:
  77       current->hwAlpha |= SiS_ALPHA_EQUAL;
  78       break;
  79    case GL_LEQUAL:
  80       current->hwAlpha |= SiS_ALPHA_LEQUAL;
  81       break;
  82    case GL_GREATER:
  83       current->hwAlpha |= SiS_ALPHA_GREATER;
  84       break;
  85    case GL_NOTEQUAL:
  86       current->hwAlpha |= SiS_ALPHA_NOTEQUAL;
  87       break;
  88    case GL_GEQUAL:
  89       current->hwAlpha |= SiS_ALPHA_GEQUAL;
  90       break;
  91    case GL_ALWAYS:
  92       current->hwAlpha |= SiS_ALPHA_ALWAYS;
  93       break;
  94    }
  95
  96    prev->hwAlpha = current->hwAlpha;
  97    smesa->GlobalFlag |= GFLAG_ALPHASETTING;
  98 }
  99
 100 static void
 101 sisDDBlendFuncSeparate( GLcontext *ctx,
 102                         GLenum sfactorRGB, GLenum dfactorRGB,
 103                         GLenum sfactorA,   GLenum dfactorA )
 104 {
 105    sisContextPtr smesa = SIS_CONTEXT(ctx);
 106
 107    __GLSiSHardware *prev = &smesa->prev;
 108    __GLSiSHardware *current = &smesa->current;
 109
 110    current->hwDstSrcBlend = 0;
 111
 112    switch (dfactorRGB)
 113    {
 114    case GL_ZERO:
 115       current->hwDstSrcBlend |= SiS_D_ZERO;
 116       break;
 117    case GL_ONE:
 118       current->hwDstSrcBlend |= SiS_D_ONE;
 119       break;
 120    case GL_SRC_COLOR:
 121       current->hwDstSrcBlend |= SiS_D_SRC_COLOR;
 122       break;
 123    case GL_ONE_MINUS_SRC_COLOR:
 124       current->hwDstSrcBlend |= SiS_D_ONE_MINUS_SRC_COLOR;
 125       break;
 126    case GL_SRC_ALPHA:
 127       current->hwDstSrcBlend |= SiS_D_SRC_ALPHA;
 128       break;
 129    case GL_ONE_MINUS_SRC_ALPHA:
 130       current->hwDstSrcBlend |= SiS_D_ONE_MINUS_SRC_ALPHA;
 131       break;
 132    case GL_DST_COLOR:
 133       current->hwDstSrcBlend |= SiS_D_DST_COLOR;
 134       break;
 135    case GL_ONE_MINUS_DST_COLOR:
 136       current->hwDstSrcBlend |= SiS_D_ONE_MINUS_DST_COLOR;
 137       break;
 138    case GL_DST_ALPHA:
 139       current->hwDstSrcBlend |= SiS_D_DST_ALPHA;
 140       break;
 141    case GL_ONE_MINUS_DST_ALPHA:
 142       current->hwDstSrcBlend |= SiS_D_ONE_MINUS_DST_ALPHA;
 143       break;
 144    default:
 145       fprintf(stderr, "Unknown dst blend function 0x%x\n", dfactorRGB);
 146       break;
 147    }
 148
 149    switch (sfactorRGB)
 150    {
 151    case GL_ZERO:
 152       current->hwDstSrcBlend |= SiS_S_ZERO;
 153       break;
 154    case GL_ONE:
 155       current->hwDstSrcBlend |= SiS_S_ONE;
 156       break;
 157    case GL_SRC_COLOR:
 158       current->hwDstSrcBlend |= SiS_S_SRC_COLOR;
 159       break;
 160    case GL_ONE_MINUS_SRC_COLOR:
 161       current->hwDstSrcBlend |= SiS_S_ONE_MINUS_SRC_COLOR;
 162       break;
 163    case GL_SRC_ALPHA:
 164       current->hwDstSrcBlend |= SiS_S_SRC_ALPHA;
 165       break;
 166    case GL_ONE_MINUS_SRC_ALPHA:
 167       current->hwDstSrcBlend |= SiS_S_ONE_MINUS_SRC_ALPHA;
 168       break;
 169    case GL_DST_COLOR:
 170       current->hwDstSrcBlend |= SiS_S_DST_COLOR;
 171       break;
 172    case GL_ONE_MINUS_DST_COLOR:
 173       current->hwDstSrcBlend |= SiS_S_ONE_MINUS_DST_COLOR;
 174       break;
 175    case GL_DST_ALPHA:
 176       current->hwDstSrcBlend |= SiS_S_DST_ALPHA;
 177       break;
 178    case GL_ONE_MINUS_DST_ALPHA:
 179       current->hwDstSrcBlend |= SiS_S_ONE_MINUS_DST_ALPHA;
 180       break;
 181    case GL_SRC_ALPHA_SATURATE:
 182       current->hwDstSrcBlend |= SiS_S_SRC_ALPHA_SATURATE;
 183       break;
 184    default:
 185       fprintf(stderr, "Unknown src blend function 0x%x\n", sfactorRGB);
 186       break;
 187    }
 188
 189    if (current->hwDstSrcBlend != prev->hwDstSrcBlend) {
 190       prev->hwDstSrcBlend = current->hwDstSrcBlend;
 191       smesa->GlobalFlag |= GFLAG_DSTBLEND;
 192    }
 193 }
 194
 195 /* =============================================================
 196  * Depth testing
 197  */
 198
 199 static void
 200 sisDDDepthFunc( GLcontext * ctx, GLenum func )
 201 {
 202    sisContextPtr smesa = SIS_CONTEXT(ctx);
 203    __GLSiSHardware *prev = &smesa->prev;
 204    __GLSiSHardware *current = &smesa->current;
 205
 206    current->hwZ &= ~MASK_ZTestMode;
 207    switch (func)
 208    {
 209    case GL_LESS:
 210       current->hwZ |= SiS_Z_COMP_S_LT_B;
 211       break;
 212    case GL_GEQUAL:
 213       current->hwZ |= SiS_Z_COMP_S_GE_B;
 214       break;
 215    case GL_LEQUAL:
 216       current->hwZ |= SiS_Z_COMP_S_LE_B;
 217       break;
 218    case GL_GREATER:
 219       current->hwZ |= SiS_Z_COMP_S_GT_B;
 220       break;
 221    case GL_NOTEQUAL:
 222       current->hwZ |= SiS_Z_COMP_S_NE_B;
 223       break;
 224    case GL_EQUAL:
 225       current->hwZ |= SiS_Z_COMP_S_EQ_B;
 226       break;
 227    case GL_ALWAYS:
 228       current->hwZ |= SiS_Z_COMP_ALWAYS;
 229       break;
 230    case GL_NEVER:
 231       current->hwZ |= SiS_Z_COMP_NEVER;
 232       break;
 233    }
 234
 235    if (current->hwZ != prev->hwZ) {
 236       prev->hwZ = current->hwZ;
 237       smesa->GlobalFlag |= GFLAG_ZSETTING;
 238    }
 239 }
 240
 241 void
 242 sisDDDepthMask( GLcontext * ctx, GLboolean flag )
 243 {
 244    sisContextPtr smesa = SIS_CONTEXT(ctx);
 245    __GLSiSHardware *prev = &smesa->prev;
 246    __GLSiSHardware *current = &smesa->current;
 247
 248    if (!ctx->Depth.Test)
 249       flag = GL_FALSE;
 250
 251    if (ctx->Visual.stencilBits) {
 252       if (flag || (ctx->Stencil.WriteMask[0] != 0)) {
 253          current->hwCapEnable |= MASK_ZWriteEnable;
 254          if (flag && ((ctx->Stencil.WriteMask[0] & 0xff) == 0xff)) {
 255               current->hwCapEnable2 &= ~MASK_ZMaskWriteEnable;
 256          } else {
 257             current->hwCapEnable2 |= MASK_ZMaskWriteEnable;
 258             current->hwZMask = (ctx->Stencil.WriteMask[0] << 24) |
 259                ((flag) ? 0x00ffffff : 0);
 260
 261             if (current->hwZMask ^ prev->hwZMask) {
 262                prev->hwZMask = current->hwZMask;
 263                smesa->GlobalFlag |= GFLAG_ZSETTING;
 264             }
 265          }
 266       } else {
 267          current->hwCapEnable &= ~MASK_ZWriteEnable;
 268       }
 269    } else {
 270       if (flag) {
 271          current->hwCapEnable |= MASK_ZWriteEnable;
 272          current->hwCapEnable2 &= ~MASK_ZMaskWriteEnable;
 273       } else {
 274          current->hwCapEnable &= ~MASK_ZWriteEnable;
 275       }
 276    }
 277 }
 278
 279 /* =============================================================
 280  * Clipping
 281  */
 282
 283 void
 284 sisUpdateClipping( GLcontext *ctx )
 285 {
 286    sisContextPtr smesa = SIS_CONTEXT(ctx);
 287
 288    __GLSiSHardware *prev = &smesa->prev;
 289    __GLSiSHardware *current = &smesa->current;
 290
 291    GLint x1, y1, x2, y2;
 292
 293    if (smesa->is6326) {
 294       /* XXX: 6326 has its own clipping for now. Should be fixed */
 295       sis6326UpdateClipping(ctx);
 296       return;
 297    }
 298
 299    x1 = 0;
 300    y1 = 0;
 301    x2 = smesa->width - 1;
 302    y2 = smesa->height - 1;
 303
 304    if (ctx->Scissor.Enabled) {
 305       if (ctx->Scissor.X > x1)
 306          x1 = ctx->Scissor.X;
 307       if (ctx->Scissor.Y > y1)
 308          y1 = ctx->Scissor.Y;
 309       if (ctx->Scissor.X + ctx->Scissor.Width - 1 < x2)
 310          x2 = ctx->Scissor.X + ctx->Scissor.Width - 1;
 311       if (ctx->Scissor.Y + ctx->Scissor.Height - 1 < y2)
 312          y2 = ctx->Scissor.Y + ctx->Scissor.Height - 1;
 313    }
 314
 315    y1 = Y_FLIP(y1);
 316    y2 = Y_FLIP(y2);
 317
 318    current->clipTopBottom = (y2 << 13) | y1;
 319    current->clipLeftRight = (x1 << 13) | x2;
 320
 321    if ((current->clipTopBottom ^ prev->clipTopBottom) ||
 322        (current->clipLeftRight ^ prev->clipLeftRight))
 323    {
 324       prev->clipTopBottom = current->clipTopBottom;
 325       prev->clipLeftRight = current->clipLeftRight;
 326       smesa->GlobalFlag |= GFLAG_CLIPPING;
 327    }
 328 }
 329
 330 static void
 331 sisDDScissor( GLcontext *ctx, GLint x, GLint y, GLsizei w, GLsizei h )
 332 {
 333    if (ctx->Scissor.Enabled)
 334       sisUpdateClipping( ctx );
 335 }
 336
 337 /* =============================================================
 338  * Culling
 339  */
 340
 341 static void
 342 sisUpdateCull( GLcontext *ctx )
 343 {
 344    sisContextPtr smesa = SIS_CONTEXT(ctx);
 345    GLint cullflag, frontface;
 346
 347    cullflag = ctx->Polygon.CullFaceMode;
 348    frontface = ctx->Polygon.FrontFace;
 349
 350    smesa->AGPParseSet &= ~(MASK_PsCullDirection_CCW);
 351    smesa->dwPrimitiveSet &= ~(MASK_CullDirection);
 352
 353    if((cullflag == GL_FRONT && frontface == GL_CCW) ||
 354       (cullflag == GL_BACK && frontface == GL_CW))
 355    {
 356       smesa->AGPParseSet |= MASK_PsCullDirection_CCW;
 357       smesa->dwPrimitiveSet |= OP_3D_CullDirection_CCW;
 358    }
 359 }
 360
 361
 362 static void
 363 sisDDCullFace( GLcontext *ctx, GLenum mode )
 364 {
 365    sisUpdateCull( ctx );
 366 }
 367
 368 static void
 369 sisDDFrontFace( GLcontext *ctx, GLenum mode )
 370 {
 371    sisUpdateCull( ctx );
 372 }
 373
 374 /* =============================================================
 375  * Masks
 376  */
 377
 378 static void sisDDColorMask( GLcontext *ctx,
 379                             GLboolean r, GLboolean g,
 380                             GLboolean b, GLboolean a )
 381 {
 382    sisContextPtr smesa = SIS_CONTEXT(ctx);
 383    __GLSiSHardware *prev = &smesa->prev;
 384    __GLSiSHardware *current = &smesa->current;
 385
 386    if (r && g && b && ((ctx->Visual.alphaBits == 0) || a)) {
 387       current->hwCapEnable2 &= ~(MASK_AlphaMaskWriteEnable |
 388                                  MASK_ColorMaskWriteEnable);
 389    } else {
 390       current->hwCapEnable2 |= (MASK_AlphaMaskWriteEnable |
 391                              MASK_ColorMaskWriteEnable);
 392
 393       current->hwDstMask = (r) ? smesa->redMask : 0 |
 394                            (g) ? smesa->greenMask : 0 |
 395                            (b) ? smesa->blueMask : 0 |
 396                            (a) ? smesa->alphaMask : 0;
 397    }
 398
 399    if (current->hwDstMask != prev->hwDstMask) {
 400       prev->hwDstMask = current->hwDstMask;
 401       smesa->GlobalFlag |= GFLAG_DESTSETTING;
 402    }
 403 }
 404
 405 /* =============================================================
 406  * Rendering attributes
 407  */
 408
 409 static void sisUpdateSpecular(GLcontext *ctx)
 410 {
 411    sisContextPtr smesa = SIS_CONTEXT(ctx);
 412    __GLSiSHardware *current = &smesa->current;
 413
 414    if (NEED_SECONDARY_COLOR(ctx))
 415       current->hwCapEnable |= MASK_SpecularEnable;
 416    else
 417       current->hwCapEnable &= ~MASK_SpecularEnable;
 418 }
 419
 420 static void sisDDLightModelfv(GLcontext *ctx, GLenum pname,
 421                               const GLfloat *param)
 422 {
 423    if (pname == GL_LIGHT_MODEL_COLOR_CONTROL) {
 424       sisUpdateSpecular(ctx);
 425    }
 426 }
 427
 428 static void sisDDShadeModel( GLcontext *ctx, GLenum mode )
 429 {
 430    sisContextPtr smesa = SIS_CONTEXT(ctx);
 431
 432    /* Signal to sisRasterPrimitive to recalculate dwPrimitiveSet */
 433    smesa->hw_primitive = -1;
 434 }
 435
 436 /* =============================================================
 437  * Window position
 438  */
 439
 440 /* =============================================================
 441  * Viewport
 442  */
 443
 444 static void sisCalcViewport( GLcontext *ctx )
 445 {
 446    sisContextPtr smesa = SIS_CONTEXT(ctx);
 447    const GLfloat *v = ctx->Viewport._WindowMap.m;
 448    GLfloat *m = smesa->hw_viewport;
 449
 450    /* See also sis_translate_vertex.
 451     */
 452    m[MAT_SX] =   v[MAT_SX];
 453    m[MAT_TX] =   v[MAT_TX] + SUBPIXEL_X;
 454    m[MAT_SY] = - v[MAT_SY];
 455    m[MAT_TY] = - v[MAT_TY] + smesa->driDrawable->h + SUBPIXEL_Y;
 456    m[MAT_SZ] =   v[MAT_SZ] * smesa->depth_scale;
 457    m[MAT_TZ] =   v[MAT_TZ] * smesa->depth_scale;
 458 }
 459
 460 static void sisDDViewport( GLcontext *ctx,
 461                            GLint x, GLint y,
 462                            GLsizei width, GLsizei height )
 463 {
 464    sisCalcViewport( ctx );
 465 }
 466
 467 static void sisDDDepthRange( GLcontext *ctx,
 468                              GLclampd nearval, GLclampd farval )
 469 {
 470    sisCalcViewport( ctx );
 471 }
 472
 473 /* =============================================================
 474  * Miscellaneous
 475  */
 476
 477 static void
 478 sisDDLogicOpCode( GLcontext *ctx, GLenum opcode )
 479 {
 480    sisContextPtr smesa = SIS_CONTEXT(ctx);
 481
 482    __GLSiSHardware *prev = &smesa->prev;
 483    __GLSiSHardware *current = &smesa->current;
 484
 485    current->hwDstSet &= ~MASK_ROP2;
 486    switch (opcode)
 487    {
 488    case GL_CLEAR:
 489       current->hwDstSet |= LOP_CLEAR;
 490       break;
 491    case GL_SET:
 492       current->hwDstSet |= LOP_SET;
 493       break;
 494    case GL_COPY:
 495       current->hwDstSet |= LOP_COPY;
 496       break;
 497    case GL_COPY_INVERTED:
 498       current->hwDstSet |= LOP_COPY_INVERTED;
 499       break;
 500    case GL_NOOP:
 501       current->hwDstSet |= LOP_NOOP;
 502       break;
 503    case GL_INVERT:
 504       current->hwDstSet |= LOP_INVERT;
 505       break;
 506    case GL_AND:
 507       current->hwDstSet |= LOP_AND;
 508       break;
 509    case GL_NAND:
 510       current->hwDstSet |= LOP_NAND;
 511       break;
 512    case GL_OR:
 513       current->hwDstSet |= LOP_OR;
 514       break;
 515    case GL_NOR:
 516       current->hwDstSet |= LOP_NOR;
 517       break;
 518    case GL_XOR:
 519       current->hwDstSet |= LOP_XOR;
 520       break;
 521    case GL_EQUIV:
 522       current->hwDstSet |= LOP_EQUIV;
 523       break;
 524    case GL_AND_REVERSE:
 525       current->hwDstSet |= LOP_AND_REVERSE;
 526       break;
 527    case GL_AND_INVERTED:
 528       current->hwDstSet |= LOP_AND_INVERTED;
 529       break;
 530    case GL_OR_REVERSE:
 531       current->hwDstSet |= LOP_OR_REVERSE;
 532       break;
 533    case GL_OR_INVERTED:
 534       current->hwDstSet |= LOP_OR_INVERTED;
 535       break;
 536    }
 537
 538    if (current->hwDstSet ^ prev->hwDstSet) {
 539       prev->hwDstSet = current->hwDstSet;
 540       smesa->GlobalFlag |= GFLAG_DESTSETTING;
 541    }
 542 }
 543
 544 void sisDDDrawBuffer( GLcontext *ctx, GLenum mode )
 545 {
 546    sisContextPtr smesa = SIS_CONTEXT(ctx);
 547    __GLSiSHardware *prev = &smesa->prev;
 548    __GLSiSHardware *current = &smesa->current;
 549
 550    if (ctx->DrawBuffer->_NumColorDrawBuffers != 1) {
 551       FALLBACK( smesa, SIS_FALLBACK_DRAW_BUFFER, GL_TRUE );
 552       return;
 553    }
 554
 555    current->hwDstSet &= ~MASK_DstBufferPitch;
 556    switch ( ctx->DrawBuffer->_ColorDrawBufferIndexes[0] ) {
 557    case BUFFER_FRONT_LEFT:
 558       FALLBACK( smesa, SIS_FALLBACK_DRAW_BUFFER, GL_FALSE );
 559       current->hwOffsetDest = smesa->front.offset >> 1;
 560       current->hwDstSet |= smesa->front.pitch >> 2;
 561       break;
 562    case BUFFER_BACK_LEFT:
 563       FALLBACK( smesa, SIS_FALLBACK_DRAW_BUFFER, GL_FALSE );
 564       current->hwOffsetDest = smesa->back.offset >> 1;
 565       current->hwDstSet |= smesa->back.pitch >> 2;
 566       break;
 567    default:
 568       FALLBACK( smesa, SIS_FALLBACK_DRAW_BUFFER, GL_TRUE );
 569       return;
 570    }
 571
 572    if (current->hwDstSet != prev->hwDstSet) {
 573       prev->hwDstSet = current->hwDstSet;
 574       smesa->GlobalFlag |= GFLAG_DESTSETTING;
 575    }
 576
 577    if (current->hwOffsetDest != prev->hwOffsetDest) {
 578       prev->hwOffsetDest = current->hwOffsetDest;
 579       smesa->GlobalFlag |= GFLAG_DESTSETTING;
 580    }
 581 }
 582
 583 /* =============================================================
 584  * Polygon stipple
 585  */
 586
 587 /* =============================================================
 588  * Render mode
 589  */
 590
 591 /* =============================================================
 592  * State enable/disable
 593  */
 594
 595 static void
 596 sisDDEnable( GLcontext * ctx, GLenum cap, GLboolean state )
 597 {
 598    sisContextPtr smesa = SIS_CONTEXT(ctx);
 599
 600    __GLSiSHardware *current = &smesa->current;
 601
 602    switch (cap)
 603    {
 604    case GL_ALPHA_TEST:
 605       if (state)
 606          current->hwCapEnable |= MASK_AlphaTestEnable;
 607       else
 608          current->hwCapEnable &= ~MASK_AlphaTestEnable;
 609       break;
 610    case GL_BLEND:
 611       /* TODO: */
 612       if (state)
 613       /* if (state & !ctx->Color.ColorLogicOpEnabled) */
 614          current->hwCapEnable |= MASK_BlendEnable;
 615       else
 616          current->hwCapEnable &= ~MASK_BlendEnable;
 617       break;
 618    case GL_CULL_FACE:
 619       if (state)
 620          current->hwCapEnable |= MASK_CullEnable;
 621       else
 622          current->hwCapEnable &= ~MASK_CullEnable;
 623       break;
 624    case GL_DEPTH_TEST:
 625       if (state && smesa->depth.offset != 0)
 626          current->hwCapEnable |= MASK_ZTestEnable;
 627       else
 628          current->hwCapEnable &= ~MASK_ZTestEnable;
 629       sisDDDepthMask( ctx, ctx->Depth.Mask );
 630       break;
 631    case GL_DITHER:
 632       if (state)
 633          current->hwCapEnable |= MASK_DitherEnable;
 634       else
 635          current->hwCapEnable &= ~MASK_DitherEnable;
 636       break;
 637    case GL_FOG:
 638       if (state)
 639          current->hwCapEnable |= MASK_FogEnable;
 640       else
 641          current->hwCapEnable &= ~MASK_FogEnable;
 642       break;
 643    case GL_COLOR_LOGIC_OP:
 644       if (state)
 645          sisDDLogicOpCode( ctx, ctx->Color.LogicOp );
 646       else
 647          sisDDLogicOpCode( ctx, GL_COPY );
 648       break;
 649    case GL_SCISSOR_TEST:
 650       sisUpdateClipping( ctx );
 651       break;
 652    case GL_STENCIL_TEST:
 653       if (state) {
 654          if (smesa->zFormat != SiS_ZFORMAT_S8Z24)
 655             FALLBACK(smesa, SIS_FALLBACK_STENCIL, 1);
 656          else
 657             current->hwCapEnable |= (MASK_StencilTestEnable |
 658                                      MASK_StencilWriteEnable);
 659       } else {
 660          FALLBACK(smesa, SIS_FALLBACK_STENCIL, 0);
 661          current->hwCapEnable &= ~(MASK_StencilTestEnable |
 662                                    MASK_StencilWriteEnable);
 663       }
 664       break;
 665    case GL_LIGHTING:
 666    case GL_COLOR_SUM_EXT:
 667       sisUpdateSpecular(ctx);
 668       break;
 669    }
 670 }
 671
 672
 673 /* =============================================================
 674  * State initialization, management
 675  */
 676
 677 /* Called before beginning of rendering. */
 678 void
 679 sisUpdateHWState( GLcontext *ctx )
 680 {
 681    sisContextPtr smesa = SIS_CONTEXT(ctx);
 682    __GLSiSHardware *prev = &smesa->prev;
 683    __GLSiSHardware *current = &smesa->current;
 684
 685    /* enable setting 1 */
 686    if (current->hwCapEnable ^ prev->hwCapEnable) {
 687       prev->hwCapEnable = current->hwCapEnable;
 688       smesa->GlobalFlag |= GFLAG_ENABLESETTING;
 689    }
 690
 691   /* enable setting 2 */
 692    if (current->hwCapEnable2 ^ prev->hwCapEnable2) {
 693       prev->hwCapEnable2 = current->hwCapEnable2;
 694       smesa->GlobalFlag |= GFLAG_ENABLESETTING2;
 695    }
 696
 697    if (smesa->GlobalFlag & GFLAG_RENDER_STATES)
 698       sis_update_render_state( smesa );
 699
 700    if (smesa->GlobalFlag & GFLAG_TEXTURE_STATES)
 701       sis_update_texture_state( smesa );
 702 }
 703
 704 static void
 705 sisDDInvalidateState( GLcontext *ctx, GLuint new_state )
 706 {
 707    sisContextPtr smesa = SIS_CONTEXT(ctx);
 708
 709    _swrast_InvalidateState( ctx, new_state );
 710    _swsetup_InvalidateState( ctx, new_state );
 711    _vbo_InvalidateState( ctx, new_state );
 712    _tnl_InvalidateState( ctx, new_state );
 713    smesa->NewGLState |= new_state;
 714 }
 715
 716 /* Initialize the context's hardware state.
 717  */
 718 void sisDDInitState( sisContextPtr smesa )
 719 {
 720    __GLSiSHardware *current = &smesa->current;
 721    __GLSiSHardware *prev = &(smesa->prev);
 722    GLcontext *ctx = smesa->glCtx;
 723
 724    /* add Texture Perspective Enable */
 725    prev->hwCapEnable = MASK_FogPerspectiveEnable | MASK_TextureCacheEnable |
 726       MASK_TexturePerspectiveEnable | MASK_DitherEnable;
 727
 728    /*
 729    prev->hwCapEnable2 = 0x00aa0080;
 730    */
 731    /* if multi-texture enabled, disable Z pre-test */
 732    prev->hwCapEnable2 = MASK_TextureMipmapBiasEnable;
 733
 734    /* Z test mode is LESS */
 735    prev->hwZ = SiS_Z_COMP_S_LT_B;
 736
 737    /* Depth mask */
 738    prev->hwZMask = 0xffffffff;
 739
 740    /* Alpha test mode is ALWAYS, alpha ref value is 0 */
 741    prev->hwAlpha = SiS_ALPHA_ALWAYS;
 742
 743    /* ROP2 is COPYPEN */
 744    prev->hwDstSet = LOP_COPY;
 745
 746    /* color mask */
 747    prev->hwDstMask = 0xffffffff;
 748
 749    /* LinePattern is 0, Repeat Factor is 0 */
 750    prev->hwLinePattern = 0x00008000;
 751
 752    /* Src blend is BLEND_ONE, Dst blend is D3DBLEND_ZERO */
 753    prev->hwDstSrcBlend = SiS_S_ONE | SiS_D_ZERO;
 754
 755    /* Stenciling disabled, function ALWAYS, ref value zero, mask all ones */
 756    prev->hwStSetting = STENCIL_FORMAT_8 | SiS_STENCIL_ALWAYS | 0xff;
 757    /* Op is KEEP for all three operations */
 758    prev->hwStSetting2 = SiS_SFAIL_KEEP | SiS_SPASS_ZFAIL_KEEP |
 759       SiS_SPASS_ZPASS_KEEP;
 760
 761    /* Texture mapping mode is Tile */
 762 #if 0
 763    prev->texture[0].hwTextureSet = 0x00030000;
 764 #endif
 765    /* Magnified & minified texture filter is NEAREST */
 766 #if 0
 767    prev->texture[0].hwTextureMip = 0;
 768 #endif
 769
 770    /* Texture Blending setting -- use fragment color/alpha*/
 771    prev->hwTexBlendColor0 = STAGE0_C_CF;
 772    prev->hwTexBlendColor1 = STAGE1_C_CF;
 773    prev->hwTexBlendAlpha0 = STAGE0_A_AF;
 774    prev->hwTexBlendAlpha1 = STAGE1_A_AF;
 775
 776    switch (smesa->bytesPerPixel)
 777    {
 778    case 2:
 779       prev->hwDstSet |= DST_FORMAT_RGB_565;
 780       break;
 781    case 4:
 782       prev->hwDstSet |= DST_FORMAT_ARGB_8888;
 783       break;
 784    }
 785
 786    switch (ctx->Visual.depthBits)
 787    {
 788    case 0:
 789       prev->hwCapEnable &= ~MASK_ZWriteEnable;
 790    case 16:
 791       smesa->zFormat = SiS_ZFORMAT_Z16;
 792       prev->hwCapEnable |= MASK_ZWriteEnable;
 793       smesa->depth_scale = 1.0 / (GLfloat)0xffff;
 794       break;
 795    case 32:
 796       smesa->zFormat = SiS_ZFORMAT_Z32;
 797       prev->hwCapEnable |= MASK_ZWriteEnable;
 798       smesa->depth_scale = 1.0 / (GLfloat)0xffffffff;
 799       break;
 800    case 24:
 801       assert (ctx->Visual.stencilBits);
 802       smesa->zFormat = SiS_ZFORMAT_S8Z24;
 803       prev->hwCapEnable |= MASK_StencilBufferEnable;
 804       prev->hwCapEnable |= MASK_ZWriteEnable;
 805       smesa->depth_scale = 1.0 / (GLfloat)0xffffff;
 806       break;
 807    }
 808
 809    prev->hwZ |= smesa->zFormat;
 810
 811    /* TODO: need to clear cache? */
 812    smesa->clearTexCache = GL_TRUE;
 813
 814    smesa->clearColorPattern = 0;
 815
 816    smesa->AGPParseSet = MASK_PsTexture1FromB | MASK_PsBumpTextureFromC;
 817    smesa->dwPrimitiveSet = OP_3D_Texture1FromB | OP_3D_TextureBumpFromC;
 818
 819    sisUpdateZStencilPattern( smesa, 1.0, 0 );
 820    sisUpdateCull( ctx );
 821
 822    memcpy( current, prev, sizeof (__GLSiSHardware) );
 823
 824    /* Set initial fog settings. Start and end are the same case.  */
 825    sisDDFogfv( ctx, GL_FOG_DENSITY, &ctx->Fog.Density );
 826    sisDDFogfv( ctx, GL_FOG_END, &ctx->Fog.End );
 827    sisDDFogfv( ctx, GL_FOG_COORDINATE_SOURCE_EXT, NULL );
 828    sisDDFogfv( ctx, GL_FOG_MODE, NULL );
 829 }
 830
 831 /* Initialize the driver's state functions.
 832  */
 833 void sisDDInitStateFuncs( GLcontext *ctx )
 834 {
 835    ctx->Driver.UpdateState       = sisDDInvalidateState;
 836
 837    ctx->Driver.Clear             = sisDDClear;
 838    ctx->Driver.ClearColor        = sisDDClearColor;
 839    ctx->Driver.ClearDepth        = sisDDClearDepth;
 840    ctx->Driver.ClearStencil      = sisDDClearStencil;
 841
 842    ctx->Driver.AlphaFunc         = sisDDAlphaFunc;
 843    ctx->Driver.BlendFuncSeparate = sisDDBlendFuncSeparate;
 844    ctx->Driver.ColorMask         = sisDDColorMask;
 845    ctx->Driver.CullFace          = sisDDCullFace;
 846    ctx->Driver.DepthMask         = sisDDDepthMask;
 847    ctx->Driver.DepthFunc         = sisDDDepthFunc;
 848    ctx->Driver.DepthRange        = sisDDDepthRange;
 849    ctx->Driver.DrawBuffer        = sisDDDrawBuffer;
 850    ctx->Driver.Enable            = sisDDEnable;
 851    ctx->Driver.FrontFace         = sisDDFrontFace;
 852    ctx->Driver.Fogfv             = sisDDFogfv;
 853    ctx->Driver.Hint              = NULL;
 854    ctx->Driver.Lightfv           = NULL;
 855    ctx->Driver.LogicOpcode       = sisDDLogicOpCode;
 856    ctx->Driver.PolygonMode       = NULL;
 857    ctx->Driver.PolygonStipple    = NULL;
 858    ctx->Driver.ReadBuffer        = NULL;
 859    ctx->Driver.RenderMode        = NULL;
 860    ctx->Driver.Scissor           = sisDDScissor;
 861    ctx->Driver.ShadeModel        = sisDDShadeModel;
 862    ctx->Driver.LightModelfv      = sisDDLightModelfv;
 863    ctx->Driver.Viewport          = sisDDViewport;
 864
 865    /* XXX this should go away */
 866    ctx->Driver.ResizeBuffers     = sisReAllocateBuffers;
 867 }